semantic_logger 4.11.0 → 4.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef345374458ca40a1c31ab82b43fa040974c586fd089a3a5a2a5ab6fe0393c77
-  data.tar.gz: a7d13c0f42e7571b3ddcc47303f83a4b28a2b46929134be7d02e9c5af23d2963
+  metadata.gz: 966d1357f842de3f83f7b0c479152a401906da47588a8f64525ea0fee406a017
+  data.tar.gz: 3528480641795abc6f38fe4617f4599be81b276ab4184c719b1f6ee7e555fb07
 SHA512:
-  metadata.gz: 0c4913a0f50f89e9b92b03b89c01b8a02f71f29efd6c06ae0c3f59b49c290b5878569cc6e5a946a7cc29943974d822a29481e6bd83d33c0de66f87f4b524e05c
-  data.tar.gz: ffe8ca5c2ce97b4bfe67bd79b4ae562c509c577cc70daca9128fe2c28cb7e92f1f6e567e4fb5199f89927653b6a1a3d32d53d6287e5f96ec935207534027746f
+  metadata.gz: 6e75514558375d84db0943fbca39295c1011f9def7a86ddc2592c1de7cd0a460c61158ecbdfa35954ec768baa3bfc7b7b068ca802723b6daf64a050a31814c60
+  data.tar.gz: 9c351b2d1eb79c5cfbde72304e6557e0d18526746be4ef3777bb1130a2a675a069321954e617d799c7d6dc2ddc60fd425cc33b9bd9ec148d04931336aa048286

data/README.md

@@ -55,6 +55,7 @@ and are therefore not automatically included by this gem:
 - Bugsnag Appender: gem 'bugsnag'
 - MongoDB Appender: gem 'mongo' 1.9.2 or above
 - NewRelic Appender: gem 'newrelic_rpm'
+- NewRelicLogs Appender: gem 'newrelic_rpm'
 - Syslog Appender: gem 'syslog_protocol' 0.9.2 or above
 - Syslog Appender to a remote syslogng server over TCP or UDP: gem 'net_tcp_client'
 - Splunk Appender: gem 'splunk-sdk-ruby'

data/lib/semantic_logger/appender/async.rb

@@ -59,7 +59,7 @@ module SemanticLogger
 
         appender.reopen if appender.respond_to?(:reopen)
 
-        @thread.kill if @thread&.alive?
+        @thread&.kill if @thread&.alive?
         @thread = Thread.new { process }
       end
 

data/lib/semantic_logger/appender/async_batch.rb

@@ -1,5 +1,3 @@
-require "concurrent"
-
 module SemanticLogger
   module Appender
     # Log asynchronously in batches using a separate thread.

data/lib/semantic_logger/appender/http.rb

@@ -21,7 +21,7 @@ module SemanticLogger
     class Http < SemanticLogger::Subscriber
       attr_accessor :username, :compress, :header,
                     :open_timeout, :read_timeout, :continue_timeout
-      attr_reader :http, :url, :server, :port, :path, :ssl_options
+      attr_reader :http, :url, :server, :port, :path, :ssl_options, :proxy_url
 
       # Create HTTP(S) log appender
       #
@@ -48,6 +48,11 @@ module SemanticLogger
       #   password: [String]
       #     Password for basic Authentication.
       #
+      #   header: [Hash]
+      #     Custom HTTP headers to send with each request.
+      #     Default: {} ( do not send any custom headers)
+      #     Example: {"Authorization" => "Bearer BEARER_TOKEN"}
+      #
       #   compress: [true|false]
       #     Whether to compress the JSON string with GZip.
       #     Default: false
@@ -57,6 +62,16 @@ module SemanticLogger
       #       ca_file, ca_path, cert, cert_store, ciphers, key, ssl_timeout,
       #       ssl_version, verify_callback, verify_depth and verify_mode.
       #
+      #   proxy_url: [String]
+      #     URL of proxy server to use for HTTP(s) connections.  Should
+      #       include username and password if required.
+      #       Example: http://user@pass:example.com/some_path
+      #     To enable SSL include https in the URL.
+      #       Example: https://example.com/some_path
+      #     If this is set to :ENV, Net::HTTP will use the environment http_proxy*
+      #       variables if they are set.  If set to nil then no proxy will be used,
+      #       even if the environment variables are set.
+      #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
       #     Default: SemanticLogger.default_level
