semantic_logger 4.7.3 → 4.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b10135713f7777b24e23191888a3341d20e39f4576c3f93fb92e008212c71f1
-  data.tar.gz: 13d48205904e7bc452621c8f65da454dc7f77c21592318324bbffef2a1bf5bae
+  metadata.gz: d0bd2e2a218bdbf0bfa67ca85da999b352de9b214383890278c0710cd3f84e91
+  data.tar.gz: dd3b393e8f0a031ddb25c2ca3cdeaa7d761617586f366006e79d7fcf3de8a9a5
 SHA512:
-  metadata.gz: 1c721150d177559864111177271517e51f1c52dae5ee8783839ef32ac09f24cfedcd2757f0406fabc10d181d5214521bdfd625b1def340236f74ed51ecf6ecaf
-  data.tar.gz: adbea6f546bd0dfaa9ba59d45950fdb775f0ea308599a4a50d2aad4353ac7809f8930c4013fdc1d4f9d0ece963728347ba06b726c6e6078ceb68302dde1b721d
+  metadata.gz: dba969cf8d70cbb63a6542a692b68773f395eda22515267c572630aa5180a3bbfe490f2096e83cc366f06e86bbf06bafc87d2e5800810110107ac5080b7a1046
+  data.tar.gz: 35d69548ee2a91fb4d7c0575ea2d1da48648a7352d52304e8f270a6fe095c42e7ad1367594cef0b14941e14fc47906816df2360899c37fc577828b368c71c21a

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/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')
@@ -62,9 +62,14 @@ module SemanticLogger
       def initialize(io: nil, file_name: nil, **args, &block)
         if io
           @log = io
+          unless @log.respond_to?(:write)
+            raise(ArgumentError, "SemanticLogging::Appender::File :io is not a valid IO instance: #{io.inspect}")
+          end
         else
           @file_name = file_name
-          raise "SemanticLogging::Appender::File missing mandatory parameter :file_name or :io" unless file_name
+          unless file_name
+            raise(ArgumentError, "SemanticLogging::Appender::File missing mandatory parameter :file_name or :io")
+          end
 
           reopen
         end
@@ -105,6 +110,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,9 +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)
+        h = SemanticLogger::Formatters::Raw.new(time_format: :seconds).call(log, logger)
         h.delete(:host)
-        message               = {
+        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/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,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/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::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.3".freeze
+  VERSION = "4.8.2".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.7.3
+  version: 4.8.2
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-22 00:00:00.000000000 Z
+date: 2021-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -26,7 +26,6 @@ dependencies:
         version: '1.0'
 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,7 +89,7 @@ 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: {}
@@ -101,14 +101,14 @@ 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.0.8
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails