semantic_logger 4.7.1 → 4.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53de576d3dea3ae2099d237648a027026469632dda0f8c3840557c648ddb0626
-  data.tar.gz: a2fe41e466fd682cc536f33331698a74b19d9026cde7604db93f859e70686d25
+  metadata.gz: c969376e41c290b01fd22a111b1eca500ab4a01e80e13d4fbf18b800b9c50c9e
+  data.tar.gz: 4319e88ebd250dd524add711cd16508d8f825686cfa28731f19d52c35854d738
 SHA512:
-  metadata.gz: c9c53adbda24e55a427945f9c5953c6e53c244af0c00b4f81ba59c92c3e052d9f7306fc8941bbf0960d665757c56b4089bbc1214255fdfc5ec085fdda24b601e
-  data.tar.gz: 700143b4c0b34e347539b7b2fccd363683b45577a5520accd55a308175f92975ca041152ca03353f7e23ec71eb9189e6de54ff8f985eecf414d51b8900b2ad96
+  metadata.gz: 435ada2480d22e98e3e4467086167411f0620f9a0fd4d9210bb715c7a7ef3defe08986afaf8b174aeb55a5bde8ba46dfefea1c8d693c78623495755d2a41c6e2
+  data.tar.gz: bb2a64552713ae4fcb3b3ae59133e4a5241ecb4692ddc7304e77f72bc76ef47e219cfd481dbebd482385e7b53e161d15b245b644c01030e9cb021c65ec222d0a

data/README.md

@@ -1,15 +1,13 @@
 # Semantic Logger
