semantic_logger 5.0.0 → 5.2.0

data/lib/semantic_logger/appender/new_relic_logs.rb

@@ -48,7 +48,8 @@ module SemanticLogger
       def initialize(formatter: SemanticLogger::Formatters::NewRelicLogs.new, **args, &block)
         super
 
-        # Record NewRelic's "trace.id"/"entity.name"/"hostname"/etc, so we can include them later in the formatted output.
+        # Record NewRelic's "trace.id"/"entity.name"/"hostname"/etc, so we can include them
+        # later in the formatted output.
         # These are thread-local, so need to be captured as soon as the log-message is created.
         # https://rubydoc.info/gems/newrelic_rpm/NewRelic/Agent#linking_metadata-instance_method
         SemanticLogger.on_log(CAPTURE_CONTEXT)
@@ -56,17 +57,15 @@ module SemanticLogger
 
       # Send an error notification to New Relic
       def log(log)
-        begin
-          message = formatter.call(log, self) # Generate the structured log
-          json_message = Utils.to_json(message) # Convert the log to JSON, repairing any non UTF-8 data
-          level = log.level.to_s.upcase # Determine the log level
-          self.class.log_newrelic(json_message, level)
-        rescue JSON::GeneratorError => e
-          warn("Failed to serialize log message to JSON: #{e.message}")
-          warn("Problematic data: #{message.inspect}")
-        rescue StandardError => e
-          warn("Unexpected error while logging to New Relic: #{e.message}")
-        end
+        message      = format_log(log) # Generate the structured log
+        json_message = Utils.to_json(message) # Convert the log to JSON, repairing any non UTF-8 data
+        level        = log.level.to_s.upcase # Determine the log level
+        self.class.log_newrelic(json_message, level)
+        true
+      rescue StandardError => e
+        # Reported to the internal logger: this appender's own #warn would log the error through
+        # this method again, recursing until SystemStackError.
+        logger.warn("Could not log to New Relic", e)
         true
       end
 

data/lib/semantic_logger/appender/open_telemetry.rb

@@ -2,7 +2,8 @@ begin
   require "opentelemetry/logs"
 rescue LoadError
   raise LoadError,
-        'Gem opentelemetry-logs-sdk is required for logging to Open Telemetry. Please add the gem "opentelemetry-logs-sdk" to your Gemfile.'
+        "Gem opentelemetry-logs-sdk is required for logging to Open Telemetry. " \
+        'Please add the gem "opentelemetry-logs-sdk" to your Gemfile.'
 end
 
 # Open Telemetry Appender
@@ -47,7 +48,7 @@ module SemanticLogger
       def log(log)
         # return log_metric(log) if metrics && log.metric_only?
 
-        body        = formatter.call(log, self)
+        body        = format_log(log)
         level       = body.delete(:level)
         level_index = body.delete(:level_index)
         time        = body.delete(:time)
@@ -88,7 +89,7 @@ module SemanticLogger
       # For logging metrics only log events.
       # def log_metric(log)
       #   puts "**** TODO: Metric Only Event ****"
-      #   ap formatter.call(log, self)
+      #   ap format_log(log)
       #   ap log.payload
       #   true
       # end

data/lib/semantic_logger/appender/opensearch.rb

@@ -2,7 +2,8 @@ begin
   require "opensearch-ruby"
 rescue LoadError
   raise LoadError,
-        'Gem opensearch-ruby is required for logging to OpenSearch. Please add the gem "opensearch-ruby" to your Gemfile.'
+        "Gem opensearch-ruby is required for logging to OpenSearch. " \
+        'Please add the gem "opensearch-ruby" to your Gemfile.'
 end
 
 require "semantic_logger/appender/elasticsearch_base"

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -81,14 +81,15 @@ module SemanticLogger
       #
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
       def initialize(queue_name: "semantic_logger", rabbitmq_host: nil,
-                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: true,
-                     **args, &)
+                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil,
+                     host: nil, metrics: true, **args, &)
         @queue_name             = queue_name
         @rabbitmq_args          = args.dup
         @rabbitmq_args[:host]   = rabbitmq_host
         @rabbitmq_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &)
