semantic_logger 4.12.0 → 4.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b09c37737f1e42edbeee95b036ba0581d5164d756e13de37aca9b22b3093cd45
-  data.tar.gz: 9f66b72480df2371a7d305164e443f9667e1acd5521c1347d54c3841efbfa4c9
+  metadata.gz: 3d393f5d7fde6627e73b79c370fed2f83e212eb43199bfbebab15b5eeb8ce66b
+  data.tar.gz: c75577f1ad4f5c209cb7fb0028c8d5738e9c546b2df6875bcec40170b1ca1f5e
 SHA512:
-  metadata.gz: fb27aa1a6d5dc1f2e0e6505ba9348a7cec091a153763361e8c9c20c21177bf84ac11ac2f21fc37ec994988ba31763dcd5c3134ac40a169ac987ed617eceec46e
-  data.tar.gz: 5d084bc8cc57b1e836326eae912667ef6b7a284b0125c0b0acee678af78c01017b9667db9a43df7c0fb38af4998b0ab3128ac05d3e2bce266176e9c4d8fadccd
+  metadata.gz: f86046a5e749f8d69ff17b9c4c9c91ff30507436bfe91f181e0c0a3a8fe1529d0f176940be3c099a9267d5f60e3215610cd3e2f49a2e70d55f88cce7c2345ae9
+  data.tar.gz: 4277d124c94f200d0d6aff5f74f58217cfd48276323b1d47656037dfbcd7d40b21e2ece17b7f50b521098608ce5d08dbd786fcbd53866b8fd052fe17f18db40d

data/README.md

@@ -1,7 +1,7 @@
 # Semantic Logger
 [![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://github.com/reidmorrison/semantic_logger/workflows/build/badge.svg)](https://github.com/reidmorrison/semantic_logger/actions?query=workflow%3Abuild) [![Downloads](https://img.shields.io/gem/dt/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
-Semantic Logger is a feature rich logging framework, and replacement for existing Ruby & Rails loggers.  
+Semantic Logger is a feature rich logging framework, and replacement for existing Ruby & Rails loggers.
 
 * https://logger.rocketjob.io/
 
@@ -21,7 +21,7 @@ Logging to the following destinations are all supported "out-of-the-box":
 * NewRelic
 * Splunk
 * MongoDB
-* Honeybadger
+* Honeybadger (exceptions and events)
 * Sentry (both with legacy `sentry-raven` and modern `sentry-ruby` gem)
 * HTTP
 * TCP
@@ -54,7 +54,10 @@ The following gems are only required when their corresponding appenders are bein
 and are therefore not automatically included by this gem:
 - Bugsnag Appender: gem 'bugsnag'
 - MongoDB Appender: gem 'mongo' 1.9.2 or above
+- Honeybadger Appender: gem 'honeybadger'
+- HoneybadgerInsights Appender: gem 'honeybadger'
 - 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'
@@ -128,16 +131,16 @@ logger.debug payload: {foo: 'foo', bar: 'bar'}
 Similarly, for measure blocks:
 
 ~~~ruby
-logger.measure_info('How long is the sleep', foo: 'foo', bar: 'bar') { sleep 1 } 
+logger.measure_info('How long is the sleep', foo: 'foo', bar: 'bar') { sleep 1 }
 ~~~
 
 Must be replaced with the following in v4:
 
 ~~~ruby
-logger.measure_info('How long is the sleep', payload: {foo: 'foo', bar: 'bar'}) { sleep 1 } 
+logger.measure_info('How long is the sleep', payload: {foo: 'foo', bar: 'bar'}) { sleep 1 }
 ~~~
 
-The common log call has not changed, and the payload is still logged directly: 
+The common log call has not changed, and the payload is still logged directly:
 
 ~~~ruby
 logger.debug('log this', foo: 'foo', bar: 'bar')

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/elasticsearch.rb

@@ -37,6 +37,7 @@ module SemanticLogger
       #
       #   type: [String]
       #     Document type to associate with logs when they are written.
+      #     Deprecated in Elasticsearch 7.0.0.
       #     Default: 'log'
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
@@ -146,7 +147,7 @@ module SemanticLogger
         @elasticsearch_args          = elasticsearch_args.dup
         @elasticsearch_args[:url]    = url if url && !elasticsearch_args[:hosts]
         @elasticsearch_args[:logger] = logger
-        @data_stream = data_stream
+        @data_stream                 = data_stream
 
         super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: false, &block)
         reopen
@@ -176,11 +177,12 @@ module SemanticLogger
       private
 
       def write_to_elasticsearch(messages)
-        bulk_result = if @data_stream
-                        @client.bulk(index: index, body: messages)
-                      else
-                        @client.bulk(body: messages)
-                      end
+        bulk_result =
+          if @data_stream
+            @client.bulk(index: index, body: messages)
+          else
+            @client.bulk(body: messages)
+          end
 
         return unless bulk_result["errors"]
 
@@ -190,22 +192,21 @@ module SemanticLogger
 
       def bulk_index(log)
         expanded_index_name = log.time.strftime("#{index}-#{date_pattern}")
-        if @data_stream
-          {"create" => {}}
-        else
-          {"index" => {"_index" => expanded_index_name, "_type" => type}}
-        end
+        return {"create" => {}} if @data_stream
+
+        bulk_index = {"index" => {"_index" => expanded_index_name}}
+        bulk_index["index"].merge!({"_type" => type}) if version_supports_type?
+        bulk_index
       end
 
       def default_formatter
-        time_key = if @data_stream
-                     "@timestamp"
-                   else
-                     :timestamp
-                   end
-
+        time_key = @data_stream ? "@timestamp" : :timestamp
         SemanticLogger::Formatters::Raw.new(time_format: :iso_8601, time_key: time_key)
       end
+
+      def version_supports_type?
+        Gem::Version.new(::Elasticsearch::VERSION) < Gem::Version.new(7)
+      end
     end
   end
 end

data/lib/semantic_logger/appender/elasticsearch_http.rb

@@ -26,6 +26,7 @@ module SemanticLogger
       #
       #   type: [String]
       #     Document type to associate with logs when they are written.
+      #     Deprecated in Elasticsearch 7.0.0
       #     Default: 'log'
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]

