semantic_logger 4.5.0 → 4.12.0

data/lib/semantic_logger/formatters/fluentd.rb

@@ -1,37 +1,26 @@
-require 'json'
+require "json"
 
 module SemanticLogger
   module Formatters
-    # Fluentd is similar to SemanticLogger::Formatters::Json but with log level that are recongnized
+    # Fluentd is similar to SemanticLogger::Formatters::Json but with log levels that are recognized
     # by kubernetes fluentd.
     class Fluentd < Json
       attr_reader :need_process_info
 
-      def initialize(log_host: true, log_application: true, need_process_info: false)
+      def initialize(time_format: :rfc_3339, time_key: :time, need_process_info: false, **args)
         @need_process_info = need_process_info
-        super(log_host: log_host, log_application: log_application, time_key: 'time', time_format: :rfc_3339)
+        super(time_format: time_format, time_key: time_key, **args)
       end
 
-      def severity
-        hash['severity'] = log.level
-        hash['severity_index'] = log.level_index
+      def level
+        hash["severity"]       = log.level
+        hash["severity_index"] = log.level_index
       end
 
       def process_info
         # Ignore fields: pid, thread, file and line by default
         super() if need_process_info
       end
-
-      def call(log, logger)
-        self.hash   = {}
-        self.log    = log
-        self.logger = logger
-
-        host; application; time; severity; process_info; duration; tags; named_tags; name; message; payload; exception; metric
-        hash
-
-        hash.to_json
-      end
     end
   end
 end

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/logfmt.rb

@@ -0,0 +1,77 @@
+require "json"
+
+module SemanticLogger
+  module Formatters
+    # Produces logfmt formatted messages
+    #
+    # The following fields are extracted from the raw log and included in the formatted message:
+    #   :timestamp, :level, :name, :message, :duration, :tags, :named_tags
+    #
+    # E.g.
+    #   timestamp="2020-07-20T08:32:05.375276Z" level=info name="DefaultTest" base="breakfast" spaces="second breakfast" double_quotes="\"elevensies\"" single_quotes="'lunch'" tag="success"
+    #
+    # All timestamps are ISO8601 formatteed
+    # All user supplied values are escaped and surrounded by double quotes to avoid ambiguious message delimeters
+    # `tags` are treated as keys with boolean values. Tag names are not formatted or validated, ensure you use valid logfmt format for tag names.
+    # `named_tags` are flattened are merged into the top level message field. Any conflicting fields are overridden.
+    # `payload` values take precedence over `tags` and `named_tags`. Any conflicting fields are overridden.
+    #
+    # Futher Reading https://brandur.org/logfmt
+    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(time_key, :level, :name, :message, :duration).merge(tag: "success")
+        handle_tags
+        handle_payload
+        handle_exception
+
+        flatten_log
+      end
+
+      def handle_tags
+        tags = @raw.fetch(:tags){ [] }
+                    .each_with_object({}){ |tag, accum| accum[tag] = true }
+
+        @parsed = @parsed.merge(tags)
+                         .merge(@raw.fetch(:named_tags){ {} })
+      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|
+          case value
+          when Hash, Array
+            "#{key}=#{value.to_s.to_json}"
+          else
+            "#{key}=#{value.to_json}"
+          end
+        end
+
+        flattened.join(" ")
+      end
+    end
+  end
+end

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,13 +1,14 @@
 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
   module Formatters
     class Syslog < Default
-      attr_accessor :level_map, :facility
+      attr_accessor :level_map, :facility, :max_size
 
       # Default level map for every log level
       #
@@ -50,9 +51,10 @@ module SemanticLogger
       #   Example:
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
-      def initialize(facility: ::Syslog::LOG_USER, level_map: LevelMap.new)
+      def initialize(facility: ::Syslog::LOG_USER, level_map: LevelMap.new, max_size: Integer)
         @facility  = facility
         @level_map = level_map.is_a?(LevelMap) ? level_map : LevelMap.new(level_map)
+        @max_size = max_size
         super()
       end
 
@@ -73,11 +75,11 @@ 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]
-        packet.to_s
+        packet.assemble(@max_size)
       end
     end
   end

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -1,13 +1,14 @@
 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
   module Formatters
     class SyslogCee < Raw
-      attr_accessor :level_map, :facility
+      attr_accessor :level_map, :facility, :max_size
 
       # CEE JSON Syslog format
       #   Untested prototype code. Based on documentation only.
@@ -22,10 +23,11 @@ module SemanticLogger
       #
       # Example:
       #   # Log via udp to a remote syslog server on host: `server1` and port `8514`, using the CEE format.
-      #   SemanticLogger.add_appender(appender: :syslog, formatter: syslog_cee, url: 'udp://server1:8514')
-      def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new)
+      #   SemanticLogger.add_appender(appender: :syslog, formatter: :syslog_cee, url: 'udp://server1:8514')
+      def initialize(facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new, max_size: Integer)
         @facility  = facility
         @level_map = level_map.is_a?(SemanticLogger::Formatters::Syslog::LevelMap) ? level_map : SemanticLogger::Formatters::Syslog::LevelMap.new(level_map)
+        @max_size = max_size
         super()
       end
 
@@ -45,11 +47,11 @@ 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]
-        packet.to_s
+        packet.assemble(@max_size)
       end
     end
   end

data/lib/semantic_logger/formatters.rb

@@ -1,16 +1,16 @@
 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"
+    autoload :SyslogCee, "semantic_logger/formatters/syslog_cee"
 
     # 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/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