semantic_logger 4.16.1 → 4.17.0

data/lib/semantic_logger/base.rb

@@ -130,7 +130,6 @@ module SemanticLogger
                   payload: nil,
                   metric: nil,
                   metric_amount: nil)
-
       log = Log.new(name, level)
       return false unless meets_log_level?(log)
 
@@ -357,7 +356,6 @@ module SemanticLogger
     # Measure the supplied block and log the message
     def measure_internal(level, index, message, params)
       exception = nil
-      result    = nil
       # Single parameter is a hash
       if params.empty? && message.is_a?(Hash)
         params  = message
@@ -366,14 +364,13 @@ module SemanticLogger
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       begin
         if block_given?
-          result =
-            if (silence_level = params[:silence])
-              # In case someone accidentally sets `silence: true` instead of `silence: :error`
-              silence_level = :error if silence_level == true
-              silence(silence_level) { yield(params) }
-            else
-              yield(params)
-            end
+          if (silence_level = params[:silence])
+            # In case someone accidentally sets `silence: true` instead of `silence: :error`
+            silence_level = :error if silence_level == true
+            silence(silence_level) { yield(params) }
+          else
+            yield(params)
+          end
         end
       rescue Exception => e
         exception = e
@@ -408,8 +405,6 @@ 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
 
@@ -421,7 +416,6 @@ module SemanticLogger
                        metric:,
                        log_exception:,
                        on_exception_level:)
-
       # Ignores filter, silence, payload
       exception = nil
       start     = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/semantic_logger/formatters/base.rb

@@ -23,6 +23,7 @@ module SemanticLogger
       #     See Time#strftime for the format of this string.
       #     :iso_8601 Outputs an ISO8601 Formatted timestamp.
       #     :ms       Output in miliseconds since epoch.
+      #     :notime   Returns an empty string for time ( no time is output ).
       #     Default: '%Y-%m-%d %H:%M:%S.%<precision>N'
       #   log_host: [Boolean]
       #     Whether or not to include hostname in logs
@@ -81,7 +82,7 @@ module SemanticLogger
           time
         when :seconds
           time.to_f
-        when nil
+        when :notime
           ""
         else
           time.strftime(time_format)

data/lib/semantic_logger/formatters/color.rb

@@ -128,7 +128,7 @@ module SemanticLogger
 
       def call(log, logger)
         self.color = color_map[log.level]
-        super(log, logger)
+        super
       end
     end
   end

data/lib/semantic_logger/formatters/fluentd.rb

@@ -19,7 +19,7 @@ module SemanticLogger
 
       def process_info
         # Ignore fields: pid, thread, file and line by default
-        super() if need_process_info
+        super if need_process_info
       end
     end
   end

data/lib/semantic_logger/formatters/json.rb

@@ -4,12 +4,12 @@ module SemanticLogger
     class Json < Raw
       # Default JSON time format is ISO8601
       def initialize(time_format: :iso_8601, time_key: :timestamp, **args)
-        super(time_format: time_format, time_key: time_key, **args)
+        super
       end
 
       # Returns log messages in JSON format
       def call(log, logger)
-        super(log, logger).to_json
+        super.to_json
       end
     end
   end

data/lib/semantic_logger/formatters/logfmt.rb

@@ -19,11 +19,11 @@ module SemanticLogger
     # 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)
+        super
       end
 
       def call(log, logger)
-        @raw = super(log, logger)
+        @raw = super
 
         raw_to_logfmt
       end
@@ -40,11 +40,11 @@ module SemanticLogger
       end
 
       def handle_tags
-        tags = @raw.fetch(:tags){ [] }
-                    .each_with_object({}){ |tag, accum| accum[tag] = true }
+        tags = @raw.fetch(:tags) { [] }.
+               each_with_object({}) { |tag, accum| accum[tag] = true }
 
-        @parsed = @parsed.merge(tags)
-                         .merge(@raw.fetch(:named_tags){ {} })
+        @parsed = @parsed.merge(tags).
+                  merge(@raw.fetch(:named_tags) { {} })
       end
 
       def handle_payload

data/lib/semantic_logger/formatters/loki.rb

