tmp commit

Author: Fire-Dragon-DoL

lib/semantic_logger/base.rb

@@ -6,8 +6,18 @@
 #
 module SemanticLogger
   class Base
+    # Creates a copy of an existing logger.
+    # This method can be overridden by subclasses to provide a specialized implementation.
+    # `child` logger uses this method.
+    def self.copy(instance)
+      raise ArgumentError, "Cannot copy instances different from #{self}" if instance.class != self
+
+      instance.dup
+    end
+
     # Class name to be logged
-    attr_accessor :name, :filter, :child_named_tags
+    attr_accessor :name, :filter
+    attr_reader :instance_named_tags
 
     # Set the logging level for this logger
     #
@@ -252,12 +262,19 @@ def should_log?(log)
 
     # Creates a new logger with the given instance named tags
     def child(**named_tags)
-      new_named_tags = child_named_tags.merge(named_tags)
-      new_logger = dup
-      new_logger.child_named_tags = new_named_tags
+      new_named_tags = instance_named_tags.merge(named_tags)
+      new_logger = self.class.copy(self)
+      new_logger.instance_named_tags = new_named_tags
       new_logger
     end
 
+    protected
+
+    def instance_named_tags=(named_tags)
+      # Prevent accidental mutation of log named tags
+      @instance_named_tags = named_tags.dup.freeze
+    end
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Base
@@ -283,7 +300,7 @@ def child(**named_tags)
     #          (/\AExclude/ =~ log.message).nil?
     #        end
     #      end
-    def initialize(klass, level = nil, filter = nil)
+    def initialize(klass, level = nil, filter = nil, instance_named_tags = {})
       # Support filtering all messages to this logger instance.
       unless filter.nil? || filter.is_a?(Regexp) || filter.is_a?(Proc) || filter.respond_to?(:call)
         raise ":filter must be a Regexp, Proc, or implement :call"
@@ -298,7 +315,7 @@ def initialize(klass, level = nil, filter = nil)
       else
         self.level = level
       end
-      @child_named_tags = {}
+      self.instance_named_tags = instance_named_tags
     end
 
     # Return the level index for fast comparisons
@@ -334,7 +351,7 @@ def log_internal(level, index, message = nil, payload = nil, exception = nil)
         payload = nil
       end
 
-      log = Log.new(name, level, index)
+      log = Log.new(name, level, index, instance_named_tags)
       should_log =
         if exception.nil? && payload.nil? && message.is_a?(Hash)
           # All arguments as a hash in the message.
@@ -358,9 +375,6 @@ def log_internal(level, index, message = nil, payload = nil, exception = nil)
         end
       end
 
-      # Add child named tags to the log
-      log.payload = child_named_tags.merge(log.payload || {})
-
       # Log level may change during assign due to :on_exception_level
       self.log(log) if should_log && should_log?(log)
     end
@@ -388,7 +402,7 @@ def measure_internal(level, index, message, params)
         exception = e
       ensure
         # Must use ensure block otherwise a `return` in the yield above will skip the log entry
-        log = Log.new(name, level, index)
+        log = Log.new(name, level, index, instance_named_tags)
         exception ||= params[:exception]
         message   = params[:message] if params[:message]
         duration  =
@@ -401,8 +415,8 @@ def measure_internal(level, index, message, params)
         # Extract options after block completes so that block can modify any of the options
         payload = params[:payload]
 
