semantic_logger 4.5.0 → 4.12.0

data/lib/semantic_logger/log.rb

@@ -47,6 +47,12 @@ module SemanticLogger
   # context [Hash]
   #   Named contexts that were captured when the log entry was created.
   class Log
+    # Keys passed in without a payload that will be extracted and the remainder passed into the payload.
+    NON_PAYLOAD_KEYS = %i[message exception backtrace exception
+                          duration min_duration
+                          log_exception on_exception_level
+                          metric metric_amount dimensions].freeze
+
     attr_accessor :level, :level_index, :name, :message, :time, :duration,
                   :payload, :exception, :thread_name, :backtrace,
                   :tags, :named_tags, :context,
@@ -79,20 +85,13 @@ module SemanticLogger
                log_exception: :full,
                on_exception_level: nil,
                dimensions: nil)
-      # Elastic logging: Log when :duration exceeds :min_duration
-      # Except if there is an exception when it will always be logged
-      if duration
-        self.duration = duration
-        return false if (duration < min_duration) && exception.nil?
-      end
 
-      self.message = message
-      if payload && payload.is_a?(Hash)
-        self.payload = payload
-      elsif payload
-        self.message = message.nil? ? payload.to_s : "#{message} -- #{payload}"
-        self.payload = nil
-      end
+      self.message       = message
+      self.payload       = payload
+      self.duration      = duration
+      self.metric        = metric
+      self.metric_amount = metric_amount
+      self.dimensions    = dimensions
 
       if exception
         case log_exception
@@ -113,57 +112,54 @@ module SemanticLogger
         end
       end
 
+      # Elastic logging: Log when :duration exceeds :min_duration
+      # Except if there is an exception when it will always be logged
+      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
-      end
-
-      if metric
-        self.metric        = metric
-        self.metric_amount = metric_amount
-        self.dimensions    = dimensions
+        self.backtrace = Utils.extract_backtrace(caller)
       end
 
       true
     end
 
-    # Assign positional arguments to this log entry, supplying defaults where applicable
-    #
-    # Returns [true|false] whether this log entry should be logged
-    #
-    # Example:
-    #   logger.info('value', :debug, 0, "hello world")
-    def assign_positional(message = nil, payload = nil, exception = nil)
-      # Exception being logged?
-      # Under JRuby a java exception is not a Ruby Exception
-      #   Java::JavaLang::ClassCastException.new.is_a?(Exception) => false
-      if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
-        exception = message
-        message   = nil
-      elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
-        exception = payload
-        payload   = nil
-      elsif payload && !payload.is_a?(Hash)
-        message = message.nil? ? payload : "#{message} -- #{payload}"
-        payload = nil
+    # Assign known keys to self, all other keys to the payload.
+    def assign_hash(hash)
+      self.payload ||= {}
+      hash.each_pair do |key, value|
+        if respond_to?("#{key}=".to_sym)
+          public_send("#{key}=".to_sym, value)
+        else
+          payload[key] = value
+        end
       end
+      self.payload = nil if payload.empty?
+      self
+    end
 
-      # Add result of block as message or payload if not nil
-      if block_given? && (result = yield)
-        if result.is_a?(String)
-          message = message.nil? ? result : "#{message} -- #{result}"
-          assign(message: message, payload: payload, exception: exception)
-        elsif message.nil? && result.is_a?(Hash) && %i[message payload exception].any? { |k| result.key? k }
-          assign(result)
-        elsif payload&.respond_to?(:merge)
-          assign(message: message, payload: payload.merge(result), exception: exception)
-        else
-          assign(message: message, payload: result, exception: exception)
+    # Extract the arguments from a Hash Payload
+    def extract_arguments(payload, message = nil)
+      raise(ArgumentError, "payload must be a Hash") unless payload.is_a?(Hash)
+
+      message = nil if message == ""
+      return payload if payload.key?(:payload)
+
+      new_payload = {}
+      args        = {}
+      payload.each_pair do |key, value|
+        # Supplied message takes precedence
+        if (key == :message) && !message.nil?
+          new_payload[key] = value
+          next
         end
