semantic_logger 4.7.2 → 4.10.0

data/lib/semantic_logger/appender/io.rb

@@ -0,0 +1,68 @@
+# File appender
+#
+#   Writes log messages to a file or open iostream
+#
+module SemanticLogger
+  module Appender
+    class IO < SemanticLogger::Subscriber
+      # Create a Stream Logger appender instance.
+      #
+      # Parameters
+      #  io [IO]
+      #    An IO stream to which to write the log messages to.
+      #
+      #  :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: 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.
+      #
+      # Example
+      #    require "semantic_logger"
+      #
+      #    # Enable trace level logging
+      #    SemanticLogger.default_level = :info
+      #
+      #    # Log to screen
+      #    SemanticLogger.add_appender(io: $stdout, formatter: :color)
+      #
+      #    logger = SemanticLogger['test']
+      #    logger.info 'Hello World'
+      def initialize(io, **args, &block)
+        @io = io
+        unless @io.respond_to?(:write)
+          raise(ArgumentError, "SemanticLogging::Appender::IO io is not a valid IO instance: #{io.inspect}")
+        end
+
+        super(**args, &block)
+      end
+
+      def log(log)
+        # Since only one appender thread will be writing to the file at a time
+        # it is not necessary to protect access to the file with a semaphore
+        # Allow this logger to filter out log levels lower than it's own
+        @io.write(formatter.call(log, self) << "\n")
+        true
+      end
+
+      # Flush all pending logs to disk.
+      #  Waits for all sent documents to be written to disk
+      def flush
+        @io.flush if @io.respond_to?(:flush)
+      end
+
+      def console_output?
+        [$stderr, $stdout].include?(@io)
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/kafka.rb

@@ -183,6 +183,10 @@ module SemanticLogger
           delivery_interval:  delivery_interval
         )
       end
+
+      private
+
+      attr_reader :producer
     end
   end
 end

data/lib/semantic_logger/appender/sentry_ruby.rb

@@ -0,0 +1,138 @@
+begin
+  require "sentry-ruby"
+rescue LoadError
+  raise LoadError, 'Gem sentry-ruby is required for logging purposes. Please add the gem "sentry-ruby" to your Gemfile.'
+end
+
+# Send log messages to sentry
+#
+# Example:
+#   SemanticLogger.add_appender(appender: :sentry_ruby)
+#
+module SemanticLogger
+  module Appender
+    class SentryRuby < SemanticLogger::Subscriber
+      # Create 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: :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] }
+        super(level: level, **args, &block)
+      end
+
+      # Send an error notification to sentry
+      def log(log)
+        # Ignore logs coming from Sentry itself
+        return false if log.name == "Sentry"
+
+        context = formatter.call(log, self)
+        payload = context.delete(:payload) || {}
+        named_tags = context[:named_tags] || {}
+        transaction_name = named_tags.delete(:transaction_name)
+
+        user = extract_user!(named_tags, payload)
+        tags = extract_tags!(context)
+
+        fingerprint = payload.delete(:fingerprint)
+
+        ::Sentry.with_scope do |scope|
+          scope.set_user(user) if user
+          scope.set_level(context.delete(:level)) if context[:level]
+          scope.set_fingerprint(fingerprint) if fingerprint
+          scope.set_transaction_name(transaction_name) if transaction_name
+          scope.set_tags(tags)
+          scope.set_extras(context)
+          scope.set_extras(payload)
+
+          if log.exception
+            ::Sentry.capture_exception(log.exception)
+          elsif log.backtrace
+            ::Sentry.capture_message(context[:message], backtrace: log.backtrace)
+          else
+            ::Sentry.capture_message(context[:message])
+          end
+        end
+
+        true
+      end
+
+      private
+
+      # Use Raw Formatter by default
+      def default_formatter
+        SemanticLogger::Formatters::Raw.new
+      end
+
+      # Extract user data from named tags or payload.
+      #
+      # Keys :user_id and :user_email will be used as :id and :email respectively.
+      # Keys :username and :ip_address will be used verbatim.
+      #
+      # Any additional value nested in a :user key will be added, provided any of
+      # the above keys is already present.
+      #
+      def extract_user!(*sources)
+        keys = {user_id: :id, username: :username, user_email: :email, ip_address: :ip_address}
+
+        user = {}
+
+        sources.each do |source|
+          keys.each do |source_key, target_key|
+            value = source.delete(source_key)
+            user[target_key] = value if value
+          end
+        end
+
+        return if user.empty?
+
+        sources.each do |source|
+          extras = source.delete(:user)
+          user.merge!(extras) if extras.is_a?(Hash)
+        end
+
+        user
+      end
+
+      # Extract tags.
+      #
+      # Named tags will be stringified (both key and value).
+      # Unnamed tags will be stringified and joined with a comma. Then they will
+      # be used as a "tag" named tag. If such a tag already exists, it is also
+      # joined with a comma.
+      #
+      # Finally, the tag names are limited to 32 characters and the tag values to 256.
+      #
+      def extract_tags!(context)
+        named_tags = context.delete(:named_tags) || {}
+        named_tags = named_tags.map { |k, v| [k.to_s, v.to_s] }.to_h
+        tags = context.delete(:tags)
+        named_tags.merge!("tag" => tags.join(", ")) { |_, v1, v2| "#{v1}, #{v2}" } if tags
+        named_tags.map { |k, v| [k[0...32], v[0...256]] }.to_h
+      end
+    end
+  end
+end

data/lib/semantic_logger/appender/splunk.rb

@@ -1,7 +1,8 @@
 begin
   require "splunk-sdk-ruby"
 rescue LoadError
-  raise LoadError, 'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
+  raise LoadError,
+        'Gem splunk-sdk-ruby is required for logging to Splunk. Please add the gem "splunk-sdk-ruby" to your Gemfile.'
 end
 
 # Splunk log appender.

data/lib/semantic_logger/appender/splunk_http.rb

@@ -89,8 +89,9 @@ module SemanticLogger
       # For splunk format requirements see:
       #   https://docs.splunk.com/Documentation/Splunk/latest/Data/FormateventsforHTTPEventCollector
       def call(log, logger)
-        h                     = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
-        message               = {
+        h = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
+        h.delete(:host)
+        message = {
           source: logger.application,
           host:   logger.host,
           time:   h.delete(:time),

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"
@@ -21,6 +22,7 @@ module SemanticLogger
     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
@@ -32,7 +34,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 +58,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 +70,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 +79,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 == ""
 
@@ -263,14 +264,22 @@ module SemanticLogger
     #    For example if set to :warn, this appender would only log :warn and :fatal
     #    log messages when other appenders could be logging :info and lower
     #
-    #  filter [Regexp|Proc]
+    #  filter [Regexp|Proc|Module]
     #    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
+    #    Module: A module that implements `.call`. For example:
+    #      module ComplexFilter
+    #        def self.call(log)
+    #          (/\AExclude/ =~ log.message).nil?
+    #        end
+    #      end
     def initialize(klass, level = nil, filter = nil)
-      # Support filtering all messages to this logger using a Regular Expression or Proc
-      raise ":filter must be a Regexp or Proc" unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc)
+      # Support filtering all messages to this logger instance.
+      unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc) || filter.respond_to?(:call)
+        raise ":filter must be a Regexp, Proc, or implement :call"
+      end
 
       @filter = filter.is_a?(Regexp) ? filter.freeze : filter
       @name   = klass.is_a?(String) ? klass : klass.name
@@ -368,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.
     #