data/lib/semantic_logger/appender/honeybadger_insights.rb

@@ -0,0 +1,61 @@
+begin
+  require "honeybadger"
+rescue LoadError
+  raise LoadError, 'Gem honeybadger is required for logging purposes. Please add the gem "honeybadger" to your Gemfile.'
+end
+
+# Send log messages to honeybadger events/insights API
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :honeybadger_insights)
+#
+module SemanticLogger
+  module Appender
+    class HoneybadgerInsights < SemanticLogger::Subscriber
+      # Honeybadger Appender
+      #
+      # Parameters
+      #   level: [:trace | :debug | :info | :warn | :error | :fatal]
+      #     Override the log level for this appender.
+      #     Default: :error
+      #
+      #   formatter: [Object|Proc|Symbol|Hash]
+      #     An instance of a class that implements #call, or a Proc to be used to format
+      #     the output from this appender
+      #     Default: Use the built-in formatter (See: #call)
+      #
+      #   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.
+      #
+      #   host: [String]
+      #     Name of this host to appear in log messages.
+      #     Default: SemanticLogger.host
+      #
+      #   application: [String]
+      #     Name of this application to appear in log messages.
+      #     Default: SemanticLogger.application
+      def initialize(level: :info, **args, &block)
+        super(level: level, **args, &block)
+      end
+
+      # Send log to honeybadger events API
+      def log(log)
+        event = formatter.call(log, self)
+
+        ::Honeybadger.event(event)
+
+        true
+      end
+
+      private
+
+      # Use Raw Formatter by default
+      def default_formatter
+        SemanticLogger::Formatters::Raw.new(time_key: :ts, time_format: :rfc_3339)
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/http.rb

@@ -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
@@ -95,6 +100,7 @@ module SemanticLogger
                      ssl: {},
                      username: nil,
                      password: nil,
+                     header: {},
                      proxy_url: :ENV,
                      open_timeout: 2.0,
                      read_timeout: 1.0,
@@ -118,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)
@@ -160,10 +166,10 @@ module SemanticLogger
         end
 
         @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
+                  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|
@@ -226,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/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/rabbitmq.rb

@@ -60,6 +60,10 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       #
+      #   metrics: [Boolean]
+      #     Also send metrics only events to rabbitmq.
+      #     Default: true
+      #
       # RabbitMQ Parameters:
       #
       #   rabbitmq_host: [String]