-      else
-        assign(message: message, payload: payload, exception: exception)
+
+        NON_PAYLOAD_KEYS.include?(key) ? args[key] = value : new_payload[key] = value
       end
+      args[:payload] = new_payload unless new_payload.empty?
+      args[:message] = message if message
+      args
     end
 
     MAX_EXCEPTIONS_TO_UNWRAP = 5
@@ -191,7 +187,7 @@ module SemanticLogger
 
     # Returns [String] the exception backtrace including all of the child / caused by exceptions
     def backtrace_to_s
-      trace = ''
+      trace = ""
       each_exception do |exception, i|
         if i.zero?
           trace = (exception.backtrace || []).join("\n")
@@ -212,6 +208,7 @@ module SemanticLogger
     else
       def duration_to_s
         return unless duration
+
         duration < 10.0 ? "#{format('%.3f', duration)}ms" : "#{format('%.1f', duration)}ms"
       end
     end
@@ -219,13 +216,14 @@ module SemanticLogger
     # Returns [String] the duration in human readable form
     def duration_human
       return nil unless duration
+
       seconds = duration / 1000
       if seconds >= 86_400.0 # 1 day
         "#{(seconds / 86_400).to_i}d #{Time.at(seconds).strftime('%-Hh %-Mm')}"
       elsif seconds >= 3600.0 # 1 hour
-        Time.at(seconds).strftime('%-Hh %-Mm')
+        Time.at(seconds).strftime("%-Hh %-Mm")
       elsif seconds >= 60.0 # 1 minute
-        Time.at(seconds).strftime('%-Mm %-Ss')
+        Time.at(seconds).strftime("%-Mm %-Ss")
       elsif seconds >= 1.0 # 1 second
         "#{format('%.3f', seconds)}s"
       else
@@ -238,9 +236,7 @@ module SemanticLogger
       level.to_s[0..0].upcase
     end
 
-    # Returns [String] the available process info
-    # Example:
-    #    18934:thread 23 test_logging.rb:51
+    # DEPRECATED
     def process_info(thread_name_length = 30)
       file, line = file_name_and_line(true)
       file_name  = " #{file}:#{line}" if file
@@ -248,7 +244,7 @@ module SemanticLogger
       "#{$$}:#{format("%.#{thread_name_length}s", thread_name)}#{file_name}"
     end
 
-    CALLER_REGEXP = /^(.*):(\d+).*/
+    CALLER_REGEXP = /^(.*):(\d+).*/.freeze
 
     # Extract the filename and line number from the last entry in the supplied backtrace
     def extract_file_and_line(stack, short_name = false)
@@ -265,7 +261,7 @@ module SemanticLogger
 
     # Strip the standard Rails colorizing from the logged message
     def cleansed_message