@@ -85,6 +100,8 @@ module SemanticLogger
                      ssl: {},
                      username: nil,
                      password: nil,
+                     header: {},
+                     proxy_url: :ENV,
                      open_timeout: 2.0,
                      read_timeout: 1.0,
                      continue_timeout: 1.0,
@@ -92,6 +109,7 @@ module SemanticLogger
                      &block)
 
         @url              = url
+        @proxy_url        = proxy_url
         @ssl_options      = ssl
         @username         = username
         @password         = password
@@ -106,7 +124,7 @@ module SemanticLogger
           "Content-Type" => "application/json",
           "Connection"   => "keep-alive",
           "Keep-Alive"   => "300"
-        }
+        }.merge(header)
         @header["Content-Encoding"] = "gzip" if @compress
 
         uri     = URI.parse(@url)
@@ -129,6 +147,9 @@ module SemanticLogger
         else
           @port ||= HTTP.http_default_port
         end
+
+        @proxy_uri = URI.parse(@proxy_url) if @proxy_url && @proxy_url != :ENV
+
         @http = nil
 
         super(**args, &block)
@@ -144,7 +165,11 @@ module SemanticLogger
           nil
         end
 
-        @http = Net::HTTP.new(server, port)
+        @http = if @proxy_uri
+                  Net::HTTP.new(server, port, @proxy_uri.host, @proxy_uri.port, @proxy_uri.user, @proxy_uri.password)
+                else
+                  Net::HTTP.new(server, port, @proxy_url)
+                end
 
         if @ssl_options
           @http.methods.grep(/\A(\w+)=\z/) do |meth|
@@ -207,7 +232,7 @@ module SemanticLogger
         end
         request.basic_auth(@username, @password) if @username
         response = @http.request(request)
-        if response.code == "200" || response.code == "201"
+        if response.is_a?(Net::HTTPSuccess)
           true
         else
           # Failures are logged to the global semantic logger failsafe logger (Usually stderr or file)

data/lib/semantic_logger/appender/kafka.rb

@@ -24,7 +24,7 @@ module SemanticLogger
     class Kafka < SemanticLogger::Subscriber
       attr_accessor :seed_brokers, :client_id, :connect_timeout, :socket_timeout,
                     :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_key, :ssl_ca_certs_from_system,
-                    :delivery_threshold, :delivery_interval,
+                    :delivery_threshold, :delivery_interval, :required_acks,
                     :topic, :partition, :partition_key, :key
 
       # Send log messages to Kafka in JSON format.
@@ -90,6 +90,10 @@ module SemanticLogger
       #      Number of seconds between triggering a delivery of messages to Apache Kafka.
       #      Default: 5
       #
+      #    required_acks: [Integer]
+      #      Number of replicas that must acknowledge receipt of each log message to the topic
+      #      Default: 1
+      #
       # Semantic Logger Parameters:
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
@@ -121,7 +125,7 @@ module SemanticLogger
       def initialize(seed_brokers:, client_id: "semantic-logger", connect_timeout: nil, socket_timeout: nil,
                      ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil, ssl_ca_certs_from_system: false,
                      topic: "log_messages", partition: nil, partition_key: nil, key: nil,
-                     delivery_threshold: 100, delivery_interval: 10,
+                     delivery_threshold: 100, delivery_interval: 10, required_acks: 1,
                      metrics: true, **args, &block)
 
         @seed_brokers             = seed_brokers
@@ -138,6 +142,7 @@ module SemanticLogger
         @key                      = key
         @delivery_threshold       = delivery_threshold
         @delivery_interval        = delivery_interval
+        @required_acks            = required_acks
 
         super(metrics: metrics, **args, &block)
         reopen
@@ -158,7 +163,8 @@ module SemanticLogger
 
         @producer = @kafka.async_producer(
           delivery_threshold: delivery_threshold,
-          delivery_interval:  delivery_interval
+          delivery_interval:  delivery_interval,
+          required_acks:      required_acks
         )
       end
 