@@ -76,13 +80,15 @@ module SemanticLogger
       #     Default: nil
       #
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
-      def initialize(queue_name: "semantic_logger", rabbitmq_host: nil, metrics: false, **args, &block)
+      def initialize(queue_name: "semantic_logger", rabbitmq_host: nil,
+                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: true,
+                     **args, &block)
         @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, host: host, metrics: metrics, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/splunk.rb

@@ -101,10 +101,10 @@ module SemanticLogger
       # open the handles to resources
       def reopen
         # Connect to splunk. Connect is a synonym for creating a Service by hand and calling login.
-        self.service = Splunk.connect(config)
+        @service = ::Splunk.connect(config)
 
         # The index we are logging to
-        self.service_index = service.indexes[index]
+        @service_index = service.indexes[index]
       end
 
       # Log the message to Splunk

data/lib/semantic_logger/appender/syslog.rb

@@ -208,7 +208,7 @@ module SemanticLogger
 
       # Flush is called by the semantic_logger during shutdown.
       def flush
-        @remote_syslog.flush if @remote_syslog&.respond_to?(:flush)
+        @remote_syslog.flush if @remote_syslog.respond_to?(:flush)
       end
 
       # Returns [SemanticLogger::Formatters::Base] default formatter for this Appender depending on the protocal selected

data/lib/semantic_logger/appender/tcp.rb

@@ -191,7 +191,7 @@ 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, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -1,7 +1,6 @@
 # Send log messages to any standard Ruby logging class.
 #
 #  Forwards logging call to loggers such as Logger, log4r, etc.
-#
 module SemanticLogger
   module Appender
     class Wrapper < SemanticLogger::Subscriber
@@ -56,15 +55,22 @@ module SemanticLogger
       #  trace entries are mapped to debug since :trace is not supported by the
       #  Ruby or Rails Loggers
       def log(log)
-        @logger.send(log.level == :trace ? :debug : log.level, formatter.call(log, self))
+        level = log.level == :trace ? :debug : log.level
+        @logger.send(level, formatter.call(log, self))
         true
       end
 
       # Flush all pending logs to disk.
-      #  Waits for all sent documents to be writted to disk
+      #  Waits for all queued log messages to be written to disk.
       def flush
         @logger.flush if @logger.respond_to?(:flush)
       end
+
+      # Close underlying log
+      #  Waits for all queued log messages to be written to disk.
+      def close
+        @logger.close if @logger.respond_to?(:close)
+      end
     end
   end
 end

data/lib/semantic_logger/appender.rb

@@ -1,28 +1,30 @@
 module SemanticLogger
   module Appender
     # @formatter:off
-    autoload :Async,             "semantic_logger/appender/async"
-    autoload :AsyncBatch,        "semantic_logger/appender/async_batch"
-    autoload :Bugsnag,           "semantic_logger/appender/bugsnag"
-    autoload :Elasticsearch,     "semantic_logger/appender/elasticsearch"
-    autoload :ElasticsearchHttp, "semantic_logger/appender/elasticsearch_http"
-    autoload :File,              "semantic_logger/appender/file"
-    autoload :Graylog,           "semantic_logger/appender/graylog"
-    autoload :Honeybadger,       "semantic_logger/appender/honeybadger"
-    autoload :IO,                "semantic_logger/appender/io"
-    autoload :Kafka,             "semantic_logger/appender/kafka"
-    autoload :Sentry,            "semantic_logger/appender/sentry"
-    autoload :Http,              "semantic_logger/appender/http"
-    autoload :MongoDB,           "semantic_logger/appender/mongodb"
-    autoload :NewRelic,          "semantic_logger/appender/new_relic"
-    autoload :Rabbitmq,          "semantic_logger/appender/rabbitmq"
-    autoload :Splunk,            "semantic_logger/appender/splunk"
-    autoload :SplunkHttp,        "semantic_logger/appender/splunk_http"
-    autoload :Syslog,            "semantic_logger/appender/syslog"
-    autoload :Tcp,               "semantic_logger/appender/tcp"
-    autoload :Udp,               "semantic_logger/appender/udp"
-    autoload :Wrapper,           "semantic_logger/appender/wrapper"
-    autoload :SentryRuby,        "semantic_logger/appender/sentry_ruby"
+    autoload :Async,               "semantic_logger/appender/async"
+    autoload :AsyncBatch,          "semantic_logger/appender/async_batch"
+    autoload :Bugsnag,             "semantic_logger/appender/bugsnag"
+    autoload :Elasticsearch,       "semantic_logger/appender/elasticsearch"
+    autoload :ElasticsearchHttp,   "semantic_logger/appender/elasticsearch_http"
+    autoload :File,                "semantic_logger/appender/file"
+    autoload :Graylog,             "semantic_logger/appender/graylog"
+    autoload :Honeybadger,         "semantic_logger/appender/honeybadger"
+    autoload :HoneybadgerInsights, "semantic_logger/appender/honeybadger_insights"
+    autoload :IO,                  "semantic_logger/appender/io"
+    autoload :Kafka,               "semantic_logger/appender/kafka"
+    autoload :Sentry,              "semantic_logger/appender/sentry"
+    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"
+    autoload :Syslog,              "semantic_logger/appender/syslog"
+    autoload :Tcp,                 "semantic_logger/appender/tcp"
+    autoload :Udp,                 "semantic_logger/appender/udp"
+    autoload :Wrapper,             "semantic_logger/appender/wrapper"
+    autoload :SentryRuby,          "semantic_logger/appender/sentry_ruby"
     # @formatter:on
 
     # Returns [SemanticLogger::Subscriber] appender for the supplied options

data/lib/semantic_logger/appenders.rb

@@ -6,6 +6,7 @@ module SemanticLogger
     def initialize(logger = Processor.logger.dup)
       @logger      = logger
       @logger.name = self.class.name
+      super()
     end
 
     def add(**args, &block)
@@ -45,18 +46,21 @@ module SemanticLogger
     end
 
     def close
-      to_a.each do |appender|
+      closed_appenders = []
+      each do |appender|
         logger.trace "Closing appender: #{appender.name}"
-        delete(appender)
+        appenders << appender
         appender.flush
         appender.close
       rescue Exception => e
         logger.error "Failed to close appender: #{appender.name}", e
       end
+      # Delete appenders outside the #each above which prevents changes during iteration.
+      closed_appenders.each { |appender| delete(appender) }
       logger.trace "All appenders closed and removed from appender list"
     end
 
-    # After a fork the appender thread is not running, start it if it is not running.
+    # After a fork reopen each appender.
     def reopen
       each do |appender|
         next unless appender.respond_to?(:reopen)

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}
@@ -342,9 +342,10 @@ module SemanticLogger
       # Add result of block to message or payload if not nil
       if block_given?
         result = yield(log)
-        if result.is_a?(String)
+        case result
+        when String
           log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
-        elsif result.is_a?(Hash)
+        when Hash
           log.assign_hash(result)
         end
       end

data/lib/semantic_logger/debug_as_trace_logger.rb

@@ -3,20 +3,9 @@ module SemanticLogger
   # This is useful for existing gems / libraries that log too much to debug
   # when most of the debug logging should be at the trace level
   class DebugAsTraceLogger < Logger
-    def debug(*args, &block)
-      trace(*args, &block)
-    end
-
-    def debug?
-      trace?
-    end
-
-    def measure_debug(*args, &block)
-      measure_trace(*args, &block)
-    end
-
-    def benchmark_debug(*args, &block)
-      measure_trace(*args, &block)
-    end
+    alias debug trace
+    alias debug? trace?
+    alias measure_debug measure_trace
+    alias benchmark_debug benchmark_trace
   end
 end

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

@@ -31,7 +31,7 @@ module SemanticLogger
       private
 
       def raw_to_logfmt
-        @parsed = @raw.slice(time_key, :level, :name, :message, :duration).merge(tag: "success")
+        @parsed = @raw.slice(time_key, :level, :name, :message, :duration, :duration_ms).merge(tag: "success")
         handle_tags
         handle_payload
         handle_exception

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/raw.rb

@@ -86,7 +86,7 @@ module SemanticLogger
 
       # Payload
       def payload
-        hash[:payload] = log.payload if log.payload&.respond_to?(:empty?) && !log.payload.empty?
+        hash[:payload] = log.payload if log.payload.respond_to?(:empty?) && !log.payload.empty?
       end
 
       # Exception

data/lib/semantic_logger/formatters/signalfx.rb

@@ -82,7 +82,10 @@ module SemanticLogger
         self.log    = log
         self.logger = logger
 
-        metric; time; value; format_dimensions
+        metric
+        time
+        value
+        format_dimensions
 
         # gauge, counter, or cumulative_counter
         data = {}
@@ -113,7 +116,10 @@ module SemanticLogger
           self.hash = {}
           self.log  = log
 
