semantic_logger 4.7.4 → 4.9.0

data/lib/semantic_logger/appender/syslog.rb

@@ -57,7 +57,7 @@ module SemanticLogger
       #     Only used with the TCP protocol.
       #     Specify custom parameters to pass into Net::TCPClient.new
       #     For a list of options see the net_tcp_client documentation:
-      #       https://github.com/rocketjob/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
+      #       https://github.com/reidmorrison/net_tcp_client/blob/master/lib/net/tcp_client/tcp_client.rb
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -151,7 +151,8 @@ module SemanticLogger
           begin
             require "syslog_protocol"
           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"
+            raise LoadError,
+                  "Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol"
           end
 
           # The net_tcp_client gem is required when logging over TCP.
@@ -159,7 +160,8 @@ module SemanticLogger
             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"
+              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
         end

data/lib/semantic_logger/appender/wrapper.rb

@@ -32,7 +32,7 @@ module SemanticLogger
       #    require 'logger'
       #    require 'semantic_logger'
       #
-      #    ruby_logger = Logger.new(STDOUT)
+      #    ruby_logger = Logger.new($stdout)
       #    SemanticLogger.add_appender(logger: ruby_logger)
       #
       #    logger =  SemanticLogger['test']
@@ -45,7 +45,8 @@ module SemanticLogger
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
         does_not_implement = LEVELS[1..-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..-1].inspect}")