@@ -0,0 +1,157 @@
+require "json"
+
+module SemanticLogger
+  module Formatters
+    class Loki < Base
+      attr_accessor :stream, :payload_value
+
+      # Returns [String] a single JSON log
+      def call(log, logger)
+        self.logger = logger
+        self.log = log
+
+        {streams: [build_stream]}.to_json
+      end
+
+      # Returns [String] a JSON batch of logs
+      def batch(logs, logger)
+        self.logger = logger
+
+        streams = logs.map do |log|
+          self.log = log
+          build_stream
+        end
+
+        {streams: streams}.to_json
+      end
+
+      private
+
+      def build_stream
+        self.stream = {stream: {pid: pid}, values: [[]]}
+
+        application
+        environment
+        host
+        level
+        thread
+        tags
+        named_tags
+        context
+        time
+        message
+        payload
+        metric
+        duration
+        exception
+
+        stream[:values][0] << payload_value
+        stream
+      end
+
+      def host
+        stream[:stream][:host] = logger.host if log_host && logger.host.to_s
+      end
+
+      def application
+        stream[:stream][:application] = logger.application if log_application && logger&.application
+      end
+
+      def environment
+        stream[:stream][:environment] = logger.environment if log_environment && logger&.environment
+      end
+
+      def level
+        stream[:stream][:level] = log.level
+      end
+
+      def thread
+        stream[:stream][:thread] = log.thread_name if log.thread_name
+      end
+
+      def tags
+        stream[:stream][:tags] = log.tags if log.tags.respond_to?(:empty?) && !log.tags.empty?
+      end
+
+      def named_tags
+        stream[:stream].merge!(log.named_tags) if log.named_tags.respond_to?(:empty?) && !log.named_tags.empty?
+      end
+
+      def context
+        return unless log.context && !log.context.empty?
+
+        log.context.each do |key, value|
+          serialized_value = if value.is_a?(Hash)
+                               value.to_json
+                             else
+                               value.to_s
+                             end
+
+          stream[:stream].merge!(key.to_s => serialized_value)
+        end
+      end
+
+      def time
+        stream[:values][0] << format_time(log)
+      end
+
+      def message
+        stream[:values][0] << (log.message ? log.cleansed_message : "")
+      end
+
+      def format_time(log)
+        log.time.strftime("%s%N")
+      end
+
+      def payload
+        self.payload_value = if log.payload.respond_to?(:empty?) && !log.payload.empty?
+                               # Loki only accepts strings as key and values
+                               stringify_hash(log.payload)
+                             else
+                               {}
+                             end
+      end
+
+      def metric
+        return unless log.metric
+
+        payload_value[:metric] = log.metric
+        payload_value[:metric_value] = log.metric_amount
+      end
+
+      def duration
+        return unless log.duration
+
+        payload_value[:duration] = log.duration.to_s
+        payload_value[:duration_human] = log.duration_human
+      end
+
+      def exception
+        return unless log.exception
+
+        payload_value.merge!(
+          exception_name:    log.exception.class.name,
+          exception_message: log.exception.message,
+          stack_trace:       log.exception.backtrace.to_s
+        )
+      end
+
+      def stringify_hash(hash)
+        result = {}
+
+        hash.each do |key, value|
+          string_key = key.to_s
+
+          result[string_key] = case value
+                               when Hash
+                                 JSON.generate(stringify_hash(value))
+                               else
+                                 value.to_s
+                               end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/new_relic_logs.rb

@@ -3,38 +3,28 @@ require "json"
 begin
   require "newrelic_rpm"
 rescue LoadError
-  raise LoadError, '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
 
-raise "NewRelic::Agent.linking_metadata is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent.respond_to?(:linking_metadata)
+unless NewRelic::Agent.respond_to?(:linking_metadata)
+  raise "NewRelic::Agent.linking_metadata is not defined. Please update newrelic_rpm gem version"
+end
 
-raise "NewRelic::Agent::Tracer.current_span_id is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent::Tracer.respond_to?(:current_span_id)
+unless NewRelic::Agent::Tracer.respond_to?(:current_span_id)
+  raise "NewRelic::Agent::Tracer.current_span_id is not defined. Please update newrelic_rpm gem version"
+end
 
-raise "NewRelic::Agent::Tracer.current_trace_id is not defined. Please update newrelic_rpm gem version" unless NewRelic::Agent::Tracer.respond_to?(:current_trace_id)
+unless NewRelic::Agent::Tracer.respond_to?(:current_trace_id)
+  raise "NewRelic::Agent::Tracer.current_trace_id is not defined. Please update newrelic_rpm gem version"
+end
 
 module SemanticLogger
   module Formatters
     # Formatter for reporting to NewRelic's Logger
     #
-    # New Relic's logs do not support custom attributes out of the box, and therefore these
-    # have to be put into a single JSON serialized string under the +message+ key.
-    #
-    # In particular the following fields of the log object are serialized under the +message+
-    # key that's sent to NewRelic:
-    #
-    # * message
-    # * tags
-    # * named_tags
-    # * payload
-    # * metric
-    # * metric_amount
-    # * environment
-    # * application
-    #
-    # == New Relic Attributes not Supported
-    # * thread.id
-    # * class.name
-    # * method.name
+    # New Relic gracefully handles (and flattens) any JSON-based logs
+    # We construct the JSON and pass it to New Relic for further processing.
     #
     # == Reference
     # * Logging specification