data/lib/semantic_logger/appender/new_relic_logs.rb

@@ -0,0 +1,57 @@
+begin
+  require "newrelic_rpm"
+rescue LoadError
+  raise LoadError, 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
+end
+
+require "semantic_logger/formatters/new_relic_logs"
+
+# Send log messages to NewRelic
+#
+# All log entries will appear under
+# "Logs" in New Relic
+#
+# == Caveats
+#
+# * The NewRelic agent only sends logs to NewRelic when log forwarding is enabled. There is however an open
+#   issue to get this fixed: https://github.com/newrelic/newrelic-ruby-agent/issues/1614. Please see the guide
+#   for a workaround.
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :new_relic_logs)
+module SemanticLogger
+  module Appender
+    class NewRelicLogs < SemanticLogger::Subscriber
+      # Create Appender
+      #
+      # Parameters
+      #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+      #     Override the log level for this appender.
+      #     Default: SemanticLogger.default_level
+      #
+      #   formatter: [Object|Proc]
+      #     An instance of a class that implements #call, or a Proc to be used to format
+      #     the output from this appender
+      #     Default: SemanticLogger::Formatters::NewRelicLogs
+      #
+      #   filter: [Regexp|Proc]
+      #     RegExp: Only include log messages where the class name matches the supplied.
+      #     regular expression. All other messages will be ignored.
+      #     Proc: Only include log messages where the supplied Proc returns true
+      #           The Proc must return true or false.
+      def initialize(formatter: SemanticLogger::Formatters::NewRelicLogs.new, **args, &block)
+        super(formatter: formatter, **args, &block)
+      end
+
+      # Send an error notification to New Relic
+      def log(log)
+        self.class.log_newrelic(formatter.call(log, self).to_json, log.level.to_s.upcase)
+        true
+      end
+
+      def self.log_newrelic(message, level)
+        ::NewRelic::Agent.agent.log_event_aggregator.record(message, level)
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -40,7 +40,7 @@ module SemanticLogger
       def initialize(level: :error, **args, &block)
         # Replace the Sentry Ruby logger so that we can identify its log
         # messages and not forward them to Sentry
-        ::Sentry.init { |config| config.logger = SemanticLogger[::Sentry] }
+        ::Sentry.init { |config| config.logger = SemanticLogger[::Sentry] } unless ::Sentry.initialized?
         super(level: level, **args, &block)
       end
 

data/lib/semantic_logger/appender.rb

@@ -15,6 +15,7 @@ module SemanticLogger
     autoload :Http,              "semantic_logger/appender/http"
     autoload :MongoDB,           "semantic_logger/appender/mongodb"
     autoload :NewRelic,          "semantic_logger/appender/new_relic"
+    autoload :NewRelicLogs,      "semantic_logger/appender/new_relic_logs"
     autoload :Rabbitmq,          "semantic_logger/appender/rabbitmq"
     autoload :Splunk,            "semantic_logger/appender/splunk"
     autoload :SplunkHttp,        "semantic_logger/appender/splunk_http"

data/lib/semantic_logger/base.rb

@@ -77,7 +77,7 @@ module SemanticLogger
     #    # Log an exception in a semantic way
     #    logger.info("Parsing received XML", exc)
     #
-    SemanticLogger::LEVELS.each_with_index do |level, index|
+    SemanticLogger::Levels::LEVELS.each_with_index do |level, index|
       class_eval <<~METHODS, __FILE__, __LINE__ + 1
         def #{level}(message=nil, payload=nil, exception=nil, &block)
           if level_index <= #{index}

data/lib/semantic_logger/formatters/base.rb

@@ -23,7 +23,6 @@ module SemanticLogger
       #     See Time#strftime for the format of this string.
       #     :iso_8601 Outputs an ISO8601 Formatted timestamp.
       #     :ms       Output in miliseconds since epoch.
-      #     nil:      Returns Empty string for time ( no time is output ).
       #     Default: '%Y-%m-%d %H:%M:%S.%<precision>N'
       #   log_host: [Boolean]
       #     Whether or not to include hostname in logs

data/lib/semantic_logger/formatters/logfmt.rb

