contextual_logger 0.9.0.pre.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7396d052ab45c9e40375f045cac2ae2dffa8e0a74b964b61252f5dca8a8500f9
-  data.tar.gz: 1f6e1299b3ad104625fc0537259c5fab051230bf03d528961be518119b23b8b4
+  metadata.gz: 0c5fcdf15e253eb8abb46dde530238633bd584f151e0282526dcfce923b4dc50
+  data.tar.gz: da4e10e4a778d244b2c36640ec4600bc76e4357fd4b0ddfbfef362c2276bbd5a
 SHA512:
-  metadata.gz: 6649c29d562f319d8c8360ee6016b0b1bde30f07856c03c3f5c97f151a591b5784c4f74488253f6b4afd7c2f3419c857fef8b96b36be2e187fc12cf657d8a6d9
-  data.tar.gz: 318dbefabf79b8ad34db1aa268d4e930879883ae74c72b05f417e25267ee042a50711688210abfc7b31dc09698b40dbb524d95df59ea463d02d09101928a8948
+  metadata.gz: c575941e59fe7196d27528ea0733bd841eb47e45914f8b74add858227fc55161c2cbc2837653033f80ddfea3c3768538c137392d0e3a2b9f64c344982fb281ff
+  data.tar.gz: 199b5c2446a3fe1e6730b352dd23e93c0f9a52e04fffc335b28c6b26e0a2f5e3fe658b9949f57f87b3adba952e2b27ebc493e05dc5a3b2944baefcea0203e099

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,21 +138,25 @@ module ContextualLogger
     end
 
     def format_message(severity, timestamp, progname, message, context: {})
+      normalized_message = ContextualLogger.normalize_message(message)
+      normalized_progname = ContextualLogger.normalize_message(progname) unless progname.nil?
       if @formatter
-        @formatter.call(severity, timestamp, progname, { message: ContextualLogger.normalize_message(message), **context })
+        @formatter.call(severity, timestamp, normalized_progname, { message: normalized_message }.merge!(context))
       else
-        "#{basic_message_formatting(severity, timestamp, progname, message, context: context).to_json}\n"
+        "#{basic_json_log_entry(severity, timestamp, normalized_progname, normalized_message, context: context)}\n"
       end
     end
 
-    def basic_message_formatting(severity, timestamp, progname, message, context:)
+    def basic_json_log_entry(severity, timestamp, normalized_progname, normalized_message, context:)
       message_hash = {
-        message:   ContextualLogger.normalize_message(message),
+        message: normalized_progname ? "#{normalized_progname}: #{normalized_message}" : normalized_message,
         severity:  severity,
         timestamp: timestamp
       }
-      message_hash[:progname] = progname if progname
-      message_hash.merge(context)
+      message_hash[:progname] = normalized_progname if normalized_progname
+
+      # 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/logger_with_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/hash/keys'
+
 module ContextualLogger
   # A logger that deep_merges additional context and then delegates to the given logger.
   # Keeps it own log level (called override_level) that may be set independently of the logger it delegates to.
@@ -13,7 +15,7 @@ module ContextualLogger
       logger.is_a?(LoggerMixin) or raise ArgumentError, "logger must include ContextualLogger::LoggerMixin (got #{logger.inspect})"
       @logger = logger
       self.level = level
-      @context = context
+      @context = normalize_context(context)
       @merged_context_cache = {}  # so we don't have to merge every time
     end
 
@@ -36,6 +38,29 @@ module ContextualLogger
       @logger.write_entry_to_log(severity, timestamp, progname, message, context: merged_context)
     end
 
+    private
+
+    def normalize_context(context)
+      if warn_on_string_keys(context)
+        context.deep_symbolize_keys
+      else
+        context
+      end
+    end
+
+    def warn_on_string_keys(context)
+      if deep_key_has_string?(context)
+        ActiveSupport::Deprecation.warn('Context keys must use symbols not strings. This will be asserted as of contextual_logger v1.0.0')
+      end
+    end
+
+    def deep_key_has_string?(hash)
+      hash.any? do |key, value|
+        key.is_a?(String) ||
+          (value.is_a?(Hash) && deep_key_has_string?(value))
+      end
+    end
+
     class << self
       def for_log_source(logger, log_source, level: nil)
         new(logger, { log_source: log_source }, level: level)

data/lib/contextual_logger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ContextualLogger
-  VERSION = '0.9.0.pre.1'
+  VERSION = '0.11.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contextual_logger
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre.1
+  version: 0.11.0
 platform: ruby
 authors:
 - James Ebentier
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-17 00:00:00.000000000 Z
+date: 2020-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -56,7 +56,7 @@ licenses:
 metadata:
   source_code_uri: https://github.com/Invoca/contextual_logger
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,12 +67,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Add context to your logger
 test_files: []