semantic_logger 4.5.0 → 4.12.0

data/lib/semantic_logger/appender.rb

@@ -1,93 +1,90 @@
 module SemanticLogger
   module Appender
     # @formatter:off
-    autoload :Async,             'semantic_logger/appender/async'
-    autoload :AsyncBatch,        'semantic_logger/appender/async_batch'
-    autoload :Bugsnag,           'semantic_logger/appender/bugsnag'
-    autoload :Elasticsearch,     'semantic_logger/appender/elasticsearch'
-    autoload :ElasticsearchHttp, 'semantic_logger/appender/elasticsearch_http'
-    autoload :File,              'semantic_logger/appender/file'
-    autoload :Graylog,           'semantic_logger/appender/graylog'
-    autoload :Honeybadger,       'semantic_logger/appender/honeybadger'
-    autoload :Kafka,             'semantic_logger/appender/kafka'
-    autoload :Sentry,            'semantic_logger/appender/sentry'
-    autoload :Http,              'semantic_logger/appender/http'
-    autoload :MongoDB,           'semantic_logger/appender/mongodb'
-    autoload :NewRelic,          'semantic_logger/appender/new_relic'
-    autoload :Rabbitmq,          'semantic_logger/appender/rabbitmq'
-    autoload :Splunk,            'semantic_logger/appender/splunk'
-    autoload :SplunkHttp,        'semantic_logger/appender/splunk_http'
-    autoload :Syslog,            'semantic_logger/appender/syslog'
-    autoload :Tcp,               'semantic_logger/appender/tcp'
-    autoload :Udp,               'semantic_logger/appender/udp'
-    autoload :Wrapper,           'semantic_logger/appender/wrapper'
+    autoload :Async,             "semantic_logger/appender/async"
+    autoload :AsyncBatch,        "semantic_logger/appender/async_batch"
+    autoload :Bugsnag,           "semantic_logger/appender/bugsnag"
+    autoload :Elasticsearch,     "semantic_logger/appender/elasticsearch"
+    autoload :ElasticsearchHttp, "semantic_logger/appender/elasticsearch_http"
+    autoload :File,              "semantic_logger/appender/file"
+    autoload :Graylog,           "semantic_logger/appender/graylog"
+    autoload :Honeybadger,       "semantic_logger/appender/honeybadger"
+    autoload :IO,                "semantic_logger/appender/io"
+    autoload :Kafka,             "semantic_logger/appender/kafka"
+    autoload :Sentry,            "semantic_logger/appender/sentry"
+    autoload :Http,              "semantic_logger/appender/http"
+    autoload :MongoDB,           "semantic_logger/appender/mongodb"
+    autoload :NewRelic,          "semantic_logger/appender/new_relic"
+    autoload :Rabbitmq,          "semantic_logger/appender/rabbitmq"
+    autoload :Splunk,            "semantic_logger/appender/splunk"
+    autoload :SplunkHttp,        "semantic_logger/appender/splunk_http"
+    autoload :Syslog,            "semantic_logger/appender/syslog"
+    autoload :Tcp,               "semantic_logger/appender/tcp"
+    autoload :Udp,               "semantic_logger/appender/udp"
+    autoload :Wrapper,           "semantic_logger/appender/wrapper"
+    autoload :SentryRuby,        "semantic_logger/appender/sentry_ruby"
     # @formatter:on
 
-    # DEPRECATED, use SemanticLogger::AnsiColors
-    AnsiColors = SemanticLogger::AnsiColors
-
-    # DEPRECATED: use SemanticLogger::Formatters::Color.new
-    def self.colorized_formatter
-      SemanticLogger::Formatters::Color.new
-    end
-
-    # DEPRECATED: use SemanticLogger::Formatters::Json.new
-    def self.json_formatter
-      SemanticLogger::Formatters::Json.new
-    end
-
     # Returns [SemanticLogger::Subscriber] appender for the supplied options
-    def self.factory(options, &block)
-      options = options.dup
-      async   = options.delete(:async)
-      batch   = options.delete(:batch)
-
-      # Extract batch and async options
-      proxy_options = {}
-      ASYNC_OPTION_KEYS.each { |key| proxy_options[key] = options.delete(key) if options.key?(key) }
-
-      appender = build(options, &block)
+    def self.factory(async: false, batch: nil,
+                     max_queue_size: 10_000, lag_check_interval: 1_000, lag_threshold_s: 30,
+                     batch_size: 300, batch_seconds: 5,
+                     **args,
+                     &block)
+      appender = build(**args, &block)
 
       # If appender implements #batch, then it should use the batch proxy by default.
       batch    = true if batch.nil? && appender.respond_to?(:batch)
 
       if batch == true