-[![Gem Version](https://img.shields.io/gem/v/semantic_logger.svg)](https://rubygems.org/gems/semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/semantic_logger) [![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) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/support)
+[![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.  
 
-* https://rocketjob.github.io/semantic_logger/
+* https://logger.rocketjob.io/
 
 ## Documentation
 
-[Semantic Logger Guide](http://rocketjob.github.io/semantic_logger)
-
-[Reference Documentation](http://www.rubydoc.info/gems/semantic_logger/)
+[Semantic Logger Guide](https://logger.rocketjob.io/)
 
 ## Upgrading to Semantic Logger v4.4
 
@@ -50,7 +48,7 @@ handles saving log information to multiple destinations / appenders.
 
 ## Rails
 
-When running Rails, use [rails_semantic_logger](http://github.com/rocketjob/rails_semantic_logger)
+When running Rails, use [rails_semantic_logger](http://github.com/reidmorrison/rails_semantic_logger)
 instead of Semantic Logger directly since it will automatically replace the Rails default logger with Semantic Logger.
 
 ## Rocket Job
@@ -129,13 +127,13 @@ SemanticLogger.default_level = :trace
 SemanticLogger.add_appender(file_name: 'development.log', formatter: :color)
 ~~~
 
-If running rails, see: [Semantic Logger Rails](http://rocketjob.github.io/semantic_logger/rails.html)
+If running rails, see: [Semantic Logger Rails](https://logger.rocketjob.io/rails.html)
 
 ## Author
 
 [Reid Morrison](https://github.com/reidmorrison)
 
-[Contributors](https://github.com/rocketjob/semantic_logger/graphs/contributors)
+[Contributors](https://github.com/reidmorrison/semantic_logger/graphs/contributors)
 
 ## Versioning
 

data/lib/semantic_logger/appender.rb

@@ -66,7 +66,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 +75,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/appender/async.rb

@@ -53,7 +53,7 @@ module SemanticLogger
       # Re-open appender after a fork
       def reopen
         # Workaround CRuby crash on fork by recreating queue on reopen
-        #   https://github.com/rocketjob/semantic_logger/issues/103
+        #   https://github.com/reidmorrison/semantic_logger/issues/103
         @queue&.close
         create_queue
 

data/lib/semantic_logger/appender/bugsnag.rb

@@ -40,42 +40,55 @@ module SemanticLogger
 
       # Returns [Hash] of parameters to send to Bugsnag.
       def call(log, logger)
-        h            = SemanticLogger::Formatters::Raw.new.call(log, logger)
-        h[:severity] = log_level(log)
-        h.delete(:message) if h[:exception] && (h[:message] == h[:exception][:message])
-        h.delete(:time)
-        h.delete(:exception)
-        h
+        hash = SemanticLogger::Formatters::Raw.new.call(log, logger)
+        hash.delete(:message) if hash[:exception] && (hash[:message] == hash[:exception][:message])
+        hash.delete(:time)
+        hash.delete(:level_index)
+        hash.delete(:exception)
+        hash[:file] = "#{hash[:file]}:#{hash.delete(:line)}" if hash.key?(:file)
+        hash
       end
 
-      # Send an error notification to Bugsnag
       def log(log)
         # Ignore logs coming from Bugsnag itself
         return false if log.name == "Bugsnag"
 
         # Send error messages as Runtime exceptions
-        exception =
-          if log.exception
-            # Manually constructed Exception, without a backtrace.
-            log.exception.set_backtrace(log.backtrace) if !log.exception.backtrace && log.backtrace
-            log.exception
-          else
-            error = RuntimeError.new(log.message)
-            error.set_backtrace(log.backtrace) if log.backtrace
-            error
-          end
-
-        # For more documentation on the Bugsnag.notify method see:
-        # https://bugsnag.com/docs/notifiers/ruby#sending-handled-exceptions
-        ::Bugsnag.notify(exception, formatter.call(log, self))
+        exception = extract_exception(log)
+        hash      = formatter.call(log, self)
+        bugsnag_notify(exception, hash, log_level(log.level))
         true
       end
 
       private
 
+      def bugsnag_notify(exception, hash, level)
+        if ::Bugsnag::VERSION.to_i >= 6
+          ::Bugsnag.notify(exception) do |report|
+            report.severity = level
+            hash.each_pair { |key, value| report.add_tab(key, value) }
+          end
+        else
+          hash[:severity] = level
+          ::Bugsnag.notify(exception, hash)
+        end
+      end
+
+      def extract_exception(log)
+        if log.exception
+          # Manually constructed Exception, without a backtrace.
+          log.exception.set_backtrace(log.backtrace) if !log.exception.backtrace && log.backtrace
+          return log.exception
+        end
+
+        error = RuntimeError.new(log.message)
+        error.set_backtrace(log.backtrace) if log.backtrace
+        error
+      end
+
       # Bugsnag supports: error, warning or info
-      def log_level(log)
-        case log.level
+      def log_level(level)
+        case level
         when :error, :fatal
           "error"
         when :warn

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -1,7 +1,8 @@
 begin
   require "elasticsearch"
 rescue LoadError
-  raise LoadError, 'Gem elasticsearch is required for logging to Elasticsearch. Please add the gem "elasticsearch" to your Gemfile.'
+  raise LoadError,
+        'Gem elasticsearch is required for logging to Elasticsearch. Please add the gem "elasticsearch" to your Gemfile.'
 end
 
 require "date"
@@ -17,7 +18,8 @@ require "date"
 module SemanticLogger
   module Appender
     class Elasticsearch < SemanticLogger::Subscriber
-      attr_accessor :url, :index, :date_pattern, :type, :client, :flush_interval, :timeout_interval, :batch_size, :elasticsearch_args
+      attr_accessor :url, :index, :date_pattern, :type, :client, :flush_interval, :timeout_interval, :batch_size,
+                    :elasticsearch_args
 
       # Create Elasticsearch appender over persistent HTTP(S)
       #

data/lib/semantic_logger/appender/file.rb

@@ -36,7 +36,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)
@@ -52,7 +52,7 @@ module SemanticLogger
       #    SemanticLogger.default_level = :trace
       #
       #    # Log to screen but only display :info and above
-      #    SemanticLogger.add_appender(io: STDOUT, level: :info)
+      #    SemanticLogger.add_appender(io: $stdout, level: :info)
       #
       #    # And log to a file at the same time, including all :trace level data
       #    SemanticLogger.add_appender(file_name: 'application.log')
@@ -105,6 +105,10 @@ module SemanticLogger
       def flush
         @log.flush if @log.respond_to?(:flush)
       end
+
+      def console_output?
+        [$stderr, $stdout].include?(@log)
+      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/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

@@ -31,7 +31,7 @@ require "socket"
 module SemanticLogger
   module Appender
     class Syslog < SemanticLogger::Subscriber
-      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map
+      attr_reader :remote_syslog, :url, :server, :port, :protocol, :facility, :options, :level_map, :max_size
 
       # Create a Syslog appender instance.
       #
@@ -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.
@@ -73,6 +73,10 @@ module SemanticLogger
       #     Identity of the program.
       #     Default: SemanticLogger.application
       #
+      #   max_size: [Integer]
+      #     Set your own packet size.
+      #     Default: 1024 bytes
+      #
       #   options: [Integer]
       #     Default: ::Syslog::LOG_PID | ::Syslog::LOG_CONS
       #     Any of the following (options can be logically OR'd together)
@@ -121,6 +125,7 @@ module SemanticLogger
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
       def initialize(url: "syslog://localhost",
                      facility: ::Syslog::LOG_USER,
+                     max_size: 1024,
                      level_map: SemanticLogger::Formatters::Syslog::LevelMap.new,
                      options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
                      tcp_client: {},
@@ -129,6 +134,7 @@ module SemanticLogger
 
         @options            = options
         @facility           = facility
+        @max_size           = max_size
         @level_map          = level_map
         @url                = url
         uri                 = URI(@url)
@@ -145,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.
@@ -153,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
@@ -209,7 +217,7 @@ module SemanticLogger
           # Format is text output without the time
           SemanticLogger::Formatters::Default.new(time_format: nil)
         else
-          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map)
+          SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)
         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/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
@@ -263,14 +263,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 +376,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.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/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,54 @@
+require "json"
+
+module SemanticLogger
+  module Formatters
+    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(:timestamp, :level, :name, :message, :duration).merge tag: "success"
+        handle_payload
+        handle_exception
+
+        flatten_log
+      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}=#{parse_value(value)}"
+        end
+
+        flattened.join(" ")
+      end
+
+      def parse_value(value)
+        return value.to_json if value.instance_of? String
+
+        value
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/syslog.rb

@@ -1,13 +1,14 @@
 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
   module Formatters
     class Syslog < Default
-      attr_accessor :level_map, :facility
+      attr_accessor :level_map, :facility, :max_size
 
       # Default level map for every log level
       #
@@ -50,9 +51,10 @@ module SemanticLogger
       #   Example:
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
-      def initialize(facility: ::Syslog::LOG_USER, level_map: LevelMap.new)
+      def initialize(facility: ::Syslog::LOG_USER, level_map: LevelMap.new, max_size: Integer)
         @facility  = facility
         @level_map = level_map.is_a?(LevelMap) ? level_map : LevelMap.new(level_map)
+        @max_size = max_size
         super()
       end
 
@@ -77,7 +79,7 @@ module SemanticLogger
         packet.content  = message
         packet.time     = log.time
         packet.severity = level_map[log.level]
-        packet.to_s
+        packet.assemble(@max_size)
       end
     end
   end

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -1,13 +1,14 @@
 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
   module Formatters
     class SyslogCee < Raw
-      attr_accessor :level_map, :facility
+      attr_accessor :level_map, :facility, :max_size
 
       # CEE JSON Syslog format
       #   Untested prototype code. Based on documentation only.
@@ -23,9 +24,10 @@ module SemanticLogger
       # Example:
       #   # Log via udp to a remote syslog server on host: `server1` and port `8514`, using the CEE format.
       #   SemanticLogger.add_appender(appender: :syslog, formatter: syslog_cee, url: 'udp://server1:8514')
-      def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new)
+      def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new, max_size: Integer)
         @facility  = facility
         @level_map = level_map.is_a?(SemanticLogger::Formatters::Syslog::LevelMap) ? level_map : SemanticLogger::Formatters::Syslog::LevelMap.new(level_map)
+        @max_size = max_size
         super()
       end
 
@@ -49,7 +51,7 @@ module SemanticLogger
         packet.content  = message
         packet.time     = log.time
         packet.severity = level_map[log.level]
-        packet.to_s
+        packet.assemble(@max_size)
       end
     end
   end

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

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::File.new(io: $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]
@@ -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
@@ -173,7 +173,15 @@ module SemanticLogger
   # Remove an existing appender
   # Currently only supports appender instances
   def self.remove_appender(appender)
+    return unless appender
+
     Logger.processor.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
@@ -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/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::File.new(io: $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/utils.rb

@@ -32,29 +32,48 @@ module SemanticLogger
       end
     end
 
-    SELF_PATTERN = File.join("lib", "semantic_logger")
-
-    # Extract the backtrace leaving out the last few Semantic Logger lines.
+    # Extract the backtrace stripping off the leading semantic logger entries.
+    # Leaves all other system and gem path entries in place.
     def self.extract_backtrace(stack = caller)
-      while (first = stack.first) && first.include?(SELF_PATTERN)
+      while (first = stack.first) && extract_path?(first)
         stack.shift
       end
       stack
     end
 
-    # Strips off all gems and built-in ruby code paths from the top of the stack until application code is found.
+    def self.extract_paths
+      @extract_paths ||= %w[lib/semantic_logger lib/rails_semantic_logger]
+    end
+
+    # Whether this path should be excluded from any cleansed backtrace
+    def self.extract_path?(path)
+      extract_paths.any? { |exclude| path.include?(exclude) }
+    end
+
+    # Try to strip everything off of the supplied backtrace, until the first application stack entry is at the top.
+    # For example all leading gem paths and built-in ruby code paths are removed from the top.
+    # Once the first application entry is found, the remaining stack is returned.
     def self.strip_backtrace(stack = caller)
-      while (first = stack.first) && system_path?(first)
+      while (first = stack.first) && (strip_path?(first) || extract_path?(first))
         stack.shift
       end
       stack
     end
 
-    GEM_ROOT = File.expand_path("../../..", __dir__) + "/"
+    # Paths to exclude in the stripped backtrace
+    # Includes Gems and built-in Ruby code paths
+    def self.strip_paths
+      @strip_paths ||=
+        begin
+          paths = Gem.path | [Gem.default_dir]
+          paths << RbConfig::CONFIG["rubylibdir"]
+          paths
+        end
+    end
 
-    def self.system_path?(path)
-      path.start_with?(GEM_ROOT) ||
-        path.start_with?(RbConfig::CONFIG["rubylibdir"])
+    # Whether this path should be excluded from any cleansed backtrace
+    def self.strip_path?(path)
+      strip_paths.any? { |exclude| path.start_with?(exclude) }
     end
   end
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = "4.7.1".freeze
+  VERSION = "4.8.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 4.8.1
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-14 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,9 +24,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: 
+description:
 email:
-- reidmo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -68,6 +67,7 @@ files:
 - lib/semantic_logger/formatters/default.rb
 - lib/semantic_logger/formatters/fluentd.rb
 - lib/semantic_logger/formatters/json.rb
+- lib/semantic_logger/formatters/logfmt.rb
 - lib/semantic_logger/formatters/one_line.rb
 - lib/semantic_logger/formatters/raw.rb
 - lib/semantic_logger/formatters/signalfx.rb
@@ -89,11 +89,11 @@ files:
 - lib/semantic_logger/sync_processor.rb
 - lib/semantic_logger/utils.rb
 - lib/semantic_logger/version.rb
-homepage: https://github.com/rocketjob/semantic_logger
+homepage: https://logger.rocketjob.io
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -101,15 +101,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails
   loggers.