@@ -54,41 +44,70 @@ module SemanticLogger
       end
 
       def call(log, logger)
-        hash = super(log, logger)
-
-        message = {
-          message:    hash[:message].to_s,
-          tags:       hash[:tags] || [],
-          named_tags: hash[:named_tags] || {},
-
-          **hash.slice(:metric, :metric_amount, :environment, :application, :payload)
-        }
-
-        message.merge!(duration: hash[:duration_ms]) if hash.key?(:duration_ms)
-        message.merge!(duration_human: hash[:duration]) if hash.key?(:duration)
+        hash = super
 
         result = {
-          **new_relic_metadata,
-          message:       message.to_json,
+          **newrelic_metadata,
+          message:       hash[:message].to_s,
+          tags:          hash[:tags],
+          metric:        hash[:metric],
+          metric_amount: hash[:metric_amount],
+          environment:   hash[:environment],
+          application:   hash[:application],
+          payload:       hash[:payload],
           timestamp:     hash[:timestamp].to_i,
-          "log.level":   log.level.to_s.upcase,
-          "logger.name": log.name,
-          "thread.name": log.thread_name.to_s
-        }
+          logger:        {
+            name: log.name
+          },
+          thread:        {
+            name: log.thread_name.to_s
+          }
+        }.compact
+
+        if hash[:duration_ms] || hash[:duration]
+          result[:duration] = {
+            ms:    hash[:duration_ms],
+            human: hash[:duration]
+          }.compact
+        end
 
         if hash[:exception]
-          result.merge!(
-            "error.message": hash[:exception][:message],
-            "error.class":   hash[:exception][:name],
-            "error.stack":   hash[:exception][:stack_trace].join("\n")
-          )
+          result[:error] = {
+            message: hash[:exception][:message],
+            class:   hash[:exception][:name],
+            stack:   hash[:exception][:stack_trace].join("\n")
+          }
         end
 
         if hash[:file]
-          result.merge!(
-            "file.name":   hash[:file],
-            "line.number": hash[:line].to_s
-          )
+          result[:file] = {
+            name: hash[:file]
+          }
+        end
+
+        if hash[:line]
+          result[:line] = {
+            number: hash[:line].to_s
+          }
+        end
+
+        # NOTE: Any named tags are merged directly into the result
+        # unless there are conflicts with other keys. In that
+        # case we clearly log this in the NR log entry so it can
+        # be easily alerted on.
+        if hash[:named_tags].is_a?(Hash)
+          result_keys = result.keys.to_set
+          named_tag_conflicts = []
+
+          hash[:named_tags].each do |key, value|
+            if result_keys.include?(key)
+              named_tag_conflicts << key
+            else
+              result[key] = value
+            end
+          end
+
+          result[:named_tag_conflicts] = named_tag_conflicts unless named_tag_conflicts.empty?
         end
 
         result
@@ -96,13 +115,11 @@ module SemanticLogger
 
       private
 
-      def new_relic_metadata
-        {
-          "trace.id": NewRelic::Agent::Tracer.current_trace_id,
-          "span.id":  NewRelic::Agent::Tracer.current_span_id,
-          **NewRelic::Agent.linking_metadata
-        }.reject { |_k, v| v.nil? }.
-          map { |k, v| [k.to_sym, v] }.to_h
+      # NOTE: This function will already include trace.id and span.id if they
+      # are available so I believe the previous implementation of this is redundant
+      # https://rubydoc.info/gems/newrelic_rpm/NewRelic/Agent#linking_metadata-instance_method
+      def newrelic_metadata
+        NewRelic::Agent.linking_metadata.transform_keys(&:to_sym)
       end
     end
   end

data/lib/semantic_logger/formatters/open_telemetry.rb

@@ -0,0 +1,40 @@
+require "json"
+module SemanticLogger
+  module Formatters
+    class OpenTelemetry < Raw
+      # Log level
+      def level
+        hash[:level]       = log.level.to_s
+        hash[:level_index] = severity_number(log.level_index)
+      end
+
+      # Payload is submitted directly as attributes
+      def payload
+        return unless log.payload.respond_to?(:empty?) && !log.payload.empty?
+
+        hash[:payload] = log.payload.transform_keys!(&:to_s)
+      end
+
+      private
+
+      def severity_number(severity)
+        case severity
+        when :trace
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_TRACE
+        when :debug
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_DEBUG
+        when :info
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_INFO
+        when :warn
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_WARN
+        when :error
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_ERROR
+        when :fatal
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_FATAL
+        else
+          ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_UNSPECIFIED
+        end
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/signalfx.rb

@@ -10,7 +10,6 @@ module SemanticLogger
                      counter_name: "Application.counter",
                      time_format: :ms,
                      **args)
