semantic_logger 4.5.0 → 4.7.1

data/lib/semantic_logger/formatters/json.rb

@@ -1,12 +1,10 @@
-require 'json'
+require "json"
 module SemanticLogger
   module Formatters
     class Json < Raw
       # Default JSON time format is ISO8601
-      def initialize(time_format: :iso_8601, log_host: true, log_application: true, time_key: :timestamp,
-                     precision: PRECISION)
-        super(time_format: time_format, log_host: log_host, log_application: log_application, time_key: time_key,
-              precision: precision)
+      def initialize(time_format: :iso_8601, time_key: :timestamp, **args)
+        super(time_format: time_format, time_key: time_key, **args)
       end
 
       # Returns log messages in JSON format

data/lib/semantic_logger/formatters/raw.rb

@@ -1,14 +1,14 @@
-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, log_host: true, log_application: true, time_key: :time, precision: PRECISION)
+      def initialize(time_format: :none, time_key: :time, **args)
         @time_key = time_key
-        super(time_format: time_format, log_host: log_host, log_application: log_application, precision: precision)
+        super(time_format: time_format, **args)
       end
 
       # Host name
@@ -18,7 +18,12 @@ module SemanticLogger
 
       # Application name
       def application
-        hash[:application] = logger.application if log_application && logger.application
+        hash[:application] = logger.application if log_application && logger && logger.application
+      end
+
+      # Environment
+      def environment
+        hash[:environment] = logger.environment if log_environment && logger && logger.environment
       end
 
       # Date & time
@@ -32,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
 
@@ -80,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
@@ -88,7 +101,7 @@ module SemanticLogger
             message:     exception.message,
             stack_trace: exception.backtrace
           }
-          root       = root[name]
+          root = root[name]
         end
       end
 
@@ -104,7 +117,23 @@ module SemanticLogger
         self.log    = log
         self.logger = logger
 
-        host; application; 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

data/lib/semantic_logger/formatters/signalfx.rb

@@ -1,49 +1,41 @@
-require 'json'
+require "json"
 module SemanticLogger
   module Formatters
     class Signalfx < Base
-      attr_accessor :token, :dimensions, :hash, :log, :logger, :gauge_name, :counter_name, :environment
+      attr_accessor :token, :dimensions, :hash, :gauge_name, :counter_name
 
       def initialize(token:,
                      dimensions: nil,
-                     log_host: true,
-                     log_application: true,
-                     gauge_name: 'Application.average',
-                     counter_name: 'Application.counter',
-                     environment: true,
-                     precision: PRECISION)
+                     gauge_name: "Application.average",
+                     counter_name: "Application.counter",
+                     time_format: :ms,
+                     **args)
 
         @token        = token
         @dimensions   = dimensions.map(&:to_sym) if dimensions
         @gauge_name   = gauge_name
         @counter_name = counter_name
 
-        if environment == true
-          @environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-        elsif environment
-          @environment = environment
-        end
-
-        super(time_format: :ms, log_host: log_host, log_application: log_application, precision: precision)
+        super(time_format: time_format, **args)
       end
 
       # Create SignalFx friendly metric.
       #   Strip leading '/'
       #   Convert remaining '/' to '.'
       def metric
-        name = log.metric.to_s.sub(/\A\/+/, '')
+        name = log.metric.to_s.sub(%r{\A/+}, "")
         if log.dimensions
-          name.tr!('/', '.')
+          name.tr!("/", ".")
           hash[:metric] = name
         else
           # Extract class and action from metric name
-          names = name.split('/')
+          names = name.split("/")
           h     = (hash[:dimensions] ||= {})
           if names.size > 1
             h[:action] = names.pop
-            h[:class]  = names.join('::')
+            h[:class]  = names.join("::")
           else
-            h[:class]  = 'Unknown'
+            h[:class]  = "Unknown"
             h[:action] = names.first || log.metric
           end
 
@@ -75,12 +67,13 @@ module SemanticLogger
             name  = name.to_sym
             value = value.to_s
             next if value.empty?
+
             h[name] = value if dimensions&.include?(name)
           end
         end
         h[:host]        = logger.host if log_host && logger.host
         h[:application] = logger.application if log_application && logger.application
