debug_logging 3.1.9 → 4.0.1

data/lib/debug_logging/argument_printer.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "date"
 require "time"
 
@@ -9,11 +7,13 @@ module DebugLogging
       "completed in #{format("%f", tms.real)}s (#{format("%f", tms.total)}s CPU)"
     end
 
-    def debug_invocation_id_to_s(args: nil, config_proxy: nil)
-      return "" unless args && config_proxy
+    def debug_invocation_id_to_s(args: nil, kwargs: nil, start_at: nil, config_proxy: nil)
+      return "" unless (args || kwargs) && config_proxy
 
       if config_proxy.debug_add_invocation_id
-        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % "%#-21a")[4..-4]}~"
+        time = start_at ? Util.debug_time(start_at) : Time.now
+        unique_id = (time.to_f.to_s % "%#-21a")[4..-4]
+        invocation = " ~#{args.object_id}|#{kwargs.object_id}@#{unique_id}~"
         case config_proxy.debug_add_invocation_id
         when true
           invocation
@@ -25,21 +25,25 @@ module DebugLogging
       end
     end
 
-    def debug_time_to_s(time_or_monotonic)
+    # @return [String]
+    def debug_time_to_s(time_or_monotonic, config_proxy: nil)
+      return "" unless config_proxy&.debug_add_timestamp
+      return config_proxy.debug_time_formatter_proc.call(Time.now) unless time_or_monotonic
+
+      time = Util.debug_time(time_or_monotonic)
+
+      config_proxy.debug_time_formatter_proc.call(time)
+    end
+
+    # A custom time format will never apply here, because ActiveSupport::Notifications have a required time format
+    def debug_event_time_to_s(time_or_monotonic)
       # Time format must match:
       #   \d{4,}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-+]\d{4}
       #   YYYY-MM-DD HH:mm:ss +00:00
       #   strftime("%F %T %z")
-      case time_or_monotonic
-      when Float
-        Time.at(time_or_monotonic).strftime("%F %T %z")
-      when Time, DateTime
-        time_or_monotonic.strftime("%F %T %z")
-      when String
-        Time.parse(time_or_monotonic).strftime("%F %T %z")
-      else
-        time_or_monotonic
-      end
+      time_or_monotonic = Time.now if time_or_monotonic.nil? || (time_or_monotonic.respond_to?(:empty?) && time_or_monotonic.empty?)
+      time = Util.debug_time(time_or_monotonic)
+      DebugLogging::Constants::EVENT_TIME_FORMATTER.call(time)
     end
 
     def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
@@ -58,12 +62,14 @@ module DebugLogging
       "#{klass_string}#{separator}#{method_string}"
     end
 
-    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity
-      return "" unless args && config_proxy
+    def debug_signature_to_s(args: nil, kwargs: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity
+      return "" unless (args || kwargs) && config_proxy
 
       printed_args = ""
 
       add_args_ellipsis = false
+      args = args.dup
+      args.push(kwargs) if kwargs
       if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
         add_other_args_ellipsis = false
         if args.length > 1
@@ -188,7 +194,7 @@ module DebugLogging
           proc_name: "add_payload",
           proc: config_proxy.debug_add_payload,
           args: payload,
-          max_length: config_proxy.payload_max_length,
+          max_length: config_proxy.debug_payload_max_length,
         )
         printed_payload += printed
         printed_payload += config_proxy.debug_ellipsis if add_payload_ellipsis

data/lib/debug_logging/class_logger.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module ClassLogger
     def logged(*methods_to_log)
@@ -31,7 +29,7 @@ module DebugLogging
                 paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
                 log_prefix = debug_invocation_to_s(
                   klass: to_s,
-                  separator: ".",
+                  separator: "::",
                   method_to_log: method_to_log,
                   config_proxy: config_proxy,
                 )

data/lib/debug_logging/class_notifier.rb

@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module ClassNotifier
-    def notifies(*methods_to_notify)
+    def notified(*methods_to_notify)
       methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
         method_names: methods_to_notify,
         payload: nil,