+          raise(ArgumentError,
+                "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
         end
 
         super(**args, &block)

data/lib/semantic_logger/appender.rb

@@ -9,6 +9,7 @@ module SemanticLogger
     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"
@@ -32,7 +33,7 @@ module SemanticLogger
       appender = build(**args, &block)
 
       # If appender implements #batch, then it should use the batch proxy by default.
-      batch = true if batch.nil? && appender.respond_to?(:batch)
+      batch    = true if batch.nil? && appender.respond_to?(:batch)
 
       if batch == true
         Appender::AsyncBatch.new(
@@ -56,8 +57,10 @@ module SemanticLogger
 
     # Returns [Subscriber] instance from the supplied options.
     def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
-      if io || file_name
-        SemanticLogger::Appender::File.new(io: io, file_name: file_name, **args, &block)
+      if file_name
+        SemanticLogger::Appender::File.new(file_name, **args, &block)
+      elsif io
+        SemanticLogger::Appender::IO.new(io, **args, &block)
       elsif logger
         SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
       elsif appender
@@ -66,7 +69,8 @@ module SemanticLogger
         elsif appender.is_a?(Subscriber)
           appender
         else
-          raise(ArgumentError, "Parameter :appender must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+          raise(ArgumentError,
+                "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)
@@ -74,10 +78,12 @@ module SemanticLogger
         elsif metric.is_a?(Subscriber)
           metric
         else
-          raise(ArgumentError, "Parameter :metric must be either a Symbol or an object derived from SemanticLogger::Subscriber, not: #{appender.inspect}")
+          raise(ArgumentError,
+                "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")
+        raise(ArgumentError,
+              "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

@@ -10,42 +10,48 @@ module SemanticLogger
 
     def add(**args, &block)
       appender = SemanticLogger::Appender.factory(**args, &block)
+
+      if appender.respond_to?(:console_output?) && appender.console_output? && console_output?
+        logger.warn "Ignoring attempt to add a second console appender: #{appender.class.name} since it would result in duplicate console output."
+        return
+      end
+
       self << appender
       appender
     end
 
+    # Whether any of the existing appenders already output to the console?
+    # I.e. Writes to stdout or stderr.
+    def console_output?
+      any? { |appender| appender.respond_to?(:console_output?) && appender.console_output? }
+    end
+
     def log(log)
       each do |appender|
-        begin
-          appender.log(log) if appender.should_log?(log)
-        rescue Exception => e
-          logger.error "Failed to log to appender: #{appender.name}", e
-        end
+        appender.log(log) if appender.should_log?(log)
+      rescue Exception => e
+        logger.error "Failed to log to appender: #{appender.name}", e
       end
     end
 
     def flush
       each do |appender|
-        begin
-          logger.trace "Flushing appender: #{appender.name}"
-          appender.flush
-        rescue Exception => e
-          logger.error "Failed to flush appender: #{appender.name}", e
-        end
+        logger.trace "Flushing appender: #{appender.name}"
+        appender.flush
+      rescue Exception => e
+        logger.error "Failed to flush appender: #{appender.name}", e
       end
       logger.trace "All appenders flushed"
     end
 
     def close
-      each do |appender|
-        begin
-          logger.trace "Closing appender: #{appender.name}"
-          appender.flush
-          appender.close
-          delete(appender)
-        rescue Exception => e
-          logger.error "Failed to close appender: #{appender.name}", e
-        end
+      to_a.each do |appender|
+        logger.trace "Closing appender: #{appender.name}"
+        delete(appender)
+        appender.flush
+        appender.close
+      rescue Exception => e
+        logger.error "Failed to close appender: #{appender.name}", e
       end
       logger.trace "All appenders closed and removed from appender list"
     end
@@ -53,14 +59,12 @@ module SemanticLogger
     # After a fork the appender thread is not running, start it if it is not running.
     def reopen
       each do |appender|
-        begin
-          next unless appender.respond_to?(:reopen)
+        next unless appender.respond_to?(:reopen)
 
-          logger.trace "Reopening appender: #{appender.name}"
-          appender.reopen
-        rescue Exception => e
-          logger.error "Failed to re-open appender: #{appender.name}", e
-        end
+        logger.trace "Reopening appender: #{appender.name}"
+        appender.reopen
+      rescue Exception => e
+        logger.error "Failed to re-open appender: #{appender.name}", e
       end
       logger.trace "All appenders re-opened"
     end

data/lib/semantic_logger/base.rb

@@ -63,7 +63,7 @@ module SemanticLogger
     #    SemanticLogger.default_level = :info
     #
     #    # Log to screen
-    #    SemanticLogger.add_appender(io: STDOUT, formatter: :color)
+    #    SemanticLogger.add_appender(io: $stdout, formatter: :color)
     #
     #    # And log to a file at the same time
     #    SemanticLogger.add_appender(file_name: 'application.log', formatter: :color)
@@ -136,7 +136,7 @@ module SemanticLogger
 
       backtrace =
         if thread == Thread.current
-          Utils.extract_backtrace
+          Utils.extract_backtrace(caller)
         else
           log.thread_name = thread.name
           log.tags        = (thread[:semantic_logger_tags] || []).clone
@@ -188,7 +188,8 @@ module SemanticLogger
     # - For better performance with clean tags, see `SemanticLogger.tagged`.
     def tagged(*tags, &block)
       # Allow named tags to be passed into the logger
-      if tags.size == 1
+      # Rails::Rack::Logger passes logs as an array with a single argument
+      if tags.size == 1 && !tags.first.is_a?(Array)
         tag = tags[0]
         return yield if tag.nil? || tag == ""
 
@@ -376,7 +377,7 @@ module SemanticLogger
         exception = e
       ensure
         # Must use ensure block otherwise a `return` in the yield above will skip the log entry
-        log       = Log.new(name, level, index)
+        log = Log.new(name, level, index)
         exception ||= params[:exception]
         message   = params[:message] if params[:message]
         duration  =

data/lib/semantic_logger/formatters/base.rb

@@ -70,6 +70,7 @@ module SemanticLogger
 
       # Return the Time as a formatted string
       def format_time(time)
+        time = time.dup
         case time_format
         when :rfc_3339
           time.utc.to_datetime.rfc3339

data/lib/semantic_logger/formatters/color.rb

@@ -109,14 +109,14 @@ module SemanticLogger
       def payload
         return unless log.payload?
 
-        if !log.payload.respond_to?(:ai)
-          super
-        else
+        if log.payload.respond_to?(:ai)
           begin
             "-- #{log.payload.ai(@ai_options)}"
           rescue StandardError
             super
           end
+        else
+          super
         end
       end
 

data/lib/semantic_logger/formatters/logfmt.rb

@@ -0,0 +1,72 @@
+require "json"
+
+module SemanticLogger
+  module Formatters
+    # Produces logfmt formatted messages
+    #
+    # The following fields are extracted from the raw log and included in the formatted message:
+    #   :timestamp, :level, :name, :message, :duration, :tags, :named_tags
+    #
+    # E.g.
+    #   timestamp="2020-07-20T08:32:05.375276Z" level=info name="DefaultTest" base="breakfast" spaces="second breakfast" double_quotes="\"elevensies\"" single_quotes="'lunch'" tag="success"
+    #
+    # All timestamps are ISO8601 formatteed
+    # All user supplied values are escaped and surrounded by double quotes to avoid ambiguious message delimeters
+    # `tags` are treated as keys with boolean values. Tag names are not formatted or validated, ensure you use valid logfmt format for tag names.
+    # `named_tags` are flattened are merged into the top level message field. Any conflicting fields are overridden.
+    # `payload` values take precedence over `tags` and `named_tags`. Any conflicting fields are overridden.
+    #
+    # Futher Reading https://brandur.org/logfmt
+    class Logfmt < Raw
+      def initialize(time_format: :iso_8601, time_key: :timestamp, **args)
+        super(time_format: time_format, time_key: time_key, **args)
+      end
+
+      def call(log, logger)
+        @raw = super(log, logger)
+
+        raw_to_logfmt
+      end
+
+      private
+
+      def raw_to_logfmt
+        @parsed = @raw.slice(time_key, :level, :name, :message, :duration).merge(tag: "success")
+        handle_tags
+        handle_payload
+        handle_exception
+
+        flatten_log
+      end
+
+      def handle_tags
+        tags = @raw.fetch(:tags){ [] }
+                    .each_with_object({}){ |tag, accum| accum[tag] = true }
+
+        @parsed = @parsed.merge(tags)
+                         .merge(@raw.fetch(:named_tags){ {} })
+      end
+
+      def handle_payload
+        return unless @raw.key? :payload
+
+        @parsed = @parsed.merge(@raw[:payload])
+      end
+
+      def handle_exception
+        return unless @raw.key? :exception
+
+        @parsed[:tag] = "exception"
+        @parsed = @parsed.merge(@raw[:exception])
+      end
+
+      def flatten_log
+        flattened = @parsed.map do |key, value|
+          "#{key}=#{value.to_json}"
+        end
+
+        flattened.join(" ")
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/syslog.rb

@@ -1,7 +1,8 @@
 begin
   require "syslog_protocol"
 rescue LoadError
-  raise LoadError, 'Gem syslog_protocol is required for remote logging using the Syslog protocol. Please add the gem "syslog_protocol" to your Gemfile.'
+  raise LoadError,
+        'Gem syslog_protocol is required for remote logging using the Syslog protocol. Please add the gem "syslog_protocol" to your Gemfile.'
 end
 
 module SemanticLogger

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -1,7 +1,8 @@
 begin
   require "syslog_protocol"
 rescue LoadError
-  raise LoadError, 'Gem syslog_protocol is required for remote logging using the Syslog protocol. Please add the gem "syslog_protocol" to your Gemfile.'
+  raise LoadError,
+        'Gem syslog_protocol is required for remote logging using the Syslog protocol. Please add the gem "syslog_protocol" to your Gemfile.'
 end
 
 module SemanticLogger

data/lib/semantic_logger/formatters.rb

@@ -1,16 +1,15 @@
 module SemanticLogger
   module Formatters
-    # @formatter:off
-    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"
-    # @formatter:on
+    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"
 
     # Return formatter that responds to call.
     #

data/lib/semantic_logger/log.rb

@@ -114,14 +114,12 @@ module SemanticLogger
 
       # Elastic logging: Log when :duration exceeds :min_duration
       # Except if there is an exception when it will always be logged
-      if duration
-        return false if (duration < min_duration) && exception.nil?
-      end
+      return false if duration && ((duration < min_duration) && exception.nil?)
 
       if backtrace
         self.backtrace = Utils.extract_backtrace(backtrace)
       elsif level_index >= SemanticLogger.backtrace_level_index
-        self.backtrace = Utils.extract_backtrace
+        self.backtrace = Utils.extract_backtrace(caller)
       end
 
       true

data/lib/semantic_logger/loggable.rb

@@ -8,7 +8,7 @@
 # Example:
 #   require 'semantic_logger'
 #   SemanticLogger.default_level = :debug
-#   SemanticLogger.add_appender(io: STDOUT, formatter: :color)
+#   SemanticLogger.add_appender(io: $stdout, formatter: :color)
 #
 #   class ExternalSupplier
 #     # Create class and instance logger methods
@@ -32,7 +32,14 @@ module SemanticLogger
   module Loggable
     def self.included(base)
       base.extend ClassMethods
+      base.singleton_class.class_eval do
+        undef_method :logger if method_defined?(:logger)
+        undef_method :logger= if method_defined?(:logger=)
+      end
       base.class_eval do
+        undef_method :logger if method_defined?(:logger)
+        undef_method :logger= if method_defined?(:logger=)
+
         # Returns [SemanticLogger::Logger] class level logger
         def self.logger
           @semantic_logger ||= SemanticLogger[self]

data/lib/semantic_logger/logger.rb

@@ -21,7 +21,19 @@ module SemanticLogger
     end
 
     def self.processor
-      @processor ||= SemanticLogger.sync? ? SyncProcessor.new : Processor.new
+      @processor ||= Processor.new
+    end
+
+    # Switch to the synchronous processor
+    def self.sync!
+      return if @processor.is_a?(SyncProcessor)
+
+      @processor = SyncProcessor.new(@processor&.appenders)
+    end
+
+    # Running without the background logging thread?
+    def self.sync?
+      processor.is_a?(SyncProcessor)
     end
 
     # Returns a Logger instance
@@ -70,11 +82,9 @@ module SemanticLogger
       return unless @subscribers
 
       @subscribers.each do |subscriber|
-        begin
-          subscriber.call(log)
-        rescue Exception => e
-          processor.logger.error("Exception calling :on_log subscriber", e)
-        end
+        subscriber.call(log)
+      rescue Exception => e
+        processor.logger.error("Exception calling :on_log subscriber", e)
       end
     end
   end

data/lib/semantic_logger/processor.rb

@@ -1,7 +1,7 @@
 module SemanticLogger
   # Thread that submits and processes log requests
   class Processor < Appender::Async
-    # Allow the internal logger to be overridden from its default of STDERR
+    # 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
     #   SemanticLogger::Logger itself since it is for reporting problems
     #   while trying to log to the various appenders
@@ -11,11 +11,11 @@ module SemanticLogger
 
     # Internal logger for SemanticLogger
     #   For example when an appender is not working etc..
-    #   By default logs to STDERR
+    #   By default logs to $stderr
     def self.logger
       @logger ||=
         begin
-          l      = SemanticLogger::Appender::File.new(io: STDERR, level: :warn)
+          l      = SemanticLogger::Appender::IO.new($stderr, level: :warn)
           l.name = name
           l
         end

data/lib/semantic_logger/semantic_logger.rb

@@ -101,7 +101,7 @@ module SemanticLogger
   #   Or,
   #   io: [IO]
   #     An IO Stream to log to.
-  #     For example STDOUT, STDERR, etc.
+  #     For example $stdout, $stderr, etc.
   #
   #   Or,
   #   appender: [Symbol|SemanticLogger::Subscriber]
@@ -122,7 +122,7 @@ module SemanticLogger
   #     Default: SemanticLogger.default_level
   #
   #   formatter: [Symbol|Object|Proc]
-  #     Any of the following symbol values: :default, :color, :json
+  #     Any of the following symbol values: :default, :color, :json, :logfmt, etc...
   #       Or,
   #     An instance of a class that implements #call
   #       Or,
@@ -138,14 +138,14 @@ module SemanticLogger
   # Examples:
   #
   #   # Send all logging output to Standard Out (Screen)
-  #   SemanticLogger.add_appender(io: STDOUT)
+  #   SemanticLogger.add_appender(io: $stdout)
   #
   #   # Send all logging output to a file
   #   SemanticLogger.add_appender(file_name: 'logfile.log')
   #
   #   # Send all logging output to a file and only :info and above to standard output
   #   SemanticLogger.add_appender(file_name: 'logfile.log')
-  #   SemanticLogger.add_appender(io: STDOUT, level: :info)
+  #   SemanticLogger.add_appender(io: $stdout, level: :info)
   #
   # Log to log4r, Logger, etc.:
   #
@@ -154,7 +154,7 @@ module SemanticLogger
   #   require 'semantic_logger'
   #
   #   # Built-in Ruby logger
-  #   log = Logger.new(STDOUT)
+  #   log = Logger.new($stdout)
   #   log.level = Logger::DEBUG
   #
   #   SemanticLogger.default_level = :debug
@@ -164,7 +164,7 @@ module SemanticLogger
   #   logger.info "Hello World"
   #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
   def self.add_appender(**args, &block)
-    appender = Logger.processor.appenders.add(**args, &block)
+    appender = appenders.add(**args, &block)
     # Start appender thread if it is not already running
     Logger.processor.start
     appender
@@ -173,7 +173,15 @@ module SemanticLogger
   # Remove an existing appender
   # Currently only supports appender instances
   def self.remove_appender(appender)
-    Logger.processor.appenders.delete(appender)
+    return unless appender
+
+    appenders.delete(appender)
+    appender.close
+  end
+
+  # Clear out all previously registered appenders
+  def self.clear_appenders!
+    Logger.processor.close
   end
 
   # Returns [SemanticLogger::Subscriber] a copy of the list of active
@@ -181,7 +189,7 @@ module SemanticLogger
   # Use SemanticLogger.add_appender and SemanticLogger.remove_appender
   # to manipulate the active appenders list
   def self.appenders
-    Logger.processor.appenders.to_a
+    Logger.processor.appenders
   end
 
   # Flush all queued log entries disk, database, etc.
@@ -494,12 +502,12 @@ module SemanticLogger
   # I.e. Instead of logging messages in a separate thread for better performance,
   # log them using the current thread.
   def self.sync!
-    @sync = true
+    Logger.sync!
   end
 
   # Running in synchronous mode?
   def self.sync?
-    @sync
+    Logger.sync?
   end
 
   # Initial default Level for all new instances of SemanticLogger::Logger

data/lib/semantic_logger/subscriber.rb

@@ -22,6 +22,11 @@ module SemanticLogger
       # NOOP
     end
 
+    # Method called to log an event
+    def log(log)
+      raise NotImplementedError
+    end
+
     # Returns [SemanticLogger::Formatters::Default] default formatter for this subscriber.
     def default_formatter
       SemanticLogger::Formatters::Default.new
@@ -68,6 +73,11 @@ module SemanticLogger
       super(log) && (log.metric_only? ? metrics? : true)
     end
 
+    # Whether this appender is logging to stdout or stderror
+    def console_output?
+      false
+    end
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Subscriber

data/lib/semantic_logger/sync_processor.rb

@@ -10,7 +10,7 @@ module SemanticLogger
     def_delegator :@appenders, :close
     def_delegator :@appenders, :reopen
 
-    # Allow the internal logger to be overridden from its default of STDERR
+    # 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
     #   SemanticLogger::Logger itself since it is for reporting problems
     #   while trying to log to the various appenders
@@ -20,11 +20,11 @@ module SemanticLogger
 
     # Internal logger for SemanticLogger
     #   For example when an appender is not working etc..
-    #   By default logs to STDERR
+    #   By default logs to $stderr
     def self.logger
       @logger ||=
         begin
-          l      = SemanticLogger::Appender::File.new(io: STDERR, level: :warn)
+          l      = SemanticLogger::Appender::IO.new($stderr, level: :warn)
           l.name = name
           l
         end
@@ -32,8 +32,8 @@ module SemanticLogger
 
     attr_reader :appenders
 
-    def initialize
-      @appenders = Appenders.new(self.class.logger.dup)
+    def initialize(appenders = nil)
+      @appenders = appenders || Appenders.new(self.class.logger.dup)
     end
 
     def start

data/lib/semantic_logger/test/capture_log_events.rb

@@ -0,0 +1,34 @@
+module SemanticLogger
+  module Test
+    # Logging class to captures all logging events in memory.
+    #
+    # Example:
+    #
+    # class UserTest < ActiveSupport::TestCase
+    #   describe User do
+    #     let(:capture_logger) { SemanticLogger::Test::CaptureLogEvents.new }
+    #     let(:user) { User.new }
+    #
+    #     it "logs message" do
+    #       user.stub(:logger, capture_logger) do
+    #         user.enable!
+    #       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)
+      end
+
+      def log(log)
+        (@events ||= []) << log
+      end
+    end
+  end
+end