+        super(level: level, formatter: formatter, filter: filter, application: application,
+              environment: environment, host: host, metrics: metrics, &)
         reopen
       end
 
@@ -106,7 +107,7 @@ module SemanticLogger
       end
 
       def log(log)
-        queue.publish(formatter.call(log, self))
+        queue.publish(format_log(log))
       end
 
       def flush
@@ -121,6 +122,11 @@ module SemanticLogger
       def queue
         @queue ||= @channel.queue(@queue_name)
       end
+
+      # Only the queue name: the connection options hold the password. See Subscriber#inspect.
+      def inspect_details
+        "queue_name=#{@queue_name.inspect}"
+      end
     end
   end
 end

data/lib/semantic_logger/appender/sentry.rb

@@ -39,6 +39,11 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       def initialize(level: :error, **args, &block)
+        Kernel.warn(
+          "SemanticLogger::Appender::Sentry (appender: :sentry) is deprecated and will be removed in v6. " \
+          "It depends on the end-of-life sentry-raven gem. Use appender: :sentry_ruby instead.",
+          category: :deprecated
+        )
         # Replace the Sentry Raven logger so that we can identify its log messages and not forward them to Sentry
         Raven.configure { |config| config.logger = SemanticLogger[Raven] }
         super
@@ -49,7 +54,7 @@ module SemanticLogger
         # Ignore logs coming from Raven itself
         return false if log.name == "Raven"
 