@@ -40,18 +38,16 @@ module DebugLogging
                 **paydirt,
               },
             ) do
-              begin
-                if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
-                  original_method.call(**harsh, &block)
-                else
-                  original_method.call(*args, &block)
-                end
-              rescue StandardError => e
-                if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args)
-                else
-                  raise e
-                end
+              if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                original_method.call(**harsh, &block)
+              else
+                original_method.call(*args, &block)
+              end
+            rescue StandardError => e
+              if config_proxy.error_handler_proc
+                config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args)
+              else
+                raise e
               end
             end
           end

data/lib/debug_logging/configuration.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module DebugLogging
   class Configuration
     include Constants
@@ -11,21 +9,29 @@ module DebugLogging
     # alias the readers to the debug_* prefix so an instance of this class
     #   can have the same API granted by `extend DebugLogging`
     #
-    #     include DebugLogging::InstanceLogger.new(
-    #       i_methods: [:drive, :stop],
-    #       config: {
-    #           logger: Logger.new(STDOUT) # probably want to override to be the Rails.logger
-    #           log_level: :debug # at what level do the messages created by this gem sent at?
-    #           last_hash_to_s_proc: nil # e.g. ->(hash) { "keys: #{hash.keys}" }
-    #           last_hash_max_length: 1_000
-    #           args_to_s_proc: nil # e.g. ->(*record) { "record id: #{record.first.id}" }
-    #           args_max_length: 1_000
-    #           instance_benchmarks: false
-    #           class_benchmarks: false
-    #           add_invocation_id: true # invocation id allows you to identify a method call uniquely in a log
-    #           ellipsis: " ✂️ …".freeze
+    #     extend DebugLogging::InstanceLogger
+    #     i_logged [:drive, :stop],
+    #       {
+    #         logger: Logger.new($stdout), # probably want to override to be the Rails.logger
+    #         log_level: :debug, # at what level do the messages created by this gem sent at?
+    #         multiple_last_hashes: false,
+    #         last_hash_to_s_proc: nil, # e.g. ->(hash) { "keys: #{hash.keys}" }
+    #         last_hash_max_length: 1_000,
+    #         args_to_s_proc: nil, # e.g. ->(*record) { "record id: #{record.first.id}" }
+    #         args_max_length: 1_000,
+    #         colorized_chain_for_method: false, # e.g. ->(colorized_string) { colorized_string.red.on_blue.underline }
+    #         colorized_chain_for_class: false,  # e.g. ->(colorized_string) { colorized_string.colorize(:light_blue ).colorize( :background => :red) }
+    #         add_invocation_id: true, # allows unique identification of method call; association of entry and exit log lines
+    #         ellipsis: " ✂️ …".freeze,
+    #         mark_scope_exit: false,
+    #         add_payload: true, # Can also be a proc returning a string, which will be called when printing the payload
+    #         payload_max_length: 1_000,
+    #         error_handler_proc: nil,
+    #         time_formatter_proc: DebugLogging::Constants::DEFAULT_TIME_FORMATTER,
+    #         add_timestamp: false,
+    #         instance_benchmarks: false,
+    #         class_benchmarks: false,
     #       }
-    #     )
     #
     CONFIG_KEYS.each do |key|
       alias_method :"debug_#{key}", :"#{key}"
@@ -39,12 +45,13 @@ module DebugLogging
         "@debug_logging_config_#{type}_#{Digest::MD5.hexdigest(method_to_log.to_s)}".to_sym
       end
     end
+
     def initialize(**options)
       CONFIG_ATTRS.each do |key|
-        send("#{key}=", get_attr_from_options(options, key))
+        send(:"#{key}=", get_attr_from_options(options, key))
       end
       CONFIG_READERS.each do |key|
-        send("#{key}=", get_reader_from_options(options, key))
+        send(:"#{key}=", get_reader_from_options(options, key))
       end
       @methods_to_log = []
     end