-        # Add child named tags
-        payload = child_named_tags.merge(payload || {})
+        # Add instance named tags
+        payload = instance_named_tags.merge(payload || {})
 
         # May return false due to elastic logging
         should_log = log.assign(

lib/semantic_logger/formatters/raw.rb

@@ -64,6 +64,10 @@ def tags
       # Named Tags
       def named_tags
         hash[:named_tags] = log.named_tags if log.named_tags && !log.named_tags.empty?
+        # TODO: Test
+        # TODO: Different hash entry instead?
+        # Always overrides thread named_tags with instance_named_tags
+        hash[:named_tags] = hash.fetch(:named_tags, {}).merge(log.instance_named_tags) if log.instance_named_tags && !log.instance_named_tags.empty?
       end
 
       # Duration

lib/semantic_logger/log.rb

@@ -28,6 +28,9 @@ module SemanticLogger
   # tags
   #   Any tags active on the thread when the log call was made
   #
+  # instance_named_tags
+  #   Any named tags active on the logger instance when the log call was made
+  #
   # level_index
   #   Internal index of the log level
   #
@@ -55,16 +58,17 @@ class Log
 
     attr_accessor :level, :level_index, :name, :message, :time, :duration,
                   :payload, :exception, :thread_name, :backtrace,
-                  :tags, :named_tags, :context,
+                  :tags, :named_tags, :instance_named_tags, :context,
                   :metric, :metric_amount, :dimensions
 
-    def initialize(name, level, index = nil)
+    def initialize(name, level, index = nil, instance_named_tags = {})
       @level       = level
       @thread_name = Thread.current.name
       @name        = name
       @time        = Time.now
       @tags        = SemanticLogger.tags
       @named_tags  = SemanticLogger.named_tags
+      @instance_named_tags = instance_named_tags
       @level_index = index.nil? ? Levels.index(level) : index
     end
 

lib/semantic_logger/loggable.rb

@@ -42,7 +42,7 @@ def self.included(base)
 
         # Returns [SemanticLogger::Logger] class level logger
         def self.logger
-          @semantic_logger ||= SemanticLogger[self].child(**@logger_child_named_tags)
+          @semantic_logger ||= SemanticLogger[self].child(**@logger_instance_named_tags)
         end
 
         # Replace instance class level logger
@@ -115,7 +115,7 @@ def #{method_name}(*args, &block)
       end
 
       def logger_child(**named_tags)
-        @logger_child_named_tags = named_tags
+        @logger_instance_named_tags = named_tags
       end
 
       private

lib/semantic_logger/logger.rb

@@ -4,6 +4,12 @@ module SemanticLogger
   class Logger < Base
     include SemanticLogger::Concerns::Compatibility
 
+    # def self.copy(instance)
+    #   raise ArgumentError, "Cannot copy instances different from #{self}" if instance.class != self
+
+    #   new(instance.name, instance.level, instance.filter, instance.instance_named_tags)
+    # end
+
     def self.subscribe(object = nil, &block)
       subscriber = block || object
 
@@ -56,7 +62,11 @@ def self.sync?
     #    regular expression. All other messages will be ignored
     #    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)
+    #
+    #  instance_named_tags
+    #    Named tags to be added to all log messages for this logger instance
+    #    Default: {}
+    def initialize(klass, level = nil, filter = nil, instance_named_tags = {})
       super
     end
 

lib/semantic_logger/subscriber.rb

@@ -3,6 +3,21 @@
 #   Abstract base class for all appenders.
 module SemanticLogger
   class Subscriber < SemanticLogger::Base
+    # def self.copy(instance)
+    #   raise ArgumentError, "Cannot copy instances different from #{self}" if instance.class != self
+
+    #   new(
+    #     level:               instance.level,
+    #     formatter:           instance.formatter,
+    #     filter:              instance.filter,
+    #     application:         instance.application,
+    #     environment:         instance.environment,
+    #     host:                instance.host,
+    #     metrics:             instance.metrics?,
+    #     instance_named_tags: instance.instance_named_tags
+    #   )
+    # end
+
     # Every appender has its own formatter
     attr_reader :formatter
     attr_writer :application, :environment, :host, :logger, :metrics
@@ -78,6 +93,11 @@ def console_output?
       false
     end
 
+    # Whether to log metric only entries with this subscriber
+    def metrics?
+      @metrics
+    end
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Subscriber
@@ -108,8 +128,12 @@ def console_output?
     #   metrics: [Boolean]
     #     Whether to log metric only entries with this subscriber.
     #     Default: false
+    #
+    #   instance_named_tags: [Hash]
+    #     Named tags to be added to all log messages for this subscriber
+    #     Default: {}
     def initialize(level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil,
-                   metrics: false, &block)
+                   metrics: false, instance_named_tags: {}, &block)
       self.formatter = block || formatter
       @application   = application
       @environment   = environment