-        context      = formatter.call(log, self)
+        context      = format_log(log)
         user         = context.delete(:user)
         tags         = context.delete(:tags)
         attrs        = {

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -12,6 +12,15 @@ end
 module SemanticLogger
   module Appender
     class SentryRuby < SemanticLogger::Subscriber
+      # Keys of the named tags or payload that set the Sentry user, mapped to its fields.
+      USER_KEYS = {user_id: :id, username: :username, user_email: :email, ip_address: :ip_address}.freeze
+
+      # The types of value taken from the payload for a field of the Sentry user.
+      USER_VALUE_TYPES = [String, Symbol, Integer].freeze
+
+      # The types of value accepted in a fingerprint, which Sentry turns into Strings.
+      FINGERPRINT_PART_TYPES = [String, Symbol, Numeric].freeze
+
       # Create Appender
       #
       # Parameters
@@ -54,16 +63,19 @@ module SemanticLogger
         # Ignore logs coming from Sentry itself
         return false if log.name == "Sentry"
 
-        context = formatter.call(log, self)
-        payload = context.delete(:payload) || {}
-        named_tags = context[:named_tags] || {}
-        transaction_name = named_tags.delete(:transaction_name)
+        context = format_log(log)
+        # Copies, since the payload and named tags are the log entry's own, which every other
+        # appender writes after this one, and the payload can be the application's own Hash. The
+        # keys taken out below must only be left out of what is sent to Sentry.
+        payload               = payload_copy(context.delete(:payload))
+        named_tags            = (context[:named_tags] || {}).dup
+        context[:named_tags]  = named_tags
+        transaction_name      = named_tags.delete(:transaction_name)
+        fingerprint           = extract_fingerprint!(named_tags) || extract_fingerprint!(payload, from_payload: true)
 
         user = extract_user!(named_tags, payload)
         tags = extract_tags!(context)
 
-        fingerprint = payload.delete(:fingerprint)
-
         ::Sentry.with_scope do |scope|
           scope.set_user(user) if user
           scope.set_level(context.delete(:level)) if context[:level]
@@ -100,26 +112,88 @@ module SemanticLogger
       # Any additional value nested in a :user key will be added, provided any of
       # the above keys is already present.
       #
-      def extract_user!(*sources)
-        keys = {user_id: :id, username: :username, user_email: :email, ip_address: :ip_address}
-
+      # The payload can hold untrusted data, such as a request body, so taking the user from it is
+      # deprecated, and the named tags win: a payload field is only taken when the named tags do not
+      # set it, and its value is a String, Symbol, or Integer. A payload value that is not taken is
+      # left where it is, and sent to Sentry as data.
+      def extract_user!(named_tags, payload)
         user = {}
 
-        sources.each do |source|
-          keys.each do |source_key, target_key|
-            value = source.delete(source_key)
-            user[target_key] = value if value
+        USER_KEYS.each do |source_key, target_key|
+          value = named_tags.delete(source_key)
+          if value
+            user[target_key] = value
+          elsif user_value?(payload[source_key])
+            user[target_key] = payload.delete(source_key)
+            payload_context_deprecated
           end
         end
 
         return if user.empty?
 
-        sources.each do |source|
-          extras = source.delete(:user)
-          user.merge!(extras) if extras.is_a?(Hash)
+        user.merge!(named_tags.delete(:user)) if named_tags[:user].is_a?(Hash)
+        merge_payload_user!(user, payload)
+        user
+      end
+
+      # Adds the fields of a :user Hash in the payload that the user does not have yet, when each of
+      # its keys is a Symbol or String, and each of its values a String, Symbol, or Integer.
+      def merge_payload_user!(user, payload)
+        extras = payload[:user]
+        return unless extras.is_a?(Hash) && extras.all? { |key, value| user_key?(key) && user_value?(value) }
+
+        payload.delete(:user)
+        payload_context_deprecated
+        extras.each do |key, value|
+          user[key.to_sym] = value unless user.key?(key.to_sym) || user.key?(key.to_s)
         end
+      end
 
-        user
+      def user_key?(key)
+        key.is_a?(Symbol) || key.is_a?(String)
+      end
+
+      def user_value?(value)
+        USER_VALUE_TYPES.any? { |type| value.is_a?(type) }
+      end
+
+      # Returns [Array<String>] the fingerprint taken from the named tags or payload, an Array of
+      # Strings, Symbols, or numbers. Returns nil when there is none, or it is of another type, which
+      # is then left where it is and sent to Sentry as data. As for the user, taking it from the
+      # payload is deprecated.
+      def extract_fingerprint!(source, from_payload: false)
+        fingerprint = source[:fingerprint]
+        return unless fingerprint.is_a?(Array) && fingerprint.all? { |part| fingerprint_part?(part) }
+
+        payload_context_deprecated if from_payload
+        source.delete(:fingerprint).map(&:to_s)
+      end
+
+      def fingerprint_part?(part)
+        FINGERPRINT_PART_TYPES.any? { |type| part.is_a?(type) }
+      end
+
+      # Returns [Hash] a copy of the payload that keys can be taken out of. A payload that is not a
+      # Hash is sent to Sentry as the extra named payload.
+      def payload_copy(payload)
+        case payload
+        when nil  then {}
+        when Hash then payload.dup
+        else {payload: payload}
+        end
+      end
+
+      # Warns once that the Sentry user or fingerprint was taken from the payload.
+      def payload_context_deprecated
+        return if @payload_context_deprecated
+
+        @payload_context_deprecated = true
+        Kernel.warn(
+          "SemanticLogger::Appender::SentryRuby took the Sentry user or fingerprint from the log payload. " \
+          "This is deprecated and will be removed in v6, since the payload can hold untrusted data: " \
+          "set them with named tags instead, for example SemanticLogger.tagged(user_id: user.id).",
+          category: :deprecated
+        )
       end
 
       # Extract tags.

data/lib/semantic_logger/appender/splunk.rb

@@ -9,6 +9,10 @@ end
 #
 # Use the official splunk gem to log messages to Splunk.
 #
+# Deprecated: will be removed in v6. Use the :splunk_http appender instead.
+# The splunk-sdk-ruby gem (last released in 2015) does not verify the server's TLS certificate,
+# so its connection, including the login credentials, is open to interception.
+#
 # Example
 #   SemanticLogger.add_appender(
 #     appender: :splunk,
@@ -90,6 +94,11 @@ module SemanticLogger
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       def initialize(index: "main", source_type: nil, **args, &)
+        Kernel.warn(
+          "SemanticLogger::Appender::Splunk (appender: :splunk) is deprecated and will be removed in v6. " \
+          "Its splunk-sdk-ruby gem does not verify TLS certificates. Use appender: :splunk_http instead.",
+          category: :deprecated
+        )
         @index       = index
         @source_type = source_type
 
@@ -109,7 +118,7 @@ module SemanticLogger
 
       # Log the message to Splunk
       def log(log)
-        event = formatter.call(log, self)
+        event = format_log(log)
         service_index.submit(event.delete(:message), event)
         true
       end

data/lib/semantic_logger/appender/syslog.rb

@@ -1,4 +1,3 @@
-require "syslog"
 require "uri"
 require "socket"
 # Send log messages to local syslog, or remote syslog servers over TCP or UDP.
@@ -78,7 +77,7 @@ module SemanticLogger
       #     Default: 1024 bytes
       #
       #   options: [Integer]
-      #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+      #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS (when logging to a local syslog daemon)
       #     Any of the following (options can be logically OR'd together)
       #       ::Syslog::LOG_CONS
       #       ::Syslog::LOG_NDELAY
@@ -91,7 +90,7 @@ module SemanticLogger
       #        I.e. When `url: 'syslog://localhost'`
       #
       #   facility: [Integer]
-      #     Default: ::Syslog::LOG_USER
+      #     Default: ::Syslog::LOG_USER (the same value as SemanticLogger::Formatters::Syslog::LOG_USER)
       #     Type of program (can be logically OR'd together)
       #       ::Syslog::LOG_AUTH
       #       ::Syslog::LOG_AUTHPRIV
@@ -124,19 +123,19 @@ module SemanticLogger
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
       def initialize(url: "syslog://localhost",
-                     facility: ::Syslog::LOG_USER,
-                     max_size: 1024,
+                     facility: SemanticLogger::Formatters::Syslog::LOG_USER,
+                     max_size: SemanticLogger::Formatters::Syslog::DEFAULT_MAX_SIZE,
                      level_map: SemanticLogger::Formatters::Syslog::LevelMap.new,
-                     options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
+                     options: nil,
                      tcp_client: {},
                      **args,
                      &)
         @options            = options
         @facility           = facility
         @max_size           = max_size
-        @level_map          = level_map
+        @level_map          = SemanticLogger::Formatters::Syslog::LevelMap.build(level_map)
         @url                = url
-        uri                 = URI(@url)
+        uri                 = Utils.parse_url(@url)
         @server             = uri.host || "localhost"
         @protocol           = (uri.scheme || :syslog).to_sym
         @port               = uri.port || 514
@@ -145,26 +144,36 @@ module SemanticLogger
 
         raise "Unknown protocol #{@protocol}!" unless %i[syslog tcp udp].include?(@protocol)
 
-        # The syslog_protocol gem is required when logging over TCP or UDP.
-        if %i[tcp udp].include?(@protocol)
+        # The syslog gem, a bundled gem since Ruby 3.4, is only required when logging to a local syslog daemon.
+        if @protocol == :syslog
           begin
-            require "syslog_protocol"
+            require "syslog"
           rescue LoadError
             raise LoadError,
-                  "Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol"
+                  "Missing gem: syslog. This gem is required when logging to a local syslog daemon on Ruby 3.4 " \
+                  'and later. Please add the gem "syslog" to your Gemfile.'
           end
+          @options ||= ::Syslog::LOG_PID | ::Syslog::LOG_CONS
+        end
 
-          # The net_tcp_client gem is required when logging over TCP.
-          if protocol == :tcp
-            begin
-              require "net/tcp_client"
-            rescue LoadError
-              raise LoadError,
-                    "Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client"
-            end
+        # The net_tcp_client gem is required when logging over TCP.
+        # The syslog formatters load the syslog_protocol gem that they use to build remote syslog packets.
+        if @protocol == :tcp
+          begin
+            require "net/tcp_client"
+          rescue LoadError
+            raise LoadError,
+                  "Missing gem: net_tcp_client. This gem is required when logging over TCP. " \
+                  "To fix this error: gem install net_tcp_client"
           end
         end
 
+        if %i[tcp udp].include?(@protocol)
+          # Reject an invalid facility when the appender is created, even with a formatter that ignores it.
+          SemanticLogger::Formatters::Syslog.facility_number(@facility)
+          args[:formatter] = with_packet_options(args[:formatter]) if args.key?(:formatter)
+        end
+
         super(**args, &)
         reopen
       end
@@ -193,12 +202,12 @@ module SemanticLogger
         case @protocol
         when :syslog
           # Since the Ruby Syslog API supports sprintf format strings, double up all existing '%'
-          message = formatter.call(log, self).gsub "%", "%%"
+          message = format_log(log).gsub "%", "%%"
           ::Syslog.log @level_map[log.level], message
         when :tcp
-          @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{formatter.call(log, self)}\r\n") }
+          @remote_syslog.retry_on_connection_failure { @remote_syslog.write("#{format_log(log)}\r\n") }
         when :udp
-          @remote_syslog.send(formatter.call(log, self), 0, @server, @port)
+          @remote_syslog.send(format_log(log), 0, @server, @port)
         else
           raise "Unsupported protocol: #{protocol}"
         end
@@ -210,16 +219,48 @@ module SemanticLogger
         @remote_syslog.flush if @remote_syslog.respond_to?(:flush)
       end
 
-      # Returns [SemanticLogger::Formatters::Base] default formatter for this Appender depending on the protocal selected
+      # Over UDP, a log message too large for a datagram (Errno::EMSGSIZE) cannot be sent by retrying.
+      def message_error?(exception)
+        (@protocol == :udp && exception.is_a?(Errno::EMSGSIZE)) || super
+      end
+
+      # Returns [SemanticLogger::Formatters::Base] default formatter for this Appender
+      # depending on the protocol selected
       def default_formatter
         if protocol == :syslog
           # Format is text output without the time.
           # Escape control characters so untrusted log data cannot forge syslog entries.
-          SemanticLogger::Formatters::Default.new(time_format: :notime, escape_control_chars: true)
+          # Exception details are off, as with the remote syslog formatters, so existing records do not change.
+          SemanticLogger::Formatters::Default.new(
+            time_format: :notime, escape_control_chars: true, log_exception_details: false
+          )
         else
           SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)
         end
       end