@@ -63,7 +70,7 @@ module DebugLogging
     def loggable?
       return @loggable if defined?(@loggable)
 
-      @loggable = logger.send("#{log_level}?")
+      @loggable = logger.send(:"#{log_level}?")
     end
 
     def benchmarkable_for?(benchmarks)
@@ -95,7 +102,7 @@ module DebugLogging
 
     def to_hash
       CONFIG_KEYS.each_with_object({}) do |key, hash|
-        hash[key] = instance_variable_get("@#{key}")
+        hash[key] = instance_variable_get(:"@#{key}")
       end
     end
 

data/lib/debug_logging/constants.rb

@@ -1,25 +1,27 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module Constants
     DEFAULT_ELLIPSIS = " ✂️ …"
+    DEFAULT_TIME_FORMATTER = ->(time) { "[#{time.strftime("%Y%m%d %H:%M:%S")}] " }
+    EVENT_TIME_FORMATTER = ->(time) { time.strftime("%F %T %z") }
     CONFIG_ATTRS_DEFAULTS = {
       enabled: true,
-      logger: Logger.new($stdout),
-      log_level: :debug,
+      logger: Logger.new($stdout), # probably want to override to be the Rails.logger
+      log_level: :debug, # at what level do the messages created by this gem sent at?
       multiple_last_hashes: false,
-      last_hash_to_s_proc: nil,
+      last_hash_to_s_proc: nil, # e.g. ->(hash) { "keys: #{hash.keys}" }
       last_hash_max_length: 1_000,
-      args_to_s_proc: nil,
+      args_to_s_proc: nil, # e.g. ->(*record) { "record id: #{record.first.id}" }
       args_max_length: 1_000,
-      colorized_chain_for_method: false,
-      colorized_chain_for_class: false,
-      add_invocation_id: true,
+      colorized_chain_for_method: false, # e.g. ->(colorized_string) { colorized_string.red.on_blue.underline }
+      colorized_chain_for_class: false,  # e.g. ->(colorized_string) { colorized_string.colorize(:light_blue ).colorize( :background => :red) }
+      add_invocation_id: true, # allows unique identification of method call; association of entry and exit log lines
       ellipsis: DEFAULT_ELLIPSIS,
       mark_scope_exit: false,
       add_payload: true, # Can also be a proc returning a string, which will be called when printing the payload
       payload_max_length: 1_000,
       error_handler_proc: nil,
+      time_formatter_proc: DEFAULT_TIME_FORMATTER,
+      add_timestamp: false,
     }.freeze
     CONFIG_ATTRS = CONFIG_ATTRS_DEFAULTS.keys
     CONFIG_READERS_DEFAULTS = {

data/lib/debug_logging/finalize.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # From: https://stackoverflow.com/a/34559282
 # License: https://creativecommons.org/licenses/by-sa/4.0/
 module DebugLogging

data/lib/debug_logging/hooks.rb

@@ -16,16 +16,14 @@ module DebugLogging
         names.each do |name|
           meth = instance_method(name)
           define_method(name) do |*args, &block|
-            begin
-              Timeout.timeout(time) do
-                meth.bind(self).call(*args, &block)
-              end
-            rescue Timeout::Error
-              error_args = [TimeoutError, "execution expired", caller]
-              raise(*error_args) unless blk
-
-              instance_exec(*error_args, &blk)
+            Timeout.timeout(time) do
+              meth.bind_call(self, *args, &block)
             end
+          rescue Timeout::Error
+            error_args = [TimeoutError, "execution expired", caller]
+            raise(*error_args) unless blk
+
+            instance_exec(*error_args, &blk)
           end
         end
       end
@@ -39,11 +37,9 @@ module DebugLogging
         names.each do |name|
           meth = instance_method(name)
           define_method(name) do |*args, &block|
-            begin
-              meth.bind(self).call(*args, &block)
-            rescue StandardError => e
-              instance_exec(e, &blk)
-            end
+            meth.bind_call(self, *args, &block)
+          rescue StandardError => e
+            instance_exec(e, &blk)
           end
         end
       end
@@ -58,7 +54,7 @@ module DebugLogging
           meth = instance_method(name)
           define_method(name) do |*args, &block|
             instance_exec(name, *args, block, &blk)
-            meth.bind(self).call(*args, &block)
+            meth.bind_call(self, *args, &block)
           end
         end
       end
@@ -72,7 +68,7 @@ module DebugLogging
         names.each do |name|
           meth = instance_method(name)
           define_method(name) do |*args, &block|
-            result = meth.bind(self).call(*args, &block)
+            result = meth.bind_call(self, *args, &block)
             instance_exec(result, &blk)
           end
         end

data/lib/debug_logging/instance_logger.rb

@@ -1,24 +1,50 @@
-# frozen_string_literal: true
-
 module DebugLogging
-  class InstanceLogger < Module
-    def initialize(i_methods: nil, payload: nil, config: nil)
-      super()
-      @config = config
-      @payload = payload
-      @instance_methods_to_log = Array(i_methods) if i_methods
-    end
-
-    def included(base)
-      return unless @instance_methods_to_log
-
-      base.send(:include, ArgumentPrinter)
-      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(
-        methods_to_log: @instance_methods_to_log,
-        payload: @payload,
-        config: @config,
+  module InstanceLogger
+    # NOTE: These params can be passed in / hidden in a last hash of *args
+    # NOTE: They can also be passed in discretely for each method, by passing *args as an array of arrays
+    # TODO: Refactor to use modern Ruby 3 *args, **kwargs instead
+    # @param logger [Logger] Logger.new($stdout), # probably want to override to be the Rails.logger
+    # @param log_level [Symbol] default: :debug, at what level do the messages created by this gem sent at?
+    # @param multiple_last_hashes [true, false] default: false,
+    # @param last_hash_to_s_proc [nil, Proc] default: nil, e.g. ->(hash) { "keys: #{hash.keys}" }
+    # @param last_hash_max_length [Integer] default: 1_000,
+    # @param args_to_s_proc [nil, Proc] default: nil, e.g. ->(*record) { "record id: #{record.first.id}" }
+    # @param args_max_length [Integer] default: 1_000,
+    # @param colorized_chain_for_method [false, Proc] default: false, e.g. ->(colorized_string) { colorized_string.red.on_blue.underline }
+    # @param colorized_chain_for_class [false, Proc] default: false, e.g. ->(colorized_string) { colorized_string.colorize(:light_blue ).colorize( :background => :red) }
+    # @param add_invocation_id [true, false] default: true, allows unique identification of method call; association of entry and exit log lines
+    # @param ellipsis [String] default: " ✂️ …".freeze,
+    # @param mark_scope_exit [true, false] default: false,
+    # @param add_payload [true, false, Proc] default: true, # Can also be a proc returning a string, which will be called when printing the payload
+    # @param payload_max_length [Integer] default: 1_000,
+    # @param error_handler_proc [nil, Proc] default: nil,
+    # @param time_formatter_proc [nil, Proc] default: DebugLogging::Constants::DEFAULT_TIME_FORMATTER,
+    # @param add_timestamp [true, false] default: false,
+    # @param instance_benchmarks [true, false] default: false,
+    # @param class_benchmarks [true, false] default: false,
+    def i_logged(*methods_to_log)
+      methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_log,
+        payload: nil,
+        config: nil,
       )
-      base.send(:prepend, instance_method_logger)
+      instance_method_modules =
+        Array(methods_to_log).map do |method_to_log|
+          DebugLogging::InstanceLoggerModulizer.to_mod(
+            methods_to_log: Array(method_to_log),
+            payload: payload,
+            config: config_opts,
+          )
+        end
+      wrapped_in_logs = Module.new do
+        singleton_class.send(:define_method, :included) do |host_class|
+          instance_method_modules.each do |mod|
+            host_class.prepend(mod)
+          end
+        end
+      end
+
+      send(:include, wrapped_in_logs)
     end
   end
 end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -1,65 +1,69 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module InstanceLoggerModulizer
-    def self.to_mod(methods_to_log: nil, payload: nil, config: nil)
-      Module.new do
-        methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
-          method_names: Array(methods_to_log),
-          payload: payload,
-          config: config,
-        )
-        Array(methods_to_log).each do |method_to_log|
-          method_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
-            method_names: method_to_log,
-            payload: payload,
-            config: config_opts,
+    class << self
+      def to_mod(methods_to_log: nil, payload: nil, config: nil)
+        Module.new do
+          methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+            method_names: Array(methods_to_log),
+            payload:,
+            config:,
           )