-
         @token        = token
         @dimensions   = dimensions.map(&:to_sym) if dimensions
         @gauge_name   = gauge_name

data/lib/semantic_logger/formatters/syslog.rb

@@ -25,7 +25,8 @@ module SemanticLogger
       class LevelMap
         attr_accessor :trace, :debug, :info, :warn, :error, :fatal
 
-        def initialize(trace: ::Syslog::LOG_DEBUG, debug: ::Syslog::LOG_INFO, info: ::Syslog::LOG_NOTICE, warn: ::Syslog::LOG_WARNING, error: ::Syslog::LOG_ERR, fatal: ::Syslog::LOG_CRIT)
+        def initialize(trace: ::Syslog::LOG_DEBUG, debug: ::Syslog::LOG_INFO, info: ::Syslog::LOG_NOTICE,
+                       warn: ::Syslog::LOG_WARNING, error: ::Syslog::LOG_ERR, fatal: ::Syslog::LOG_CRIT)
           @trace = trace
           @debug = debug
           @info  = info
@@ -64,7 +65,7 @@ module SemanticLogger
       end
 
       def call(log, logger)
-        message = super(log, logger)
+        message = super
         create_syslog_packet(message)
       end
 

data/lib/semantic_logger/formatters/syslog_cee.rb

@@ -24,7 +24,8 @@ 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, max_size: Integer)
+      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
@@ -36,7 +37,7 @@ module SemanticLogger
       end
 
       def call(log, logger)
-        hash = super(log, logger)
+        hash = super
         create_syslog_packet("@cee: #{hash.to_json}")
       end
 

data/lib/semantic_logger/formatters.rb

@@ -1,17 +1,19 @@
 module SemanticLogger
   module Formatters
-    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"
-    autoload :NewRelicLogs, "semantic_logger/formatters/new_relic_logs"
+    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 :OpenTelemetry, "semantic_logger/formatters/open_telemetry"
+    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"
+    autoload :NewRelicLogs,  "semantic_logger/formatters/new_relic_logs"
+    autoload :Loki,          "semantic_logger/formatters/loki"
 
     # Return formatter that responds to call.
     #

data/lib/semantic_logger/log.rb

@@ -85,7 +85,6 @@ module SemanticLogger
                log_exception: :full,
                on_exception_level: nil,
                dimensions: nil)
-
       self.message       = message
       self.payload       = payload
       self.duration      = duration
@@ -114,7 +113,7 @@ module SemanticLogger
 
       # 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?)
+      return false if duration && (duration < min_duration) && exception.nil?
 
       if backtrace
         self.backtrace = Utils.extract_backtrace(backtrace)
@@ -129,8 +128,8 @@ module SemanticLogger
     def assign_hash(hash)
       self.payload ||= {}
       hash.each_pair do |key, value|
-        if respond_to?("#{key}=".to_sym)
-          public_send("#{key}=".to_sym, value)
+        if respond_to?(:"#{key}=")
+          public_send(:"#{key}=", value)
         else
           payload[key] = value
         end
@@ -281,7 +280,8 @@ module SemanticLogger
       !(payload.nil? || (payload.respond_to?(:empty?) && payload.empty?))
     end
 
-    def to_h(host = SemanticLogger.host, application = SemanticLogger.application, environment = SemanticLogger.environment)
+    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

@@ -83,7 +83,6 @@ module SemanticLogger
                                 on_exception_level: nil,
                                 message: "##{method_name}",
                                 level: :info)
-
         # unless visibility = Utils.method_visibility(self, method_name)
         #   logger.warn("Unable to measure method: #{name}##{method_name} since it does not exist")
         #   return false
@@ -124,6 +123,7 @@ module SemanticLogger
         else
           mod = const_set(:SemanticLoggerMeasure, Module.new)
           prepend mod
+
           mod
         end
       end

data/lib/semantic_logger/logger.rb

@@ -57,7 +57,7 @@ module SemanticLogger
     #    Proc: Only include log messages where the supplied Proc returns true
     #          The Proc must return true or false
     def initialize(klass, level = nil, filter = nil)
-      super(klass, level, filter)
+      super
     end
 
     # Place log request on the queue for the Appender thread to write to each

data/lib/semantic_logger/metric/new_relic.rb

@@ -1,7 +1,8 @@
 begin
   require "newrelic_rpm"
 rescue LoadError
-  raise LoadError, '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

data/lib/semantic_logger/metric/signalfx.rb

@@ -79,7 +79,6 @@ module SemanticLogger
                      formatter: nil,
                      **args,
                      &block)
-
         formatter ||= SemanticLogger::Formatters::Signalfx.new(token: token, dimensions: dimensions)
 
         super(url: url, formatter: formatter, **args, &block)