+
+      # The formatters that build remote syslog packets, and so need this appender's facility, level map,
+      # and maximum packet size.
+      PACKET_FORMATTERS = %i[syslog syslog_cee].freeze
+      private_constant :PACKET_FORMATTERS
+
+      # The url without any credentials. See Subscriber#inspect.
+      def inspect_details
+        "url=#{Utils.redacted_url(url).inspect}"
+      end
+
+      private
+
+      # Returns the supplied `formatter:` argument, with this appender's facility, level map, and
+      # maximum packet size added when it names one of the PACKET_FORMATTERS, so that they are not
+      # silently ignored. Options in a
+      # `{syslog: {...}}` Hash take precedence. A formatter instance keeps its own settings.
+      def with_packet_options(formatter)
+        name, options = formatter.is_a?(Hash) ? formatter.first : [formatter, {}]
+        return formatter unless name.respond_to?(:to_sym) && PACKET_FORMATTERS.include?(name.to_sym)
+
+        {name.to_sym => {facility: facility, level_map: level_map, max_size: max_size}.merge(options || {})}
+      end
     end
   end
 end

data/lib/semantic_logger/appender/tcp.rb

@@ -183,8 +183,8 @@ module SemanticLogger
       #     connect_retry_count:    5
       #   )
       def initialize(separator: "\n",
-                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: false,
-                     **tcp_client_args, &)
+                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil,
+                     host: nil, metrics: false, **tcp_client_args, &)
         @separator       = separator
         @tcp_client_args = tcp_client_args
 
@@ -192,7 +192,8 @@ module SemanticLogger
         Net::TCPClient.logger      = logger
         Net::TCPClient.logger.name = "Net::TCPClient"
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &)
+        super(level: level, formatter: formatter, filter: filter, application: application,
+              environment: environment, host: host, metrics: metrics, &)
         reopen
       end
 
@@ -204,7 +205,7 @@ module SemanticLogger
 
       # Write the log using the specified protocol and server.
       def log(log)
-        message = formatter.call(log, self)
+        message = format_log(log)
         @tcp_client.retry_on_connection_failure do
           @tcp_client.write("#{message}#{separator}")
         end
@@ -221,6 +222,11 @@ module SemanticLogger
         @tcp_client&.close
       end
 
+      # Only the servers: the other options can hold TLS keys and passwords. See Subscriber#inspect.
+      def inspect_details
+        "server=#{(@tcp_client_args[:server] || @tcp_client_args[:servers]).inspect}"
+      end
+
       private
 
       # Returns [SemanticLogger::Formatters::Default] formatter default for this Appender

data/lib/semantic_logger/appender/udp.rb

@@ -80,7 +80,7 @@ module SemanticLogger
 
       # Write the log using the specified protocol and server.
       def log(log)
-        @socket.send(formatter.call(log, self), udp_flags)
+        @socket.send(format_log(log), udp_flags)
         true
       end
 