-          define_method(method_to_log) do |*args, &block|
-            method_return_value = nil
-            config_proxy = DebugLogging::Util.config_proxy_finder(
-              scope: self.class,
-              config_opts: method_config_opts,
-              method_name: method_to_log,
-              proxy_ref: "ilm",
+          Array(methods_to_log).each do |method_to_log|
+            method_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+              method_names: method_to_log,
+              payload:,
+              config: config_opts,
             )
-            log_prefix = self.class.debug_invocation_to_s(
-              klass: self.class.to_s,
-              separator: "#",
-              method_to_log: method_to_log,
-              config_proxy: config_proxy,
-            )
-            invocation_id = self.class.debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
-            config_proxy.log do
-              paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
-              signature = self.class.debug_signature_to_s(args: args, config_proxy: config_proxy)
-              paymud = debug_payload_to_s(payload: paydirt, config_proxy: config_proxy)
-              "#{log_prefix}#{signature}#{invocation_id} debug: #{paymud}"
-            end
-            if config_proxy.benchmarkable_for?(:debug_instance_benchmarks)
-              tms = Benchmark.measure do
-                method_return_value = super(*args, &block)
-              end
+            define_method(method_to_log) do |*args, **kwargs, &block|
+              method_return_value = nil
+              config_proxy = DebugLogging::Util.config_proxy_finder(
+                scope: self.class,
+                config_opts: method_config_opts,
+                method_name: method_to_log,
+                proxy_ref: "ilm",
+              )
+              log_prefix = self.class.debug_invocation_to_s(
+                klass: self.class.to_s,
+                separator: "#",
+                method_to_log: method_to_log,
+                config_proxy: config_proxy,
+              )
+              start_at = Time.now
+              start_timestamp = self.class.debug_time_to_s(start_at, config_proxy:)
+              invocation_id = self.class.debug_invocation_id_to_s(args:, kwargs:, start_at:, config_proxy:)
               config_proxy.log do
