contextual_logger 1.2.0.colin.4 → 1.2.0.colin.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b8180f031cfc4c1facc22a0cfbbadf8970b01a1b7c1d18f974dbf54fd1712d5
-  data.tar.gz: d310df13569303aa5f6964d1cf9f73583fcfcabcd5950f330b00a30f8eb151f5
+  metadata.gz: 4e69ef52ab71f4f66d8f0d933f9ac6e74b5f2d8c218cd7b5865086f1ae00a6ff
+  data.tar.gz: e7245b4c4074d6f112730ed3b89b681b21a12042b96d03e751329f1a8f302363
 SHA512:
-  metadata.gz: e0c0350c9f36cf27071a7e1da1f42363979852304c4b029ca24d0a550c77bfb403815dc09420d5c8d9c164b003f8a22213e5d33216e1647ae63143a3b73447e9
-  data.tar.gz: 4984642ce8b36e78c3f14f0415ac95d67dec97f9f5651f6c63deb715bbfa27134243f7286e09802146b6629df0bc1077c476ea3e3d5ad783779daa718aef032d
+  metadata.gz: 7ced2de731f75eef24afa7d327c0947299202a92f904df2a424af43c3520de8cfdcc8b21d1967a198f17cb6510fe3406449e969077f9bcb0b8b173dfe94d6a52
+  data.tar.gz: 36e6d8e0e7c44e9444bd8907700b3072aa4f8f3767c2b7937dc5d59a747acfeb33c1943a8a4ed65a68ba5851ca16c5164daf948d2390b6bec19472721cefb21c

data/lib/contextual_logger/context.rb

@@ -2,17 +2,20 @@
 
 module ContextualLogger
   module Context
-    def thread_context_for_logger_instance
+    EMPTY_CONTEXT = {}.freeze
+
+    def thread_context_key_for_logger_instance
       # We include the object_id here to make these thread/fiber locals unique per logger instance.
-      @thread_context_for_logger_instance ||= "ContextualLogger::Context.context_for_#{object_id}".to_sym
+      @thread_context_key_for_logger_instance ||= "ContextualLogger::Context.context_for_#{object_id}".to_sym
     end
 
     def current_context_override
-      Thread.current[thread_context_for_logger_instance]
+      Thread.current[thread_context_key_for_logger_instance]
     end
 
     def current_context_override=(context_override)
-      Thread.current[thread_context_for_logger_instance] = context_override.freeze
+      ContextualLogger.global_context_lock_message ||= "ContextualLogger::Context.current_context_override set for #{self.class.name} #{object_id}: #{context_override.inspect}"
+      Thread.current[thread_context_key_for_logger_instance] = context_override.freeze
     end
   end
 end

data/lib/contextual_logger/global_context_lock_message.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ContextualLogger
+  class << self
+    attr_accessor :global_context_lock_message # nil or a string indicating what locked the global context
+  end
+
+  class GlobalContextIsLocked < StandardError
+  end
+end

data/lib/contextual_logger/logger_with_context.rb

@@ -6,6 +6,13 @@ 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.
   # If override_level is non-nil, it takes precedence; if it is nil (the default), then it delegates to the logger.
+  #
+  # Context Precedence:
+  # 1. inline **context passed to the logger method
+  # 2. `with_context` overrides on this LoggerWithContext object
+  # 3. context passed to this LoggerWithContext constructor
+  # 4. `with_context` overrides on the logger passed to this constructor
+  # 5. `global_context` set on the logger passed to this constructor
   class LoggerWithContext
     include LoggerMixin
 
@@ -16,11 +23,13 @@ module ContextualLogger
       @logger = logger
       self.level = level
       @context = normalize_context(context)
-      @merged_context_cache = {}  # so we don't have to merge every time
     end
 
+    # TODO: It's a (small) bug that the global_context is memoized at this point. There's a chance that the @logger.current_context
+    # changes after this because of an enclosing @logger.with_context block. If that happens, we'll miss that extra context.
+    # The tradeoff is that we don't want to keep calling deep_merge.
     def global_context
-      @logger.global_context
+      @global_context ||= @logger.current_context.deep_merge(@context) # this will include any with_context overrides on the `logger`
     end
 
     def level
@@ -33,10 +42,10 @@ module ContextualLogger
 
     def write_entry_to_log(severity, timestamp, progname, message, context:)
       merged_context =
-        if @merged_context_cache.size >= 1000 # keep this cache memory use finite
-          @merged_context_cache[context] || @context.deep_merge(context)
+        if context.any?
+          current_context.deep_merge(context)
         else