@@ -94,6 +94,16 @@ module SemanticLogger
         @socket&.close
       end
 
+      # A log message too large for a datagram (Errno::EMSGSIZE) cannot be sent by retrying.
+      def message_error?(exception)
+        exception.is_a?(Errno::EMSGSIZE) || super
+      end
+
+      # See Subscriber#inspect.
+      def inspect_details
+        "server=#{server.inspect}"
+      end
+
       private
 
       # Returns [SemanticLogger::Formatters::Default] formatter default for this Appender

data/lib/semantic_logger/appender/wrapper.rb

@@ -45,7 +45,8 @@ module SemanticLogger
         does_not_implement = LEVELS[1..].find { |i| !@logger.respond_to?(i) }
         if does_not_implement
           raise(ArgumentError,
-                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..].inspect}")
+                "Supplied logger does not implement:#{does_not_implement}. " \
+                "It must implement all of #{LEVELS[1..].inspect}")
         end
 
         super(**args, &)
@@ -56,7 +57,7 @@ module SemanticLogger
       #  Ruby or Rails Loggers
       def log(log)
         level = log.level == :trace ? :debug : log.level
-        @logger.send(level, formatter.call(log, self))
+        @logger.send(level, format_log(log))
         true
       end
 

data/lib/semantic_logger/appender.rb

@@ -87,7 +87,8 @@ module SemanticLogger
           appender
         else
           raise(ArgumentError,
-                "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+                "Parameter :appender must be either a Symbol or an object derived from " \
+                "SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
       elsif metric
         if metric.is_a?(Symbol)
@@ -96,11 +97,13 @@ module SemanticLogger
           metric
         else
           raise(ArgumentError,
-                "Parameter :metric must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+                "Parameter :metric must be either a Symbol or an object derived from " \
+                "SemanticLogger::Subscriber, not: #{appender.inspect}")
         end
       else
         raise(ArgumentError,
-              "To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger")
+              "To create an appender it must supply one of the following: " \
+              ":io, :file_name, :appender, :metric, or :logger")
       end
     end
 

data/lib/semantic_logger/appenders.rb

@@ -14,7 +14,8 @@ module SemanticLogger
 
       stream = appender.respond_to?(:console_stream) && appender.console_stream
       if stream && console_streams.include?(stream)
-        logger.warn "Ignoring attempt to add a second #{stream} console appender since it would result in duplicate console output."
+        logger.warn "Ignoring attempt to add a second #{stream} console appender since it " \
+                    "would result in duplicate console output."
         return
       end
 
@@ -36,7 +37,7 @@ module SemanticLogger
     # Returns [Array<Hash>] operational statistics for each appender.
     #
     # Appenders that run asynchronously (see SemanticLogger::Appender::Async#stats) report
-    # their queue size and processed/dropped counts. Appenders that log inline on the
+    # their queue size and processed/dropped/failed counts. Appenders that log inline on the
     # processor thread report only their name with `async: false`.
     def stats
       map do |appender|
@@ -48,9 +49,17 @@ module SemanticLogger
       end
     end
 
+    # Write the log message to every appender that should log it. An appender that fails is
+    # reported, and the others still write the message.
+    #
+    # A stack overflow is not a failure of the appender but of the thread, which must not overflow
+    # again: on macOS a second stack overflow on the same thread crashes Ruby. It is raised to the
+    # processor running this thread instead, and the message goes to no further appenders.
     def log(log)
       each do |appender|
         appender.log(log) if appender.should_log?(log)
+      rescue SystemStackError
+        raise
       rescue Exception => e
         logger.error "Failed to log to appender: #{appender.name}", e
       end