-      message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, '').strip
+      message.to_s.gsub(/(\e(\[([\d;]*[mz]?))?)?/, "").strip
     end
 
     # Return the payload in text form
@@ -279,19 +275,8 @@ module SemanticLogger
       !(payload.nil? || (payload.respond_to?(:empty?) && payload.empty?))
     end
 
-    # DEPRECATED
-    alias has_payload? payload?
-
-    # DEPRECATED
-    def formatted_time
-      time.strftime(Formatters::Base.build_time_format)
-    end
-
-    DeprecatedLogger = Struct.new(:host, :application)
-
-    # DEPRECATED: Use SemanticLogger::Formatters::Raw
-    def to_h(host = SemanticLogger.host, application = SemanticLogger.application)
-      logger = DeprecatedLogger.new(host, application)
+    def to_h(host = SemanticLogger.host, application = SemanticLogger.application, environment = SemanticLogger.environment)
+      logger = Struct.new(:host, :application, :environment).new(host, application, environment)
       SemanticLogger::Formatters::Raw.new.call(self, logger)
     end
 

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

@@ -1,4 +1,4 @@
-require 'concurrent'
+require "concurrent"
 module SemanticLogger
   # Logger stores the class name to be used for all log messages so that every
   # log message written by this instance will include the class name
@@ -9,7 +9,7 @@ module SemanticLogger
       subscriber = block || object
 
       unless subscriber.is_a?(Proc) || subscriber.respond_to?(:call)
-        raise('When supplying an on_log subscriber, it must support the #call method')
+        raise("When supplying an on_log subscriber, it must support the #call method")
       end
 
       subscribers = (@subscribers ||= Concurrent::Array.new)
@@ -21,7 +21,19 @@ module SemanticLogger
     end
 
     def self.processor
-      @processor
+      @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
@@ -63,20 +75,16 @@ module SemanticLogger
       Logger.processor.log(log)
     end
 
-    private
-
-    @processor   = Processor.new
+    @processor   = nil
     @subscribers = nil
 
     def self.call_subscribers(log)
       return unless @subscribers
 
       @subscribers.each do |subscriber|
-        begin
-          subscriber.call(log)
-        rescue Exception => exc
-          self.class.processor.logger.error('Exception calling :on_log subscriber', exc)
-        end
+        subscriber.call(log)
+      rescue Exception => e
+        processor.logger.error("Exception calling :on_log subscriber", e)
       end
     end
   end

data/lib/semantic_logger/metric/new_relic.rb

@@ -1,7 +1,7 @@
 begin
-  require 'newrelic_rpm'
+  require "newrelic_rpm"
 rescue LoadError
-  raise 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
+  raise LoadError, 'Gem newrelic_rpm is required for logging to New Relic. Please add the gem "newrelic_rpm" to your Gemfile.'
 end
 
 # Send Metrics to NewRelic
@@ -37,7 +37,7 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(prefix: 'Custom', **args, &block)
+      def initialize(prefix: "Custom", **args, &block)
         @prefix = prefix
         super(**args, &block)
       end

data/lib/semantic_logger/metric/signalfx.rb

@@ -10,7 +10,7 @@ module SemanticLogger
     class Signalfx < SemanticLogger::Appender::Http
       attr_reader :full_url
 
-      END_POINT = 'v2/datapoint'.freeze
+      END_POINT = "v2/datapoint".freeze
 
       # Create SignalFx metrics appender.
       #
@@ -75,7 +75,7 @@ module SemanticLogger
       #   end
       def initialize(token:,
                      dimensions: nil,
-                     url: 'https://ingest.signalfx.com',
+                     url: "https://ingest.signalfx.com",
                      formatter: nil,
                      **args,
                      &block)
@@ -84,7 +84,7 @@ module SemanticLogger
 
         super(url: url, formatter: formatter, **args, &block)
 
-        @header['X-SF-TOKEN'] = token
+        @header["X-SF-TOKEN"] = token
         @full_url             = "#{url}/#{END_POINT}"
       end
 

data/lib/semantic_logger/metric/statsd.rb

@@ -1,8 +1,8 @@
-require 'uri'
+require "uri"
 begin
-  require 'statsd-ruby'
+  require "statsd-ruby"
 rescue LoadError
-  raise 'Gem statsd-ruby is required for logging metrics. Please add the gem "statsd-ruby" to your Gemfile.'
+  raise LoadError, 'Gem statsd-ruby is required for logging metrics. Please add the gem "statsd-ruby" to your Gemfile.'
 end
 
 module SemanticLogger
@@ -26,17 +26,17 @@ module SemanticLogger
       #     metric: :statsd,
       #     url:    'localhost:8125'
       #   )
-      def initialize(url: 'udp://localhost:8125')
+      def initialize(url: "udp://localhost:8125")
         @url = url
       end
 
       def reopen
         uri = URI.parse(@url)
-        raise('Statsd only supports udp. Example: "udp://localhost:8125"') if uri.scheme != 'udp'
+        raise('Statsd only supports udp. Example: "udp://localhost:8125"') if uri.scheme != "udp"
 
         @statsd           = ::Statsd.new(uri.host, uri.port)
-        path              = uri.path.chomp('/')
-        @statsd.namespace = path.sub('/', '') if path != ''
+        path              = uri.path.chomp("/")
+        @statsd.namespace = path.sub("/", "") if path != ""
       end
 
       def log(log)

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,13 +11,14 @@ 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.name = name
-        l
-      end
+      @logger ||=
+        begin
+          l      = SemanticLogger::Appender::IO.new($stderr, level: :warn)
+          l.name = name
+          l
+        end
     end
 
     attr_reader :appenders
@@ -30,6 +31,7 @@ module SemanticLogger
     # Start the appender thread
     def start
       return false if active?
+
       thread
       true
     end

data/lib/semantic_logger/reporters/minitest.rb

@@ -23,7 +23,7 @@ module SemanticLogger
     class Minitest < ::Minitest::AbstractReporter
       include SemanticLogger::Loggable
 
-      logger.name = 'Minitest'
+      logger.name = "Minitest"
 
       attr_accessor :io
 
@@ -33,11 +33,11 @@ module SemanticLogger
 
       def after_test(test)
         if test.error?
-          logger.benchmark_error("FAIL #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: 'minitest/fail')
+          logger.benchmark_error("FAIL #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: "minitest/fail")
         elsif test.skipped?
-          logger.benchmark_warn("SKIP #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: 'minitest/skip')
+          logger.benchmark_warn("SKIP #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: "minitest/skip")
         else
-          logger.benchmark_info("PASS #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: 'minitest/pass')
+          logger.benchmark_info("PASS #{test.class_name} #{test.name}", duration: test.time * 1_000, metric: "minitest/pass")
         end
       end
     end

data/lib/semantic_logger/semantic_logger.rb

@@ -1,5 +1,5 @@
-require 'concurrent'
-require 'socket'
+require "concurrent"
+require "socket"
 
 module SemanticLogger
   # Logging levels in order of most detailed to most severe
@@ -52,7 +52,7 @@ module SemanticLogger
   # Returns [String] name of this host for logging purposes
   # Note: Not all appenders use `host`
   def self.host
-    @host ||= Socket.gethostname.force_encoding('UTF-8')
+    @host ||= Socket.gethostname.force_encoding("UTF-8")
   end
 
   # Override the default host name
@@ -71,7 +71,19 @@ module SemanticLogger
     @application = application
   end
 
-  @application = 'Semantic Logger'
+  # Returns [String] name of this environment for logging purposes
+  # Note: Not all appenders use `environment`
+  def self.environment
+    @environment
+  end
+
+  # Override the default environment
+  def self.environment=(environment)
+    @environment = environment
+  end
+
+  @application = ENV["SEMANTIC_LOGGER_APP"] || "Semantic Logger"
+  @environment = ENV["SEMANTIC_LOGGER_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"]
 
   # Add a new logging appender as a new destination for all log messages
   # emitted from Semantic Logger
@@ -89,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]
@@ -110,7 +122,7 @@ module SemanticLogger
   #     Default: SemanticLogger.default_level
   #
   #   formatter: [Symbol|Object|Proc]
-  #     Any of the following symbol values: :default, :color, :json
+  #     Any of the following symbol values: :default, :color, :json, :logfmt, etc...
   #       Or,
   #     An instance of a class that implements #call
   #       Or,
@@ -126,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.:
   #
@@ -142,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
@@ -151,8 +163,8 @@ module SemanticLogger
   #   logger = SemanticLogger['Example']
   #   logger.info "Hello World"
   #   logger.debug("Login time", user: 'Joe', duration: 100, ip_address: '127.0.0.1')
-  def self.add_appender(options, deprecated_level = nil, &block)
-    appender = Logger.processor.appenders.add(options, deprecated_level, &block)
+  def self.add_appender(**args, &block)
+    appender = appenders.add(**args, &block)
     # Start appender thread if it is not already running
     Logger.processor.start
     appender
@@ -161,7 +173,15 @@ module SemanticLogger
   # Remove an existing appender
   # Currently only supports appender instances
   def self.remove_appender(appender)
-    Logger.processor.appenders.delete(appender)
+    return unless appender
+
+    appenders.delete(appender)
+    appender.close
+  end
+
+  # Clear out all previously registered appenders
+  def self.clear_appenders!
+    Logger.processor.close
   end
 
   # Returns [SemanticLogger::Subscriber] a copy of the list of active
@@ -169,7 +189,7 @@ module SemanticLogger
   # Use SemanticLogger.add_appender and SemanticLogger.remove_appender
   # to manipulate the active appenders list
   def self.appenders
-    Logger.processor.appenders.to_a
+    Logger.processor.appenders
   end
 
   # Flush all queued log entries disk, database, etc.
@@ -233,9 +253,9 @@ module SemanticLogger
   #   When the log_level_signal is raised on this process, the global default log level
   #   rotates through the following log levels in the following order, starting
   #   from the current global default level:
-  #     :warn, :info, :debug, :trace
+  #     :fatal, :error, :warn, :info, :debug, :trace
   #
-  #   If the current level is :trace it wraps around back to :warn
+  #   If the current level is :trace it wraps around back to :fatal
   #
   # 2. Logging a Ruby thread dump
   #
@@ -256,22 +276,24 @@ module SemanticLogger
   # Note:
   #   To only register one of the signal handlers, set the other to nil
   #   Set gc_log_microseconds to nil to not enable JRuby Garbage collections
-  def self.add_signal_handler(log_level_signal = 'USR2', thread_dump_signal = 'TTIN', gc_log_microseconds = 100_000)
+  def self.add_signal_handler(log_level_signal = "USR2", thread_dump_signal = "TTIN", gc_log_microseconds = 100_000)
     if log_level_signal
       Signal.trap(log_level_signal) do
-        index     = default_level == :trace ? LEVELS.find_index(:error) : LEVELS.find_index(default_level)
-        new_level = LEVELS[index - 1]
-        self['SemanticLogger'].warn "Changed global default log level to #{new_level.inspect}"
+        current_level_index = LEVELS.find_index(default_level)
+        new_level_index = current_level_index == 0 ? LEVELS.size - 1 : current_level_index - 1
+        new_level = LEVELS[new_level_index]
         self.default_level = new_level
+        self["SemanticLogger"].warn "Changed global default log level to #{new_level.inspect}"
       end
     end
 
     if thread_dump_signal
       Signal.trap(thread_dump_signal) do
-        logger = SemanticLogger['Thread Dump']
+        logger = SemanticLogger["Thread Dump"]
         Thread.list.each do |thread|
           # MRI re-uses the main thread for signals, JRuby uses `SIGTTIN handler` thread.
           next if defined?(JRuby) && (thread == Thread.current)
+
           logger.backtrace(thread: thread)
         end
       end
@@ -290,7 +312,7 @@ module SemanticLogger
   # If the tag being supplied is definitely a string then this fast
   # tag api can be used for short lived tags
   def self.fast_tag(tag)
-    return yield if tag.nil? || tag == ''
+    return yield if tag.nil? || tag == ""
 
     t = Thread.current[:semantic_logger_tags] ||= []
     begin
@@ -367,7 +389,7 @@ module SemanticLogger
   # :nodoc
   def self.named_tagged(hash)
     return yield if hash.nil? || hash.empty?
-    raise(ArgumentError, '#named_tagged only accepts named parameters (Hash)') unless hash.is_a?(Hash)
+    raise(ArgumentError, "#named_tagged only accepts named parameters (Hash)") unless hash.is_a?(Hash)
 
     begin
       push_named_tags(hash)
@@ -476,11 +498,23 @@ module SemanticLogger
     Thread.current[:semantic_logger_silence] || @default_level_index
   end
 
-  private
+  # Run Semantic Logger in Synchronous mode.
+  #
+  # I.e. Instead of logging messages in a separate thread for better performance,
+  # log them using the current thread.
+  def self.sync!
+    Logger.sync!
+  end
+
+  # Running in synchronous mode?
+  def self.sync?
+    Logger.sync?
+  end
 
   # Initial default Level for all new instances of SemanticLogger::Logger
   @default_level         = :info
   @default_level_index   = Levels.index(@default_level)
   @backtrace_level       = :error
   @backtrace_level_index = Levels.index(@backtrace_level)
+  @sync                  = false
 end