-          @merged_context_cache[context] ||= @context.deep_merge(context)
+          current_context
         end
 
       @logger.write_entry_to_log(severity, timestamp, progname, message, context: merged_context)

data/lib/contextual_logger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ContextualLogger
-  VERSION = '1.2.0.colin.4'
+  VERSION = '1.2.0.colin.6'
 end

data/lib/contextual_logger.rb

@@ -6,6 +6,7 @@ require 'json'
 require_relative './contextual_logger/redactor'
 require_relative './contextual_logger/context'
 require_relative './contextual_logger/context_handler'
+require_relative './contextual_logger/global_context_lock_message'
 
 module ContextualLogger
   LOG_LEVEL_NAMES_TO_SEVERITY =
@@ -43,16 +44,23 @@ module ContextualLogger
     end
   end
 
+  # Context Precedence when this is mixed into a logger:
+  # 1. inline **context passed to the logger method
+  # 2. `with_context` overrides on the logger object
+  # 3. `global_context` set on the logger passed to this constructor
   module LoggerMixin
     include Context
 
     delegate :register_secret, :register_secret_regex, to: :redactor
 
     def global_context
-      @global_context ||= {}.freeze
+      @global_context ||= Context::EMPTY_CONTEXT
     end
 
     def global_context=(context)
+      if (global_context_lock_message = ::ContextualLogger.global_context_lock_message)
+        raise ::ContextualLogger::GlobalContextIsLocked, global_context_lock_message
+      end
       @global_context = context.freeze
     end
 
@@ -63,18 +71,19 @@ module ContextualLogger
     # TODO: Deprecate current_context_for_thread in v2.0.
     alias current_context_for_thread current_context
 
-    def with_context(context)
-      previous_context_override = current_context_override
-      self.current_context_override = current_context.deep_merge(context)
+    def with_context(stacked_context)
+      context_handler = ContextHandler.new(self, current_context_override)
+      self.current_context_override = deep_merge_with_current_context(stacked_context)
+
       if block_given?
         begin
           yield
         ensure
-          self.current_context_override = previous_context_override
+          context_handler.reset!
         end
       else
         # If no block given, return context handler to the caller so they can call reset! themselves.
-        ContextHandler.new(self, previous_context_override)
+        context_handler
       end
     end
 
@@ -112,7 +121,7 @@ module ContextualLogger
 
     # 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
+    def add(arg_severity, arg1 = nil, arg2 = nil, **context)   # Ruby will prefer to match hashes to last argument because of **
       severity = arg_severity || UNKNOWN
       if log_level_enabled?(severity)
         if arg1.nil?
@@ -127,7 +136,7 @@ module ContextualLogger
           message = arg1
           progname = arg2 || @progname
         end
-        write_entry_to_log(severity, Time.now, progname, message, context: current_context.deep_merge(context))
+        write_entry_to_log(severity, Time.now, progname, message, context: deep_merge_with_current_context(context))
       end
 
       true
@@ -151,7 +160,7 @@ module ContextualLogger
       normalized_message = ContextualLogger.normalize_message(message)
       normalized_progname = ContextualLogger.normalize_message(progname) unless progname.nil?
       if @formatter
-        @formatter.call(severity, timestamp, normalized_progname, { message: normalized_message }.merge!(context))
+        @formatter.call(severity, timestamp, normalized_progname, { message: normalized_message, **context })
       else
         "#{basic_json_log_entry(severity, timestamp, normalized_progname, normalized_message, context: context)}\n"
       end
@@ -161,12 +170,20 @@ module ContextualLogger
       message_hash = {
         message: normalized_progname ? "#{normalized_progname}: #{normalized_message}" : normalized_message,
         severity:  severity,
-        timestamp: timestamp
+        timestamp: timestamp,
+        **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
+      message_hash.to_json
+    end
+
+    def deep_merge_with_current_context(stacked_context)
+      if stacked_context.any?
+        current_context.deep_merge(stacked_context)
+      else
+        current_context
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contextual_logger
 version: !ruby/object:Gem::Version
-  version: 1.2.0.colin.4
+  version: 1.2.0.colin.6
 platform: ruby
 authors:
 - James Ebentier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-02 00:00:00.000000000 Z
+date: 2023-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -47,6 +47,7 @@ files:
 - lib/contextual_logger.rb
 - lib/contextual_logger/context.rb
 - lib/contextual_logger/context_handler.rb
+- lib/contextual_logger/global_context_lock_message.rb
 - lib/contextual_logger/logger_with_context.rb
 - lib/contextual_logger/overrides/active_support/tagged_logging/formatter.rb
 - lib/contextual_logger/redactor.rb