-                "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+                paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
+                signature = self.class.debug_signature_to_s(args:, kwargs:, config_proxy:)
+                paymud = debug_payload_to_s(payload: paydirt, config_proxy:)
+                "#{start_timestamp}#{log_prefix}#{signature}#{invocation_id} debug: #{paymud}"
               end
-            else
-              begin
-                method_return_value = super(*args, &block)
-              rescue StandardError => e
-                if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args)
-                else
-                  raise e
+              if config_proxy.benchmarkable_for?(:debug_instance_benchmarks)
+                tms = Benchmark.measure do
+                  method_return_value = super(*args, **kwargs, &block)
                 end
-              end
-              if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+                end_timestamp = self.class.debug_time_to_s(Time.now, config_proxy:)
                 config_proxy.log do
-                  "#{log_prefix} completed#{invocation_id}"
+                  "#{end_timestamp}#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+                end
+              else
+                begin
+                  method_return_value = super(*args, **kwargs, &block)
+                rescue StandardError => e
+                  if config_proxy.error_handler_proc
+                    config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args, kwargs)
+                  else
+                    raise e
+                  end
+                end
+                if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+                  end_timestamp = self.class.debug_time_to_s(Time.now, config_proxy:)
+                  config_proxy.log do
+                    "#{end_timestamp}#{log_prefix} completed#{invocation_id}"
+                  end
                 end
               end