@@ -118,7 +142,7 @@ def initialize(level: nil, formatter: nil, filter: nil, application: nil, enviro
 
       # Subscribers don't take a class name, so use this class name if a subscriber
       # is logged to directly.
-      super(self.class, level, filter)
+      super(self.class, level, filter, instance_named_tags)
     end
 
     # Return the level index for fast comparisons.
@@ -127,10 +151,5 @@ def initialize(level: nil, formatter: nil, filter: nil, application: nil, enviro
     def level_index
       @level_index || 0
     end
-
-    # Whether to log metric only entries with this subscriber
-    def metrics?
-      @metrics
-    end
   end
 end

lib/semantic_logger/test/capture_log_events.rb

@@ -20,6 +20,12 @@ module Test
     #     end
     #   end
     class CaptureLogEvents < SemanticLogger::Subscriber
+      def self.copy(instance)
+        new_instance = super
+        new_instance.events = []
+        new_instance
+      end
+
       attr_accessor :events
 
       # By default collect all log levels, and collect metric only log events.

lib/semantic_logger/test/minitest.rb

@@ -20,12 +20,13 @@ def semantic_logger_events(deprecated_klass = nil, klass: deprecated_klass, sile
         logger.events
       end
 
+      # TODO: Add instance_named_tags
       # Verify a single log event has all the required attributes.
       def assert_semantic_logger_event(event, level: nil, name: nil, message: nil, message_includes: nil,
                                        payload: nil, payload_includes: nil,
                                        exception: nil, exception_includes: nil, backtrace: nil,
                                        thread_name: nil, tags: nil, named_tags: nil, context: nil,
-                                       level_index: nil, duration: nil, time: nil,
+                                       instance_named_tags: nil, level_index: nil, duration: nil, time: nil,
                                        metric: nil, metric_amount: nil, dimensions: nil)
         assert event, "No log event occurred"
 
@@ -35,6 +36,7 @@ def assert_semantic_logger_event(event, level: nil, name: nil, message: nil, mes
         assert_semantic_logger_entry(event, :thread_name, thread_name)
         assert_semantic_logger_entry(event, :tags, tags)
         assert_semantic_logger_entry(event, :named_tags, named_tags)
+        assert_semantic_logger_entry(event, :instance_named_tags, instance_named_tags)
         assert_semantic_logger_entry(event, :context, context)
         assert_semantic_logger_entry(event, :metric, metric)
         assert_semantic_logger_entry(event, :metric_amount, metric_amount)

test/loggable_test.rb

@@ -89,8 +89,8 @@ class TestChildClassLogger
     end
 
     describe "sample child class logger" do
-      it "has child named tags set" do
-        assert_equal TestChildClassLogger::TAG_DATA, TestChildClassLogger.logger.child_named_tags
+      it "has instance named tags set" do
+        assert_equal TestChildClassLogger::TAG_DATA, TestChildClassLogger.logger.instance_named_tags
       end
     end
   end

test/logger_test.rb

@@ -155,15 +155,35 @@ def self.call(log)
     end
 
     describe ".child" do
-      it "creates a child logger" do
-        tag_data = {tag1: "value1", tag2: "value2"}
-        child_logger = logger.child(**tag_data)
+      it "creates a child logger with instance named tags merged with parent" do
+        parent_tag_data = {parent_tag: "parent_value"}
+        child_tag_data = {tag1: "value1", tag2: "value2"}
+        parent_logger = logger.child(**parent_tag_data)
+        child_logger = parent_logger.child(**child_tag_data)
+
         child_logger.info("hello world")
 
-        assert_equal tag_data, child_logger.child_named_tags
-        assert log = child_logger.events.first
-        assert_equal "hello world", log.message
-        assert_equal tag_data, log.payload
+        assert_equal parent_tag_data, parent_logger.instance_named_tags
+        assert_equal parent_tag_data.merge(child_tag_data), child_logger.instance_named_tags
+      end
+
+      it "outputs log entries with different instance named tags from the parent" do
+        parent_tag_data = {parent_tag: "parent_value"}
+        child_tag_data = {tag1: "value1", tag2: "value2"}
+        parent_logger = logger.child(**parent_tag_data)
+        child_logger = parent_logger.child(**child_tag_data)
+
+        parent_logger.info("hello parent")
+
+        assert log_parent = parent_logger.events.first
+        assert_equal "hello parent", log_parent.message
+        assert_equal parent_tag_data, log_parent.instance_named_tags
+
+        child_logger.info("hello child")
+
+        assert log_child = child_logger.events.first
+        assert_equal "hello child", log_child.message
+        assert_equal parent_tag_data.merge(child_tag_data), log_child.instance_named_tags
       end
     end
   end