@@ -62,7 +62,12 @@ module SemanticLogger
 
       def flatten_log
         flattened = @parsed.map do |key, value|
-          "#{key}=#{value.to_json}"
+          case value
+          when Hash, Array
+            "#{key}=#{value.to_s.to_json}"
+          else
+            "#{key}=#{value.to_json}"
+          end
         end
 
         flattened.join(" ")

data/lib/semantic_logger/formatters/new_relic_logs.rb

@@ -0,0 +1,109 @@
+require "json"
+
+begin
+  require "newrelic_rpm"
+rescue LoadError
+  raise LoadError, 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
+end
+
+raise "NewRelic::Agent.linking_metadata is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent.respond_to?(:linking_metadata)
+
+raise "NewRelic::Agent::Tracer.current_span_id is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent::Tracer.respond_to?(:current_span_id)
+
+raise "NewRelic::Agent::Tracer.current_trace_id is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent::Tracer.respond_to?(:current_trace_id)
+
+module SemanticLogger
+  module Formatters
+    # Formatter for reporting to NewRelic's Logger
+    #
+    # New Relic's logs do not support custom attributes out of the box, and therefore these
+    # have to be put into a single JSON serialized string under the +message+ key.
+    #
+    # In particular the following fields of the log object are serialized under the +message+
+    # key that's sent to NewRelic:
+    #
+    # * message
+    # * tags
+    # * named_tags
+    # * payload
+    # * metric
+    # * metric_amount
+    # * environment
+    # * application
+    #
+    # == New Relic Attributes not Supported
+    # * thread.id
+    # * class.name
+    # * method.name
+    #
+    # == Reference
+    # * Logging specification
+    #   * https://github.com/newrelic/newrelic-exporter-specs/tree/master/logging
+    #
+    # * Metadata APIs
+    #   * https://www.rubydoc.info/gems/newrelic_rpm/NewRelic/Agent#linking_metadata-instance_method
+    #   * https://www.rubydoc.info/gems/newrelic_rpm/NewRelic/Agent/Tracer#current_trace_id-class_method
+    #   * https://www.rubydoc.info/gems/newrelic_rpm/NewRelic/Agent/Tracer#current_span_id-class_method
+    #
+    class NewRelicLogs < Raw
+      def initialize(**args)
+        args.delete(:time_key)
+        args.delete(:time_format)
+
+        super(time_key: :timestamp, time_format: :ms, **args)
+      end
+
+      def call(log, logger)
+        hash = super(log, logger)
+
+        message = {
+          message:    hash[:message].to_s,
+          tags:       hash[:tags] || [],
+          named_tags: hash[:named_tags] || {},
+
+          **hash.slice(:metric, :metric_amount, :environment, :application, :payload)
+        }
+
+        message.merge!(duration: hash[:duration_ms]) if hash.key?(:duration_ms)
+        message.merge!(duration_human: hash[:duration]) if hash.key?(:duration)
+
+        result = {
+          **new_relic_metadata,
+          message:       message.to_json,
+          timestamp:     hash[:timestamp].to_i,
+          "log.level":   log.level.to_s.upcase,
+          "logger.name": log.name,
+          "thread.name": log.thread_name.to_s
+        }
+
+        if hash[:exception]
+          result.merge!(
+            "error.message": hash[:exception][:message],
+            "error.class":   hash[:exception][:name],
+            "error.stack":   hash[:exception][:stack_trace].join("\n")
+          )
+        end
+
+        if hash[:file]
+          result.merge!(
+            "file.name":   hash[:file],
+            "line.number": hash[:line].to_s
+          )
+        end
+
+        result
+      end
+
+      private
+
+      def new_relic_metadata
+        {
+          "trace.id": NewRelic::Agent::Tracer.current_trace_id,
+          "span.id":  NewRelic::Agent::Tracer.current_span_id,
+          **NewRelic::Agent.linking_metadata
+        }.reject { |_k, v| v.nil? }.
+          map { |k, v| [k.to_sym, v] }.to_h
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -23,7 +23,7 @@ module SemanticLogger
       #
       # Example:
       #   # Log via udp to a remote syslog server on host: `server1` and port `8514`, using the CEE format.