+              method_return_value
             end
-            method_return_value
           end
         end
       end

data/lib/debug_logging/instance_notifier.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
 module DebugLogging
-  class InstanceNotifier < Module
-    def initialize(i_methods: nil, payload: nil, config: nil)
-      super()
-      @config = config
-      @payload = payload
-      @instance_methods_to_notify = Array(i_methods) if i_methods
-    end
-
-    def included(base)
-      return unless @instance_methods_to_notify
-
-      base.send(:include, ArgumentPrinter)
+  module InstanceNotifier
+    def i_notified(*methods_to_log)
+      method_names, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_log,
+        payload: nil,
+        config: nil,
+      )
       instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(
-        methods_to_notify: @instance_methods_to_notify,
-        payload: @payload,
-        config: @config,
+        methods_to_notify: Array(method_names),
+        payload: payload,
+        config: config_opts,
       )
-      base.send(:prepend, instance_method_notifier)
+
+      wrapped_in_notifier = Module.new do
+        singleton_class.send(:define_method, :included) do |host_class|
+          host_class.prepend(instance_method_notifier)
+        end
+      end
+
+      send(:include, wrapped_in_notifier)
     end
   end
 end

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -1,51 +1,45 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module InstanceNotifierModulizer
-    def self.to_mod(methods_to_notify: nil, payload: nil, config: nil)
-      Module.new do
-        methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
-          method_names: Array(methods_to_notify),
-          payload: payload,
-          config: config,
-        )
-        Array(methods_to_notify).each do |method_to_notify|
-          method_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
-            method_names: method_to_notify,
-            payload: payload,
-            config: config_opts,
+    class << self
+      def to_mod(methods_to_notify: nil, payload: nil, config: nil)
+        Module.new do
+          methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+            method_names: Array(methods_to_notify),
+            payload:,
+            config:,
           )
-          define_method(method_to_notify) do |*args, &block|
-            config_proxy = DebugLogging::Util.config_proxy_finder(
-              scope: self.class,
-              config_opts: method_config_opts,
-              method_name: method_to_notify,
-              proxy_ref: "inm",
-            ) do |config_proxy|
-              ActiveSupport::Notifications.subscribe(
-                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
-              ) do |*args|
-                config_proxy&.log do
-                  DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
+          Array(methods_to_notify).each do |method_to_notify|
+            method_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+              method_names: method_to_notify,
+              payload:,
+              config: config_opts,
+            )
+            define_method(method_to_notify) do |*args, **kwargs, &block|
+              config_proxy = DebugLogging::Util.config_proxy_finder(
+                scope: self.class,
+                config_opts: method_config_opts,
+                method_name: method_to_notify,
+                proxy_ref: "inm",
+              ) do |config_proxy|
+                ActiveSupport::Notifications.subscribe(
+                  DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify:),
+                ) do |*subscribe_args|
+                  config_proxy&.log do
+                    DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*subscribe_args))
+                  end
                 end
               end
-            end
-            paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
-            ActiveSupport::Notifications.instrument(
-              DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
-              debug_args: args,
-              config_proxy: config_proxy,
-              **paydirt,
-            ) do
-              begin
-                # TODO: I need to split logic based on Ruby version.
-                # TODO: Use VersionGem's minimum Ruby version check
-                # TODO: Switch between positional, and kwargs argument handling
-                # See: https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
-                super(*args, &block)
+              paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
+              ActiveSupport::Notifications.instrument(
+                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify:),
+                debug_args: kwargs.empty? ? args : args + [kwargs],
+                config_proxy: config_proxy,
+                **paydirt,
+              ) do
+                super(*args, **kwargs, &block)
               rescue StandardError => e
                 if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args)
+                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args, kwargs)
                 else
                   raise e
                 end