semantic_logger 4.6.1 → 4.7.4

data/lib/semantic_logger/appender/tcp.rb

@@ -1,10 +1,10 @@
 begin
-  require 'net/tcp_client'
+  require "net/tcp_client"
 rescue LoadError
-  raise LoadError.new('Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.')
+  raise LoadError, 'Gem net_tcp_client is required for logging over TCP. Please add the gem "net_tcp_client" to your Gemfile.'
 end
 
-raise 'Net::TCPClient v2.0 or greater is required to log over TCP' unless Net::TCPClient::VERSION.to_f >= 2.0
+raise "Net::TCPClient v2.0 or greater is required to log over TCP" unless Net::TCPClient::VERSION.to_f >= 2.0
 
 module SemanticLogger
   module Appender
@@ -189,7 +189,7 @@ module SemanticLogger
 
         # Use the internal logger so that errors with remote logging are only written locally.
         Net::TCPClient.logger      = logger
-        Net::TCPClient.logger.name = 'Net::TCPClient'
+        Net::TCPClient.logger.name = "Net::TCPClient"
 
         super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, &block)
         reopen
@@ -198,7 +198,7 @@ module SemanticLogger
       # After forking an active process call #reopen to re-open the handles to resources.
       def reopen
         close
-        @tcp_client = Net::TCPClient.new(@tcp_client_args)
+        @tcp_client = Net::TCPClient.new(**@tcp_client_args)
       end
 
       # Write the log using the specified protocol and server.

data/lib/semantic_logger/appender/udp.rb

@@ -1,4 +1,4 @@
-require 'socket'
+require "socket"
 module SemanticLogger
   module Appender
     # UDP log appender.
@@ -74,7 +74,7 @@ module SemanticLogger
       def reopen
         close
         @socket    = UDPSocket.new
-        host, port = server.split(':')
+        host, port = server.split(":")
         @socket.connect(host, port.to_i)
       end
 

data/lib/semantic_logger/appenders.rb

@@ -18,8 +18,8 @@ module SemanticLogger
       each do |appender|
         begin
           appender.log(log) if appender.should_log?(log)
-        rescue Exception => exc
-          logger.error "Failed to log to appender: #{appender.name}", exc
+        rescue Exception => e
+          logger.error "Failed to log to appender: #{appender.name}", e
         end
       end
     end
@@ -29,11 +29,11 @@ module SemanticLogger
         begin
           logger.trace "Flushing appender: #{appender.name}"
           appender.flush
-        rescue Exception => exc
-          logger.error "Failed to flush appender: #{appender.name}", exc
+        rescue Exception => e
+          logger.error "Failed to flush appender: #{appender.name}", e
         end
       end
-      logger.trace 'All appenders flushed'
+      logger.trace "All appenders flushed"
     end
 
     def close
@@ -43,11 +43,11 @@ module SemanticLogger
           appender.flush
           appender.close
           delete(appender)
-        rescue Exception => exc
-          logger.error "Failed to close appender: #{appender.name}", exc
+        rescue Exception => e
+          logger.error "Failed to close appender: #{appender.name}", e
         end
       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.
@@ -58,11 +58,11 @@ module SemanticLogger
 
           logger.trace "Reopening appender: #{appender.name}"
           appender.reopen
-        rescue Exception => exc
-          logger.error "Failed to re-open appender: #{appender.name}", exc
+        rescue Exception => e
+          logger.error "Failed to re-open appender: #{appender.name}", e
         end
       end
-      logger.trace 'All appenders re-opened'
+      logger.trace "All appenders re-opened"
     end
   end
 end

data/lib/semantic_logger/base.rb

@@ -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)
@@ -190,7 +190,8 @@ module SemanticLogger
       # Allow named tags to be passed into the logger
       if tags.size == 1
         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
 
@@ -240,7 +241,7 @@ module SemanticLogger
 
     # 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.
@@ -262,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
@@ -302,23 +311,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
-        elsif exception.nil? && message && payload && payload.is_a?(Hash) &&
-          (payload.key?(:payload) || payload.key?(:exception) || payload.key?(:metric))
-          log.assign(message: message, **payload)
+          # Everything as keyword arguments.
+          log.assign(**log.extract_arguments(message))
+        elsif exception.nil? && message && payload && payload.is_a?(Hash)
+          # Message with keyword arguments as the rest.
+          log.assign(message: message, **log.extract_arguments(payload))
         else