-        h[:environment] = environment if environment
+        h[:environment] = logger.environment if log_environment && logger.environment
       end
 
       # Returns [Hash] log message in Signalfx format.

data/lib/semantic_logger/formatters/syslog.rb

@@ -1,7 +1,7 @@
 begin
-  require 'syslog_protocol'
+  require "syslog_protocol"
 rescue LoadError
-  raise '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
@@ -73,7 +73,7 @@ module SemanticLogger
         packet          = SyslogProtocol::Packet.new
         packet.hostname = logger.host
         packet.facility = facility
-        packet.tag      = logger.application.delete(' ')
+        packet.tag      = logger.application.delete(" ")
         packet.content  = message
         packet.time     = log.time
         packet.severity = level_map[log.level]

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -1,7 +1,7 @@
 begin
-  require 'syslog_protocol'
+  require "syslog_protocol"
 rescue LoadError
-  raise '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
@@ -45,7 +45,7 @@ module SemanticLogger
         packet          = SyslogProtocol::Packet.new
         packet.hostname = logger.host
         packet.facility = facility
-        packet.tag      = logger.application.delete(' ')
+        packet.tag      = logger.application.delete(" ")
         packet.content  = message
         packet.time     = log.time
         packet.severity = level_map[log.level]

data/lib/semantic_logger/jruby/garbage_collection_logger.rb

@@ -12,7 +12,9 @@ module SemanticLogger
       # Must leave the method name as-is so that it can be found by Java
       def handleNotification(notification, _)
         # Only care about GARBAGE_COLLECTION_NOTIFICATION notifications
-        return unless notification.get_type == Java::ComSunManagement::GarbageCollectionNotificationInfo::GARBAGE_COLLECTION_NOTIFICATION
+        unless notification.get_type == Java::ComSunManagement::GarbageCollectionNotificationInfo::GARBAGE_COLLECTION_NOTIFICATION
+          return
+        end
 
         info     = Java::ComSunManagement::GarbageCollectionNotificationInfo.from(notification.user_data)
         gc_info  = info.gc_info
@@ -20,7 +22,7 @@ module SemanticLogger
 
         return unless duration >= @min_microseconds
 
-        SemanticLogger['GarbageCollector'].measure_warn(
+        SemanticLogger["GarbageCollector"].measure_warn(
           "Garbage Collection completed: #{info.gc_name} ##{gc_info.id}",
           duration: duration.to_f / 1000
         )

data/lib/semantic_logger/levels.rb

@@ -16,17 +16,19 @@ module SemanticLogger
           LEVELS.index(level)
         elsif level.is_a?(Integer) && defined?(::Logger::Severity)
           # Mapping of Rails and Ruby Logger levels to SemanticLogger levels
-          @map_levels ||= begin
-            levels = []
-            ::Logger::Severity.constants.each do |constant|
-              levels[::Logger::Severity.const_get(constant)] =
-                LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
+          @map_levels ||=
+            begin
+              levels = []
+              ::Logger::Severity.constants.each do |constant|
+                levels[::Logger::Severity.const_get(constant)] =
+                  LEVELS.find_index(constant.downcase.to_sym) || LEVELS.find_index(:error)
+              end
+              levels
             end
-            levels
-          end
           @map_levels[level]
         end
       raise "Invalid level:#{level.inspect} being requested. Must be one of #{LEVELS.inspect}" unless index
+
       index
     end
 

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,45 @@ module SemanticLogger
         end
       end
 
+      # 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
+
       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
-      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
-      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)
+    # 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
-          assign(message: message, payload: result, exception: exception)
+          payload[key] = value
         end
-      else
-        assign(message: message, payload: payload, exception: exception)
       end
+      self.payload = nil if payload.empty?
+      self
+    end
+
+    # Extract the arguments from a Hash Payload
+    def extract_arguments(payload)
+      raise(ArgumentError, "payload must be a Hash") unless payload.is_a?(Hash)
+
+      return payload if payload.key?(:payload)
+
+      args = {}
+      payload.each_key { |key| args[key] = payload.delete(key) if NON_PAYLOAD_KEYS.include?(key) }
+      args[:payload] = payload unless payload.empty?
+      args
     end
 
     MAX_EXCEPTIONS_TO_UNWRAP = 5
@@ -191,7 +178,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 +199,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 +207,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 +227,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 +235,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 +252,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 +266,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