-        proxy_options[:appender] = appender
-        Appender::AsyncBatch.new(proxy_options)
+        Appender::AsyncBatch.new(
+          appender:        appender,
+          max_queue_size:  max_queue_size,
+          lag_threshold_s: lag_threshold_s,
+          batch_size:      batch_size,
+          batch_seconds:   batch_seconds
+        )
       elsif async == true
-        proxy_options[:appender] = appender
-        Appender::Async.new(proxy_options)
-
-
+        Appender::Async.new(
+          appender:           appender,
+          max_queue_size:     max_queue_size,
+          lag_check_interval: lag_check_interval,
+          lag_threshold_s:    lag_threshold_s
+        )
       else
         appender
       end
     end
 
-    ASYNC_OPTION_KEYS = %i[max_queue_size lag_threshold_s batch_size batch_seconds lag_check_interval].freeze
-
     # Returns [Subscriber] instance from the supplied options.
-    def self.build(options, &block)
-      if options[:io] || options[:file_name]
-        SemanticLogger::Appender::File.new(options, &block)
-      elsif (appender = options.delete(:appender))
+    def self.build(io: nil, file_name: nil, appender: nil, metric: nil, logger: nil, **args, &block)
+      if file_name
+        SemanticLogger::Appender::File.new(file_name, **args, &block)
+      elsif io
+        SemanticLogger::Appender::IO.new(io, **args, &block)
+      elsif logger
+        SemanticLogger::Appender::Wrapper.new(logger: logger, **args, &block)
+      elsif appender
         if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender).new(options)
+          SemanticLogger::Utils.constantize_symbol(appender).new(**args)
         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 (appender = options.delete(:metric))
-        if appender.is_a?(Symbol)
-          SemanticLogger::Utils.constantize_symbol(appender, 'SemanticLogger::Metric').new(options)
-        elsif appender.is_a?(Subscriber)
-          appender
+      elsif metric
+        if metric.is_a?(Symbol)
+          SemanticLogger::Utils.constantize_symbol(metric, "SemanticLogger::Metric").new(**args)
+        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
-      elsif options[:logger]
-        SemanticLogger::Appender::Wrapper.new(options, &block)
+      else
+        raise(ArgumentError,
+              "To create an appender it must supply one of the following: :io, :file_name, :appender, :metric, or :logger")
       end
     end
 

data/lib/semantic_logger/appenders.rb

@@ -8,82 +8,65 @@ module SemanticLogger
       @logger.name = self.class.name
     end
 
-    def add(options, deprecated_level = nil, &block)
-      options  = options.is_a?(Hash) ? options.dup : convert_old_appender_args(options, deprecated_level)
-      appender = SemanticLogger::Appender.factory(options, &block)
+    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 => exc
-          logger.error "Failed to log to appender: #{appender.inspect}", exc
-        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 => exc
-          logger.error "Failed to flush appender: #{appender.inspect}", exc
-        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'
+      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 => exc
-          logger.error "Failed to close appender: #{appender.inspect}", exc
-        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'
+      logger.trace "All appenders closed and removed from appender list"
     end
 
     # 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)
-
-          logger.trace "Reopening appender: #{appender.name}"
-          appender.reopen
-        rescue Exception => exc
-          logger.error "Failed to re-open appender: #{appender.inspect}", exc
-        end
-      end
-      logger.trace 'All appenders re-opened'
-    end
-
-    private
-
-    # Backward compatibility
-    def convert_old_appender_args(appender, level)
-      options         = {}
-      options[:level] = level if level
+        next unless appender.respond_to?(:reopen)
 
-      if appender.is_a?(String)
-        options[:file_name] = appender
-      elsif appender.is_a?(IO)
-        options[:io] = appender
-      elsif appender.is_a?(Symbol) || appender.is_a?(Subscriber)
-        options[:appender] = appender
-      else
-        options[:logger] = appender
+        logger.trace "Reopening appender: #{appender.name}"
+        appender.reopen
+      rescue Exception => e
+        logger.error "Failed to re-open appender: #{appender.name}", e
       end
-      warn "[DEPRECATED] SemanticLogger.add_appender parameters have changed. Please use: #{options.inspect}"
-      options
+      logger.trace "All appenders re-opened"
     end
   end
 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)
@@ -126,7 +126,7 @@ module SemanticLogger
     # Log a thread backtrace
     def backtrace(thread: Thread.current,
                   level: :warn,
-                  message: 'Backtrace:',
+                  message: "Backtrace:",
                   payload: nil,
                   metric: nil,
                   metric_amount: nil)
@@ -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
@@ -186,11 +186,14 @@ module SemanticLogger
     #   to:
     #     `logger.tagged('first', 'more', 'other')`
     # - For better performance with clean tags, see `SemanticLogger.tagged`.
-    def tagged(*tags, &block)
+    def tagged(*tags)
+      block = -> { yield(self) }
       # Allow named tags to be passed into the logger
-      if tags.size == 1
+      # Rails::Rack::Logger passes logs as an array with a single argument
+      if tags.size == 1 && !tags.first.is_a?(Array)
         tag = tags[0]
-        return yield if tag.nil? || tag == ''
+        return yield if tag.nil? || tag == ""
+
         return tag.is_a?(Hash) ? SemanticLogger.named_tagged(tag, &block) : SemanticLogger.fast_tag(tag.to_s, &block)
       end
 
@@ -233,26 +236,14 @@ module SemanticLogger
       SemanticLogger.silence(new_level, &block)
     end
 
-    # Deprecated. Use `SemanticLogger.tagged`
+    # :nodoc:
     def fast_tag(tag, &block)
       SemanticLogger.fast_tag(tag, &block)
     end
 
-    # :nodoc:
-    def with_payload(payload, &block)
-      warn '#with_payload is deprecated, use SemanticLogger.named_tagged'
-      SemanticLogger.named_tagged(payload, &block)
-    end
-
-    # :nodoc:
-    def payload
-      warn '#payload is deprecated, use SemanticLogger.named_tags'
-      SemanticLogger.named_tags
-    end
-
     # Write log data to underlying data storage
     def log(_log_)
-      raise NotImplementedError, 'Logging Appender must implement #log(log)'
+      raise NotImplementedError, "Logging Appender must implement #log(log)"
     end
 
     # Whether this log entry meets the criteria to be logged by this appender.
@@ -274,14 +265,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
@@ -314,20 +313,42 @@ module SemanticLogger
     end
 
     # Log message at the specified level
-    def log_internal(level, index, message = nil, payload = nil, exception = nil, &block)
-      log        = Log.new(name, level, index)
+    def log_internal(level, index, message = nil, payload = nil, exception = nil)
+      # Handle variable number of arguments by detecting exception object and payload hash.
+      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
+      end
+
+      log = Log.new(name, level, index)
       should_log =
-        if payload.nil? && exception.nil? && message.is_a?(Hash)
-          # Check if someone just logged a hash payload instead of meaning to call semantic logger
-          if message.key?(:message) || message.key?(:payload) || message.key?(:exception) || message.key?(:metric)
-            log.assign(message)
-          else
-            log.assign_positional(nil, message, nil, &block)
-          end
+        if exception.nil? && payload.nil? && message.is_a?(Hash)
+          # All arguments as a hash in the message.
+          log.assign(**log.extract_arguments(message))
+        elsif exception.nil? && message && payload && payload.is_a?(Hash)
+          # Message supplied along with a hash with the remaining arguments.
+          log.assign(**log.extract_arguments(payload, message))
         else
-          log.assign_positional(message, payload, exception, &block)
+          # All fields supplied directly.
+          log.assign(message: message, payload: payload, exception: exception)
         end
 
+      # Add result of block to message or payload if not nil
+      if block_given?
+        result = yield(log)
+        if result.is_a?(String)
+          log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
+        elsif result.is_a?(Hash)
+          log.assign_hash(result)
+        end
+      end
+
       # Log level may change during assign due to :on_exception_level
       self.log(log) if should_log && should_log?(log)
     end
@@ -353,18 +374,18 @@ module SemanticLogger
               yield(params)
             end
         end
-      rescue Exception => exc
-        exception = exc
+      rescue Exception => e
+        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  =
           if block_given?
             1_000.0 * (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start)
           else
-            params[:duration] || raise('Mandatory block missing when :duration option is not supplied')
+            params[:duration] || raise("Mandatory block missing when :duration option is not supplied")
           end
 
         # Extract options after block completes so that block can modify any of the options
@@ -386,6 +407,7 @@ module SemanticLogger
         # Log level may change during assign due to :on_exception_level
         self.log(log) if should_log && should_log?(log)
         raise exception if exception
+
         result
       end
     end
@@ -404,8 +426,8 @@ module SemanticLogger
       start     = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       begin
         yield
-      rescue Exception => exc
-        exception = exc
+      rescue Exception => e
+        exception = e
       ensure
         log = Log.new(name, level, index)
         # May return false due to elastic logging

data/lib/semantic_logger/formatters/base.rb

@@ -1,12 +1,12 @@
-require 'time'
+require "time"
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :time_format, :log_host, :log_application, :precision
+      attr_accessor :log, :logger, :time_format, :log_host, :log_application, :log_environment, :precision
 
       # Time precision varies by Ruby interpreter
       # JRuby 9.1.8.0 supports microseconds
-      PRECISION   =
+      PRECISION =
         if defined?(JRuby)
           if JRUBY_VERSION.to_f >= 9.1
             maint = JRUBY_VERSION.match(/\A\d+\.\d+\.(\d+)\./)[1].to_i
@@ -34,11 +34,15 @@ module SemanticLogger
       #   precision: [Integer]
       #     How many fractional digits to log times with.
       #     Default: PRECISION (6, except on older JRuby, where 3)
-      def initialize(time_format: nil, log_host: true, log_application: true,
+      def initialize(time_format: nil,
+                     log_host: true,
+                     log_application: true,
+                     log_environment: true,
                      precision: PRECISION)
         @time_format     = time_format || self.class.build_time_format(precision)
         @log_host        = log_host
         @log_application = log_application
+        @log_environment = log_environment
         @precision       = precision
       end
 
@@ -48,7 +52,7 @@ module SemanticLogger
       #   precision: [Integer]
       #     How many fractional digits to log times with.
       #     Default: PRECISION (6, except on older JRuby, where 3)
-      def self.build_time_format(precision=PRECISION)
+      def self.build_time_format(precision = PRECISION)
         "%Y-%m-%d %H:%M:%S.%#{precision}N"
       end
 
@@ -57,10 +61,16 @@ module SemanticLogger
         format_time(log.time) if time_format
       end
 
+      # Process ID
+      def pid
+        $$
+      end
+
       private
 
       # Return the Time as a formatted string
       def format_time(time)
+        time = time.dup
         case time_format
         when :rfc_3339
           time.utc.to_datetime.rfc3339
@@ -73,7 +83,7 @@ module SemanticLogger
         when :seconds
           time.to_f
         when nil
-          ''
+          ""
         else
           time.strftime(time_format)
         end

data/lib/semantic_logger/formatters/color.rb

@@ -1,8 +1,12 @@
-# Load AwesomePrint if available
+# Load Amazing Print, or Awesome Print if available
 begin
-  require 'awesome_print'
+  require "amazing_print"
 rescue LoadError
-  nil
+  begin
+    require "awesome_print"
+  rescue LoadError
+    nil
+  end
 end
 
 module SemanticLogger
@@ -61,24 +65,19 @@ module SemanticLogger
       #
       # Parameters:
       #  ap: [Hash]
-      #    Any valid AwesomePrint option for rendering data.
+      #    Any valid Amazing Print option for rendering data.
       #    These options can also be changed be creating a `~/.aprc` file.
-      #    See: https://github.com/michaeldv/awesome_print
+      #    See: https://github.com/amazing-print/amazing_print
       #
       #    Note: The option :multiline is set to false if not supplied.
       #    Note: Has no effect if Awesome Print is not installed.
       #
       #  color_map: [Hash | SemanticLogger::Formatters::Color::ColorMap]
       #    ColorMaps each of the log levels to a color
-      def initialize(ap: {multiline: false},
-                     color_map: ColorMap.new,
-                     time_format: nil,
-                     log_host: false,
-                     log_application: false,
-                     precision: PRECISION)
+      def initialize(ap: {multiline: false}, color_map: ColorMap.new, **args)
         @ai_options = ap
         @color_map  = color_map.is_a?(ColorMap) ? color_map : ColorMap.new(color_map)
-        super(time_format: time_format, log_host: log_host, log_application: log_application, precision: precision)
+        super(**args)
       end
 
       def level
@@ -110,14 +109,14 @@ module SemanticLogger
       def payload
         return unless log.payload?
 
-        if !defined?(AwesomePrint) || !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/default.rb

@@ -2,8 +2,6 @@ module SemanticLogger
   module Formatters
     # Default non-colored text log output
     class Default < Base
-      attr_accessor :log, :logger
-
       # Formatting methods, must return nil, or a string
       # Nil values are ignored
 
@@ -12,9 +10,24 @@ module SemanticLogger
         log.level_to_s
       end
 
-      # Process info
+      # Name of the thread that logged the message.
+      def thread_name
+        format("%.30s", log.thread_name)
+      end
+
+      # Ruby file name and line number that logged the message.
+      def file_name_and_line
+        file, line = log.file_name_and_line(true)
+        "#{file}:#{line}" if file
+      end
+
+      # Returns [String] the available process info
+      # Example:
+      #    [18934:thread_name test_logging.rb:51]
       def process_info
-        "[#{log.process_info}]"
+        process_id = "#{pid}:" if pid
+        fname      = file_name_and_line
+        fname ? "[#{process_id}#{thread_name} #{fname}]" : "[#{process_id}#{thread_name}]"
       end
 
       # Tags
@@ -67,7 +80,7 @@ module SemanticLogger
         self.log    = log
         self.logger = logger
 
-        [time, level, process_info, tags, named_tags, duration, name, message, payload, exception].compact.join(' ')
+        [time, level, process_info, tags, named_tags, duration, name, message, payload, exception].compact.join(" ")
       end
     end
   end