-      #   SemanticLogger.add_appender(appender: :syslog, formatter: syslog_cee, url: 'udp://server1:8514')
+      #   SemanticLogger.add_appender(appender: :syslog, formatter: :syslog_cee, url: 'udp://server1:8514')
       def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new, max_size: Integer)
         @facility  = facility
         @level_map = level_map.is_a?(SemanticLogger::Formatters::Syslog::LevelMap) ? level_map : SemanticLogger::Formatters::Syslog::LevelMap.new(level_map)

data/lib/semantic_logger/formatters.rb

@@ -1,15 +1,17 @@
 module SemanticLogger
   module Formatters
-    autoload :Base,     "semantic_logger/formatters/base"
-    autoload :Color,    "semantic_logger/formatters/color"
-    autoload :Default,  "semantic_logger/formatters/default"
-    autoload :Json,     "semantic_logger/formatters/json"
-    autoload :Raw,      "semantic_logger/formatters/raw"
-    autoload :OneLine,  "semantic_logger/formatters/one_line"
-    autoload :Signalfx, "semantic_logger/formatters/signalfx"
-    autoload :Syslog,   "semantic_logger/formatters/syslog"
-    autoload :Fluentd,  "semantic_logger/formatters/fluentd"
-    autoload :Logfmt,   "semantic_logger/formatters/logfmt"
+    autoload :Base,         "semantic_logger/formatters/base"
+    autoload :Color,        "semantic_logger/formatters/color"
+    autoload :Default,      "semantic_logger/formatters/default"
+    autoload :Json,         "semantic_logger/formatters/json"
+    autoload :Raw,          "semantic_logger/formatters/raw"
+    autoload :OneLine,      "semantic_logger/formatters/one_line"
+    autoload :Signalfx,     "semantic_logger/formatters/signalfx"
+    autoload :Syslog,       "semantic_logger/formatters/syslog"
+    autoload :Fluentd,      "semantic_logger/formatters/fluentd"
+    autoload :Logfmt,       "semantic_logger/formatters/logfmt"
+    autoload :SyslogCee,    "semantic_logger/formatters/syslog_cee"
+    autoload :NewRelicLogs, "semantic_logger/formatters/new_relic_logs"
 
     # Return formatter that responds to call.
     #

data/lib/semantic_logger/levels.rb

@@ -1,35 +1,31 @@
+require "logger"
+
 module SemanticLogger
   module Levels
     # Logging levels in order of most detailed to most severe
     LEVELS = %i[trace debug info warn error fatal].freeze
 
+    # Map the built-in `Logger` levels to SemanticLogger levels.
+    MAPPED_LEVELS =
+      ::Logger::Severity.constants.each_with_object([]) do |constant, levels|
+        logger_value = ::Logger::Severity.const_get(constant)
+        levels[logger_value] = LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
+      end.freeze
+
     # Internal method to return the log level as an internal index
     # Also supports mapping the ::Logger levels to SemanticLogger levels
     def self.index(level)
       return if level.nil?
 
-      index =
-        if level.is_a?(Symbol)
-          LEVELS.index(level)
-        elsif level.is_a?(String)
-          level = level.downcase.to_sym
-          LEVELS.index(level)
-        elsif level.is_a?(Integer) && defined?(::Logger::Severity)
-          # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
-          @map_levels ||=
-            begin
-              levels = []
-              ::Logger::Severity.constants.each do |constant|
-                levels[::Logger::Severity.const_get(constant)] =
-                  LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
-              end
-              levels
-            end
-          @map_levels[level]
-        end
-      raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
-
-      index
+      case level
+      when Symbol
+        LEVELS.index(level)
+      when String
+        LEVELS.index(level.downcase.to_sym)
+      when Integer
+        MAPPED_LEVELS[level]
+      end ||
+        raise(ArgumentError, "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}")
     end
 
     # Returns the symbolic level for the supplied level index

data/lib/semantic_logger/log.rb

@@ -219,11 +219,11 @@ module SemanticLogger
 
       seconds = duration / 1000
       if seconds >= 86_400.0 # 1 day
-        "#{(seconds / 86_400).to_i}d #{Time.at(seconds).strftime('%-Hh %-Mm')}"
+        "#{(seconds / 86_400).to_i}d #{Time.at(seconds).utc.strftime('%-Hh %-Mm')}"
       elsif seconds >= 3600.0 # 1 hour
-        Time.at(seconds).strftime("%-Hh %-Mm")
+        Time.at(seconds).utc.strftime("%-Hh %-Mm")
       elsif seconds >= 60.0 # 1 minute
-        Time.at(seconds).strftime("%-Mm %-Ss")
+        Time.at(seconds).utc.strftime("%-Mm %-Ss")
       elsif seconds >= 1.0 # 1 second
         "#{format('%.3f', seconds)}s"
       else

data/lib/semantic_logger/logger.rb

@@ -1,4 +1,3 @@
-require "concurrent"
 module SemanticLogger
   # Logger stores the class name to be used for all log messages so that every
   # log message written by this instance will include the class name

data/lib/semantic_logger/semantic_logger.rb

@@ -1,4 +1,3 @@
-require "concurrent"
 require "socket"
 
 module SemanticLogger
@@ -253,9 +252,9 @@ module SemanticLogger
   #   When the log_level_signal is raised on this process, the global default log level
   #   rotates through the following log levels in the following order, starting
   #   from the current global default level:
-  #     :warn, :info, :debug, :trace
+  #     :fatal, :error, :warn, :info, :debug, :trace
   #
-  #   If the current level is :trace it wraps around back to :warn
+  #   If the current level is :trace it wraps around back to :fatal
   #
   # 2. Logging a Ruby thread dump
   #
@@ -279,10 +278,11 @@ module SemanticLogger
   def self.add_signal_handler(log_level_signal = "USR2", thread_dump_signal = "TTIN", gc_log_microseconds = 100_000)
     if log_level_signal
       Signal.trap(log_level_signal) do
-        index     = default_level == :trace ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
-        new_level = LEVELS[index - 1]
-        self["SemanticLogger"].warn "Changed global default log level to #{new_level.inspect}"
+        current_level_index = LEVELS.find_index(default_level)
+        new_level_index = current_level_index == 0 ? LEVELS.size - 1 : current_level_index - 1
+        new_level = LEVELS[new_level_index]
         self.default_level = new_level
+        self["SemanticLogger"].warn "Changed global default log level to #{new_level.inspect}"
       end
     end
 
@@ -516,4 +516,27 @@ module SemanticLogger
   @backtrace_level       = :error
   @backtrace_level_index = Levels.index(@backtrace_level)
   @sync                  = false
+
+  # @formatter:off
+  module Metric
+    autoload :NewRelic,          "semantic_logger/metric/new_relic"
+    autoload :Signalfx,          "semantic_logger/metric/signalfx"
+    autoload :Statsd,            "semantic_logger/metric/statsd"
+  end
+
+  module Reporters
+    autoload :Minitest,          "semantic_logger/reporters/minitest"
+  end
+
+  module Test
+    autoload :CaptureLogEvents,  "semantic_logger/test/capture_log_events"
+    autoload :Minitest,          "semantic_logger/test/minitest"
+  end
+
+  if defined?(JRuby)
+    module JRuby
+      autoload :GarbageCollectionLogger, "semantic_logger/jruby/garbage_collection_logger"
+    end
+  end
+  # @formatter:on
 end

data/lib/semantic_logger/sync_processor.rb

@@ -1,14 +1,28 @@
 module SemanticLogger
-  # Thread that submits and processes log requests
+  # The SyncProcessor performs logging in the current thread.
+  #
+  # Appenders are designed to only be used by one thread at a time, so all calls
+  # are mutex protected in case SyncProcessor is being used in a multi-threaded environment.
   class SyncProcessor
-    extend Forwardable
+    def add(*args, &block)
+      @mutex.synchronize { @appenders.add(*args, &block) }
+    end
+
+    def log(*args, &block)
+      @mutex.synchronize { @appenders.log(*args, &block) }
+    end
+
+    def flush
+      @mutex.synchronize { @appenders.flush }
+    end
+
+    def close
+      @mutex.synchronize { @appenders.close }
+    end
 
-    # Forward methods that can be called directly
-    def_delegator :@appenders, :add
-    def_delegator :@appenders, :log
-    def_delegator :@appenders, :flush
-    def_delegator :@appenders, :close
-    def_delegator :@appenders, :reopen
+    def reopen(*args)
+      @mutex.synchronize { @appenders.reopen(*args) }
+    end
 
     # Allow the internal logger to be overridden from its default of $stderr
     #   Can be replaced with another Ruby logger or Rails logger, but never to
@@ -33,6 +47,7 @@ module SemanticLogger
     attr_reader :appenders
 
     def initialize(appenders = nil)
+      @mutex     = Mutex.new
       @appenders = appenders || Appenders.new(self.class.logger.dup)
     end
 

data/lib/semantic_logger/test/capture_log_events.rb

@@ -24,10 +24,15 @@ module SemanticLogger
       # By default collect all log levels, and collect metric only log events.
       def initialize(level: :trace, metrics: true)
         super(level: level, metrics: true)
+        @events = []
       end
 
       def log(log)
-        (@events ||= []) << log
+        @events << log
+      end
+
+      def clear
+        @events.clear
       end
     end
   end

data/lib/semantic_logger/test/minitest.rb

@@ -0,0 +1,53 @@
+module SemanticLogger
+  module Test
+    module Minitest
+      # Returns [Array<SemanticLogger::Log>] the log events from Semantic Logger
+      # captured whilst executing the supplied block.
+      def semantic_logger_events(klass = nil, &block)
+        logger = SemanticLogger::Test::CaptureLogEvents.new
+        if klass
+          klass.stub(:logger, logger, &block)
+        else
+          SemanticLogger.silence(:trace) do
+            SemanticLogger::Logger.stub(:processor, logger, &block)
+          end
+        end
+        logger.events
+      end
+
+      # Verify a single log event has all the required attributes.
+      def assert_semantic_logger_event(event, level: nil, name: nil, message: nil, message_includes: nil,
+                                       payload: nil, payload_includes: nil,
+                                       thread_name: nil, tags: nil, named_tags: nil, context: nil,
+                                       metric: nil, metric_amount: nil, dimensions: nil)
+        msg = message || message_includes || "no message"
+        assert event, "Log event missing for message: '#{msg}'"
+        assert_equal message, event.message if message
+        assert_includes event.message, message_includes if message_includes
+        assert_equal name, event.name, -> { "Mismatched log name for message: '#{msg}'" } if name
+        assert_equal level, event.level, -> { "Mismatched log level for message: '#{msg}'" } if level
+
+        if payload_includes
+          payload_includes.each_pair do |key, expected_value|
+            value = event.payload[key]
+            if expected_value.nil?
+              assert_nil value, -> { "Mismatched key: #{key.inspect} in log payload: #{event.payload} for message: '#{msg}'" }
+            else
+              assert_equal expected_value, value, -> { "Mismatched key: #{key.inspect} in log payload: #{event.payload} for message: '#{msg}'" }
+            end
+          end
+        elsif payload
+          assert_equal payload, event.payload, -> { "Mismatched log payload: #{event.payload} for message: '#{msg}'" }
+        end
+
+        assert_equal thread_name, event.thread_name, -> { "Mismatched thread_name for message: '#{msg}'" } if thread_name
+        assert_equal tags, event.tags, -> { "Mismatched tags for message: '#{msg}'" } if tags
+        assert_equal named_tags, event.named_tags, -> { "Mismatched named_tags for message: '#{msg}'" } if named_tags
+        assert_equal context, event.context, -> { "Mismatched context for message: '#{msg}'" } if context
+        assert_equal metric, event.metric, -> { "Mismatched metric for message: '#{msg}'" } if metric
+        assert_equal metric_amount, event.metric_amount, -> { "Mismatched metric_amount for message: '#{msg}'" } if metric_amount
+        assert_equal dimensions, event.dimensions, -> { "Mismatched dimensions for message: '#{msg}'" } if dimensions
+      end
+    end
+  end
+end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = "4.11.0".freeze
+  VERSION = "4.14.0".freeze
 end

data/lib/semantic_logger.rb

@@ -1,49 +1,22 @@
+require "concurrent"
 require "semantic_logger/core_ext/thread"
 require "semantic_logger/version"