-          log.assign_positional(message, payload, exception, &block)
+          # No keyword arguments.
+          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
@@ -344,8 +372,8 @@ 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)
@@ -355,7 +383,7 @@ module SemanticLogger
           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
@@ -377,6 +405,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
@@ -395,8 +424,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.rb

@@ -1,15 +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'
+    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
 
     # Return formatter that responds to call.
@@ -22,10 +22,10 @@ module SemanticLogger
     # - Any object that responds to :call
     def self.factory(formatter)
       if formatter.is_a?(Symbol)
-        SemanticLogger::Utils.constantize_symbol(formatter, 'SemanticLogger::Formatters').new
+        SemanticLogger::Utils.constantize_symbol(formatter, "SemanticLogger::Formatters").new
       elsif formatter.is_a?(Hash) && formatter.size.positive?
         fmt, options = formatter.first
-        SemanticLogger::Utils.constantize_symbol(fmt.to_sym, 'SemanticLogger::Formatters').new(options)
+        SemanticLogger::Utils.constantize_symbol(fmt.to_sym, "SemanticLogger::Formatters").new(**options)
       elsif formatter.respond_to?(:call)
         formatter
       else

data/lib/semantic_logger/formatters/base.rb

@@ -1,8 +1,8 @@
-require 'time'
+require "time"
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :time_format, :log_host, :log_application, :log_environment, :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
@@ -61,6 +61,11 @@ module SemanticLogger
         format_time(log.time) if time_format
       end
 
+      # Process ID
+      def pid
+        $$
+      end
+
       private
 
       # Return the Time as a formatted string
@@ -77,7 +82,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,9 +65,9 @@ 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.
@@ -105,7 +109,7 @@ module SemanticLogger
       def payload
         return unless log.payload?
 
-        if !defined?(AwesomePrint) || !log.payload.respond_to?(:ai)
+        if !log.payload.respond_to?(:ai)
           super
         else
           begin

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

data/lib/semantic_logger/formatters/fluentd.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 
 module SemanticLogger
   module Formatters
@@ -13,8 +13,8 @@ module SemanticLogger
       end
 
       def level
-        hash['severity']       = log.level
-        hash['severity_index'] = log.level_index
+        hash["severity"]       = log.level
+        hash["severity_index"] = log.level_index
       end
 
       def process_info

data/lib/semantic_logger/formatters/json.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 module SemanticLogger
   module Formatters
     class Json < Raw

data/lib/semantic_logger/formatters/raw.rb

@@ -1,9 +1,9 @@
-require 'json'
+require "json"
 module SemanticLogger
   module Formatters
     class Raw < Base
       # Fields are added by populating this hash.
-      attr_accessor :hash, :log, :logger, :time_key
+      attr_accessor :hash, :time_key
 
       # By default Raw formatter does not reformat the time
       def initialize(time_format: :none, time_key: :time, **args)
@@ -37,11 +37,18 @@ module SemanticLogger
         hash[:level_index] = log.level_index
       end
 
-      # Process info
-      def process_info
-        hash[:pid]    = $$
+      # Process ID
+      def pid
+        hash[:pid] = super
+      end
+
+      # Name of the thread that logged the message.
+      def thread_name
         hash[:thread] = 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
         return unless file
 
@@ -85,6 +92,7 @@ module SemanticLogger
       # Exception
       def exception
         return unless log.exception
+
         root = hash
         log.each_exception do |exception, i|
           name       = i.zero? ? :exception : :cause
@@ -93,7 +101,7 @@ module SemanticLogger
             message:     exception.message,
             stack_trace: exception.backtrace
           }
-          root       = root[name]
+          root = root[name]
         end
       end
 
@@ -109,7 +117,23 @@ module SemanticLogger
         self.log    = log
         self.logger = logger
 
-        host; application; environment; time; level; process_info; duration; tags; named_tags; name; message; payload; exception; metric
+        host
+        application
+        environment
+        time
+        level
+        pid
+        thread_name
+        file_name_and_line
+        duration
+        tags
+        named_tags
+        name
+        message
+        payload
+        exception
+        metric
+
         hash
       end
     end