-          metric; time; value; format_dimensions
+          metric
+          time
+          value
+          format_dimensions
 
           if log.duration
             gauges = (data[:gauge] ||= [])

data/lib/semantic_logger/formatters.rb

@@ -1,16 +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 :SyslogCee, "semantic_logger/formatters/syslog_cee"
+    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

@@ -144,7 +144,9 @@ module SemanticLogger
       raise(ArgumentError, "payload must be a Hash") unless payload.is_a?(Hash)
 
       message = nil if message == ""
-      return payload if payload.key?(:payload)
+      if payload.key?(:payload)
+        return message ? payload.merge(message: message) : payload
+      end
 
       new_payload = {}
       args        = {}
@@ -219,11 +221,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
@@ -248,7 +250,11 @@ module SemanticLogger
 
     # Extract the filename and line number from the last entry in the supplied backtrace
     def extract_file_and_line(stack, short_name = false)
+      return unless stack&.size&.positive?
+
       match = CALLER_REGEXP.match(stack.first)
+      return unless match
+
       [short_name ? File.basename(match[1]) : match[1], match[2].to_i]
     end
 
@@ -256,7 +262,7 @@ module SemanticLogger
     # in either the backtrace or exception
     def file_name_and_line(short_name = false)
       stack = backtrace || exception&.backtrace
-      extract_file_and_line(stack, short_name) if stack&.size&.positive?
+      extract_file_and_line(stack, short_name)
     end
 
     # Strip the standard Rails colorizing from the logged message

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/metric/statsd.rb

@@ -28,6 +28,7 @@ module SemanticLogger
       #   )
       def initialize(url: "udp://localhost:8125")
         @url = url
+        super()
       end
 
       def reopen

data/lib/semantic_logger/semantic_logger.rb

@@ -1,4 +1,3 @@
-require "concurrent"
 require "socket"
 
 module SemanticLogger
@@ -517,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

@@ -2,26 +2,26 @@ module SemanticLogger
   # 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.
+  # are monitor protected in case SyncProcessor is being used in a multi-threaded environment.
   class SyncProcessor
     def add(*args, &block)
-      @mutex.synchronize { @appenders.add(*args, &block) }
+      @monitor.synchronize { @appenders.add(*args, &block) }
     end
 
     def log(*args, &block)
-      @mutex.synchronize { @appenders.log(*args, &block) }
+      @monitor.synchronize { @appenders.log(*args, &block) }
     end
 
     def flush
-      @mutex.synchronize { @appenders.flush }
+      @monitor.synchronize { @appenders.flush }
     end
 
     def close
-      @mutex.synchronize { @appenders.close }
+      @monitor.synchronize { @appenders.close }
     end
 
     def reopen(*args)
-      @mutex.synchronize { @appenders.reopen(*args) }
+      @monitor.synchronize { @appenders.reopen(*args) }
     end
 
     # Allow the internal logger to be overridden from its default of $stderr
@@ -47,7 +47,7 @@ module SemanticLogger
     attr_reader :appenders
 
     def initialize(appenders = nil)
-      @mutex     = Mutex.new
+      @monitor   = Monitor.new
       @appenders = appenders || Appenders.new(self.class.logger.dup)
     end
 

data/lib/semantic_logger/test/capture_log_events.rb

@@ -4,30 +4,51 @@ module SemanticLogger
     #
     # Example:
     #
-    # class UserTest < ActiveSupport::TestCase
-    #   describe User do
-    #     let(:capture_logger) { SemanticLogger::Test::CaptureLogEvents.new }
-    #     let(:user) { User.new }
+    #   class UserTest < ActiveSupport::TestCase
+    #     describe User do
+    #       let(:logger) { SemanticLogger::Test::CaptureLogEvents.new }
+    #       let(:user) { User.new }
     #
-    #     it "logs message" do
-    #       user.stub(:logger, capture_logger) do
-    #         user.enable!
+    #       it "logs message" do
+    #         user.stub(:logger, logger) do
+    #           user.enable!
+    #         end
+    #         assert log = logger.events.first
+    #         assert_equal "Hello World", log.message
+    #         assert_equal :info, log.level
     #       end
-    #       assert_equal "Hello World", capture_logger.events.last.message
-    #       assert_equal :info, capture_logger.events.last.level
     #     end
     #   end
-    # end
     class CaptureLogEvents < SemanticLogger::Subscriber
       attr_accessor :events
 
       # 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