-
-# @formatter:off
-module SemanticLogger
-  autoload :AnsiColors,         "semantic_logger/ansi_colors"
-  autoload :Appender,           "semantic_logger/appender"
-  autoload :Appenders,          "semantic_logger/appenders"
-  autoload :Base,               "semantic_logger/base"
-  autoload :DebugAsTraceLogger, "semantic_logger/debug_as_trace_logger"
-  autoload :Formatters,         "semantic_logger/formatters"
-  autoload :Levels,             "semantic_logger/levels"
-  autoload :Log,                "semantic_logger/log"
-  autoload :Logger,             "semantic_logger/logger"
-  autoload :Loggable,           "semantic_logger/loggable"
-  autoload :Processor,          "semantic_logger/processor"
-  autoload :Subscriber,         "semantic_logger/subscriber"
-  autoload :SyncProcessor,      "semantic_logger/sync_processor"
-  autoload :Utils,              "semantic_logger/utils"
-
-  module Concerns
-    autoload :Compatibility, "semantic_logger/concerns/compatibility"
-  end
-
-  module Metric
-    autoload :NewRelic,          "semantic_logger/metric/new_relic"
-    autoload :Signalfx,          "semantic_logger/metric/signalfx"
-    autoload :Statsd,            "semantic_logger/metric/statsd"
-  end
-
-  module Reporters
-    autoload :Minitest,          "semantic_logger/reporters/minitest"
-  end
-
-  module Test
-    autoload :CaptureLogEvents,  "semantic_logger/test/capture_log_events"
-  end
-
-  if defined?(JRuby)
-    module JRuby
-      autoload :GarbageCollectionLogger, "semantic_logger/jruby/garbage_collection_logger"
-    end
-  end
-end
+require "semantic_logger/utils"
+require "semantic_logger/ansi_colors"
+require "semantic_logger/levels"
+require "semantic_logger/base"
+require "semantic_logger/formatters"
+require "semantic_logger/log"
+require "semantic_logger/subscriber"
+require "semantic_logger/loggable"
+require "semantic_logger/concerns/compatibility"
+require "semantic_logger/appender"
+require "semantic_logger/appenders"
+require "semantic_logger/processor"
+require "semantic_logger/sync_processor"
+require "semantic_logger/logger"
+require "semantic_logger/debug_as_trace_logger"
 require "semantic_logger/semantic_logger"
-# @formatter:on
 
 # Flush all appenders at exit, waiting for outstanding messages on the queue
 # to be written first.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.11.0
+  version: 4.14.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-13 00:00:00.000000000 Z
+date: 2023-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -49,6 +49,7 @@ files:
 - lib/semantic_logger/appender/kafka.rb
 - lib/semantic_logger/appender/mongodb.rb
 - lib/semantic_logger/appender/new_relic.rb
+- lib/semantic_logger/appender/new_relic_logs.rb
 - lib/semantic_logger/appender/rabbitmq.rb
 - lib/semantic_logger/appender/sentry.rb
 - lib/semantic_logger/appender/sentry_ruby.rb
@@ -70,6 +71,7 @@ files:
 - lib/semantic_logger/formatters/fluentd.rb
 - lib/semantic_logger/formatters/json.rb
 - lib/semantic_logger/formatters/logfmt.rb
+- lib/semantic_logger/formatters/new_relic_logs.rb
 - lib/semantic_logger/formatters/one_line.rb
 - lib/semantic_logger/formatters/raw.rb
 - lib/semantic_logger/formatters/signalfx.rb
@@ -90,12 +92,17 @@ files:
 - lib/semantic_logger/sync.rb
 - lib/semantic_logger/sync_processor.rb
 - lib/semantic_logger/test/capture_log_events.rb
+- lib/semantic_logger/test/minitest.rb
 - lib/semantic_logger/utils.rb
 - lib/semantic_logger/version.rb
 homepage: https://logger.rocketjob.io
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/reidmorrison/semantic_logger/issues
+  documentation_uri: https://logger.rocketjob.io
+  source_code_uri: https://github.com/reidmorrison/semantic_logger/tree/4.14.0
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -111,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.9
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails