contextual_logger 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18dbe015c1afe16cedfab41724a5efd02b0f26e12de9b19d9f55a206a2e8513a
-  data.tar.gz: 672605e6ae20d620435d0d9f6d47f9a2a39c7384b0fcf352618a0c9b0d59c4e0
+  metadata.gz: 2fe842aebc69d35423b8b06cb1c3dc270fc64d5541293c946dc8eb4f6bc274ed
+  data.tar.gz: b3591004af708bd8722c313c222bf85dc4452053d2d2deb7c8abda72a500391e
 SHA512:
-  metadata.gz: 6b57e454af45bbf44d64e96fb6e34c0a8ad2e30ba590413177bcdd87206e75d7e2c65e3974133eb87142a157645cadd870369c290f4f65da1275838bcc521100
-  data.tar.gz: 36e078b7bc8fce929a524122448312e3a6856167cc5676dc4465a4c20d22fdd55eae7bf92e3531614b2a602370ff7ecdb79f9c9dd146620e5da4fed80f0cd738
+  metadata.gz: f79aa7e16d8b788b8b641fd8d62109f67c4e566ee4bb90a816fd9cf894729bc74354bcb01935ff6f15a3ed330bb0ea56629d9ad7cc24ef4d3cbe68fe8203270c
+  data.tar.gz: ec0406c0265718ee617a55f209e004805df6ce516d36a080680dda648e59ffd61ae48ebd654f1ced16db34c4bfcd83584002757b1abb8ce8fb6104582dca0307

data/lib/contextual_logger.rb

@@ -7,6 +7,16 @@ require_relative './contextual_logger/redactor'
 require_relative './contextual_logger/context/handler'
 
 module ContextualLogger
+  LOG_LEVEL_NAMES_TO_SEVERITY =
+  {
+    debug:  Logger::Severity::DEBUG,
+    info:   Logger::Severity::INFO,
+    warn:   Logger::Severity::WARN,
+    error:  Logger::Severity::ERROR,
+    fatal:  Logger::Severity::FATAL,
+    unknown: Logger::Severity::UNKNOWN
+  }.freeze
+
   class << self
     def new(logger)
       logger.extend(LoggerMixin)
@@ -17,22 +27,8 @@ module ContextualLogger
       if log_level.is_a?(Integer) && (Logger::Severity::DEBUG..Logger::Severity::UNKNOWN).include?(log_level)
         log_level
       else
-        case log_level.to_s.downcase
-        when 'debug'
-          Logger::Severity::DEBUG
-        when 'info'
-          Logger::Severity::INFO
-        when 'warn'
-          Logger::Severity::WARN
-        when 'error'
-          Logger::Severity::ERROR
-        when 'fatal'
-          Logger::Severity::FATAL
-        when 'unknown'
-          Logger::Severity::UNKNOWN
-        else
+        LOG_LEVEL_NAMES_TO_SEVERITY[log_level.to_s.downcase.to_sym] or
           raise ArgumentError, "invalid log level: #{log_level.inspect}"
-        end
       end
     end
 
@@ -72,45 +68,54 @@ module ContextualLogger
       Context::Handler.current_context
     end
 
-    def debug(message = nil, context = {})
-      add(Logger::Severity::DEBUG, message.nil? && block_given? ? yield : message, **context)
-    end
-
-    def info(message = nil, context = {})
-      add(Logger::Severity::INFO, message.nil? && block_given? ? yield : message, **context)
-    end
-
-    def warn(message = nil, context = {})
-      add(Logger::Severity::WARN, message.nil? && block_given? ? yield : message, **context)
-    end
-
-    def error(message = nil, context = {})
-      add(Logger::Severity::ERROR, message.nil? && block_given? ? yield : message, **context)
-    end
+    # In the methods generated below, we assume that presence of context means new code that is
+    # aware of ContextualLogger...and that that code never uses progname.
+    # This is important because we only get 3 args total (not including &block) passed to `add`,
+    # in order to be compatible with classic implementations like in the plain ::Logger and
+    # ActiveSupport::Logger.broadcast.
 
-    def fatal(message = nil, context = {})
-      add(Logger::Severity::FATAL, message.nil? && block_given? ? yield : message, **context)
-    end
+    # Note that we can't yield before `add` because `add` might skip it based on log_level. And we can't check
+    # log_level here because we might be running in ActiveSupport::Logging.broadcast which has multiple
+    # loggers, each with their own log_level.
 
-    def unknown(message = nil, context = {})
-      add(Logger::Severity::UNKNOWN, message.nil? && block_given? ? yield : message, **context)
+    LOG_LEVEL_NAMES_TO_SEVERITY.each do |method_name, log_level|
+      class_eval(<<~EOS, __FILE__, __LINE__ + 1)
+        def #{method_name}(arg = nil, **context, &block)
+          if context.empty?
+            add(#{log_level}, nil, arg, &block)
+          else
+            if arg.nil?
+              add(#{log_level}, nil, context, &block)
+            elsif block
+              add(#{log_level}, nil, context.merge(progname: arg), &block)
+            else
+              add(#{log_level}, arg, context)
+            end
+          end
+        end
+      EOS
     end
 
     def log_level_enabled?(severity)
       severity >= level
     end
 
-    def add(init_severity, message = nil, init_progname = nil, **context)   # Ruby will prefer to match hashes up to last ** argument
-      severity = init_severity || UNKNOWN
+    # Note that this interface needs to stay compatible with the underlying ::Logger#add interface,
+    # which is: def add(severity, message = nil, progname = nil)
+    def add(arg_severity, arg1 = nil, arg2 = nil, **context)   # Ruby will prefer to match hashes up to last ** argument
+      severity = arg_severity || UNKNOWN
       if log_level_enabled?(severity)
-        progname = init_progname || @progname
-        if message.nil?
+        if arg1.nil?
           if block_given?
             message = yield
+            progname = arg2 || context.delete(:progname) || @progname
           else
-            message = init_progname
+            message = arg2
             progname = @progname
           end
+        else
+          message = arg1
+          progname = arg2 || @progname
         end
         write_entry_to_log(severity, Time.now, progname, message, context: current_context_for_thread.deep_merge(context))
       end
@@ -133,25 +138,25 @@ module ContextualLogger
     end
 
     def format_message(severity, timestamp, progname, message, context: {})
-      message_hash = message_hash_with_context(severity, timestamp, progname, message, context: context)
-
+      normalized_message = ContextualLogger.normalize_message(message)
+      normalized_progname = ContextualLogger.normalize_message(progname) unless progname.nil?
       if @formatter
-        @formatter.call(severity, timestamp, progname, message_hash)
+        @formatter.call(severity, timestamp, normalized_progname, { message: normalized_message }.merge!(context))
       else
-        "#{message_hash.to_json}\n"
+        "#{basic_json_log_entry(severity, timestamp, normalized_progname, normalized_message, context: context)}\n"
       end
     end
 
-    def message_hash_with_context(severity, timestamp, progname, message, context:)
-      message_hash =
-        {
-          message:   ContextualLogger.normalize_message(message),
-          severity:  severity,
-          timestamp: timestamp
-        }
-      message_hash[:progname] = progname if progname
+    def basic_json_log_entry(severity, timestamp, normalized_progname, normalized_message, context:)
+      message_hash = {
+        message: normalized_progname ? "#{normalized_progname}: #{normalized_message}" : normalized_message,
+        severity:  severity,
+        timestamp: timestamp
+      }
+      message_hash[:progname] = normalized_progname if normalized_progname
 
-      message_hash.merge!(context)
+      # merge! is faster and OK here since message_hash is still local only to this method
+      message_hash.merge!(context).to_json
     end
   end
 end

data/lib/contextual_logger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ContextualLogger
-  VERSION = '0.8.0'
+  VERSION = '0.10.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contextual_logger
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - James Ebentier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-15 00:00:00.000000000 Z
+date: 2020-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json