+        Logger.call_subscribers(log)
+        @events << log
+      end
+
+      # Supports batching of log events
+      def batch(logs)
+        @events += log
+      end
+
+      def clear
+        @events.clear
+      end
+
+      # Support silencing of log messages
+      def level_index
+        @level_index || SemanticLogger.default_level_index
+      end
+
+      def to_h
+        events.map(&:to_h)
       end
     end
   end

data/lib/semantic_logger/test/minitest.rb

@@ -0,0 +1,88 @@
+module SemanticLogger
+  module Test
+    module Minitest
+      # Returns [Array<SemanticLogger::Log>] the log events from Semantic Logger
+      # captured whilst executing the supplied block.
+      #
+      # Notes:
+      # - All log messages are returned regardless of the global default log level.
+      def semantic_logger_events(deprecated_klass = nil, klass: deprecated_klass, silence: :trace, &block)
+        logger = SemanticLogger::Test::CaptureLogEvents.new
+        if klass
+          klass.stub(:logger, logger, &block)
+        elsif silence
+          SemanticLogger.silence(silence) do
+            SemanticLogger::Logger.stub(:processor, logger, &block)
+          end
+        else
+          SemanticLogger::Logger.stub(:processor, logger, &block)
+        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,
+                                       exception: nil, exception_includes: nil, backtrace: nil,
+                                       thread_name: nil, tags: nil, named_tags: nil, context: nil,
+                                       level_index: nil, duration: nil, time: nil,
+                                       metric: nil, metric_amount: nil, dimensions: nil)
+        assert event, "No log event occurred"
+
+        assert_semantic_logger_entry(event, :message, message)
+        assert_semantic_logger_entry(event, :name, name)
+        assert_semantic_logger_entry(event, :level, level)
+        assert_semantic_logger_entry(event, :thread_name, thread_name)
+        assert_semantic_logger_entry(event, :tags, tags)
+        assert_semantic_logger_entry(event, :named_tags, named_tags)
+        assert_semantic_logger_entry(event, :context, context)
+        assert_semantic_logger_entry(event, :metric, metric)
+        assert_semantic_logger_entry(event, :metric_amount, metric_amount)
+        assert_semantic_logger_entry(event, :dimensions, dimensions)
+        assert_semantic_logger_entry(event, :level_index, level_index)
+        assert_semantic_logger_entry(event, :duration, duration)
+        assert_semantic_logger_entry(event, :time, time)
+        assert_semantic_logger_entry(event, :exception, exception)
+        assert_semantic_logger_entry(event, :backtrace, backtrace)
+        assert_semantic_logger_entry(event, :payload, payload)
+
+        if message_includes
+          assert_includes(
+            event.message,
+            message_includes,
+            -> { "Expected message to include '#{message_includes}' in log event #{event.inspect}" }
+          )
+        end
+
+        if payload_includes
+          payload_includes.each_pair do |key, expected|
+            actual = event.payload[key]
+            assert_semantic_logger_entry(event, "payload #{name}", expected, actual)
+          end
+        end
+
+        if exception_includes
+          payload_includes.each_pair do |key, expected|
+            actual = event.exception.send(key)
+            assert_semantic_logger_entry(event, "Exception #{name}", expected, actual)
+          end
+        end
+      end
+
+      private
+
+      def assert_semantic_logger_entry(event, name, expected, actual = event.send(name))
+        return if expected.nil?
+
+        case expected
+        when :nil
+          assert_nil actual, "Expected nil #{name} for log event: #{event.to_h.inspect}"
+        when Class
+          assert actual.is_a?(expected), -> { "Type #{expected} expected for #{name} in log event: #{event.to_h.inspect}" }
+        else
+          assert_equal expected, actual, "Mismatched #{name} for log event: #{event.to_h.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = "4.12.0".freeze
+  VERSION = "4.16.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.12.0
+  version: 4.16.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-30 00:00:00.000000000 Z
+date: 2024-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -44,11 +44,13 @@ files:
 - lib/semantic_logger/appender/file.rb
 - lib/semantic_logger/appender/graylog.rb
 - lib/semantic_logger/appender/honeybadger.rb
+- lib/semantic_logger/appender/honeybadger_insights.rb
 - lib/semantic_logger/appender/http.rb
 - lib/semantic_logger/appender/io.rb
 - 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 +72,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 +93,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.16.0
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -111,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails