debug_logging 3.1.8 → 3.1.9

data/lib/debug_logging/argument_printer.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
+require "date"
+require "time"
+
 module DebugLogging
   module ArgumentPrinter
     def debug_benchmark_to_s(tms:)
-      "completed in #{format('%f', tms.real)}s (#{format('%f', tms.total)}s CPU)"
+      "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
+      return "" unless args && config_proxy
 
       if config_proxy.debug_add_invocation_id
-        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..-4]}~"
+        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % "%#-21a")[4..-4]}~"
         case config_proxy.debug_add_invocation_id
         when true
           invocation
@@ -18,30 +21,47 @@ module DebugLogging
           config_proxy.debug_add_invocation_id.call(ColorizedString[invocation])
         end
       else
-        ''
+        ""
+      end
+    end
+
+    def debug_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
     end
 
     def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
-      return '' unless config_proxy
+      return "" unless config_proxy
 
       klass_string = if config_proxy.debug_colorized_chain_for_class
-                       config_proxy.debug_colorized_chain_for_class.call(ColorizedString[klass.to_s])
-                     else
-                       klass.to_s
-                     end
+        config_proxy.debug_colorized_chain_for_class.call(ColorizedString[klass.to_s])
+      else
+        klass.to_s
+      end
       method_string = if config_proxy.debug_colorized_chain_for_method
-                        config_proxy.debug_colorized_chain_for_method.call(ColorizedString[method_to_log.to_s])
-                      else
-                        method_to_log.to_s
-                      end
+        config_proxy.debug_colorized_chain_for_method.call(ColorizedString[method_to_log.to_s])
+      else
+        method_to_log.to_s
+      end
       "#{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
+      return "" unless args && config_proxy
 
-      printed_args = ''
+      printed_args = ""
 
       add_args_ellipsis = false
       if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
@@ -52,18 +72,18 @@ module DebugLogging
               arg.is_a?(Hash)
             end
             other_args_string = if config_proxy.debug_args_to_s_proc
-                                  printed, add_other_args_ellipsis = debug_safe_proc(
-                                    proc_name:'args_to_s_proc',
-                                    proc: config_proxy.debug_args_to_s_proc,
-                                    args: other_args,
-                                    max_length: config_proxy.debug_args_max_length
-                                  )
-                                  printed
-                                else
-                                  other_args.map(&:inspect).join(', ').tap do |x|
-                                    add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
-                                  end[0..(config_proxy.debug_args_max_length)]
-                                end
+              printed, add_other_args_ellipsis = debug_safe_proc(
+                proc_name: "args_to_s_proc",
+                proc: config_proxy.debug_args_to_s_proc,
+                args: other_args,
+                max_length: config_proxy.debug_args_max_length,
+              )
+              printed
+            else
+              other_args.map(&:inspect).join(", ").tap do |x|
+                add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
+              end[0..(config_proxy.debug_args_max_length)]
+            end
             other_args_string += config_proxy.debug_ellipsis if add_other_args_ellipsis
             # On the debug_multiple_last_hashes truthy branch we don't print the ellipsis after regular args
             #   because it will go instead after each of the last hashes (if needed)
@@ -71,73 +91,73 @@ module DebugLogging
             last_hash_args_string = last_hash_args.map do |arg|
               arr = []
               printed, add_last_hash_ellipsis = debug_safe_proc(
-                proc_name:'last_hash_to_s_proc',
+                proc_name: "last_hash_to_s_proc",
                 proc: config_proxy.debug_last_hash_to_s_proc,
                 args: arg,
-                max_length: config_proxy.debug_last_hash_max_length
+                max_length: config_proxy.debug_last_hash_max_length,
               )
               printed += config_proxy.debug_ellipsis if add_last_hash_ellipsis
               arr << printed
               arr
-            end.flatten.join(', ')
+            end.flatten.join(", ")
             printed_args += other_args_string if other_args_string
-            printed_args += ', ' if !other_args_string.empty? && !last_hash_args_string.empty?
+            printed_args += ", " if !other_args_string.empty? && !last_hash_args_string.empty?
             printed_args += last_hash_args_string if last_hash_args_string && !last_hash_args_string.empty?
           else
             other_args = args[0..-2]
             other_args_string = if config_proxy.debug_args_to_s_proc
-                                  printed, add_other_args_ellipsis = debug_safe_proc(
-                                    proc_name:'args_to_s_proc',
-                                    proc: config_proxy.debug_args_to_s_proc,
-                                    args: other_args,
-                                    max_length: config_proxy.debug_args_max_length
-                                  )
-                                  printed
-                                else
-                                  other_args.map(&:inspect).join(', ').tap do |x|
-                                    add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
-                                  end[0..(config_proxy.debug_args_max_length)]
-                                end
+              printed, add_other_args_ellipsis = debug_safe_proc(
+                proc_name: "args_to_s_proc",
+                proc: config_proxy.debug_args_to_s_proc,
+                args: other_args,
+                max_length: config_proxy.debug_args_max_length,
+              )
+              printed
+            else
+              other_args.map(&:inspect).join(", ").tap do |x|
+                add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
+              end[0..(config_proxy.debug_args_max_length)]
+            end
             other_args_string += config_proxy.debug_ellipsis if add_other_args_ellipsis
             printed_args += other_args_string
             printed, add_last_hash_ellipsis = debug_safe_proc(
-              proc_name:'last_hash_to_s_proc',
+              proc_name: "last_hash_to_s_proc",
               proc: config_proxy.debug_last_hash_to_s_proc,
               args: args[-1],
-              max_length: config_proxy.debug_last_hash_max_length
+              max_length: config_proxy.debug_last_hash_max_length,
             )
             printed_args += ", #{printed}"
             printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
           end
         else
           printed, add_last_hash_ellipsis = debug_safe_proc(
-            proc_name:'last_hash_to_s_proc',
+            proc_name: "last_hash_to_s_proc",
             proc: config_proxy.debug_last_hash_to_s_proc,
             args: args[0],
-            max_length: config_proxy.debug_last_hash_max_length
+            max_length: config_proxy.debug_last_hash_max_length,
           )
           printed_args += printed
           printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
         end
       else
         printed_args += if config_proxy.debug_args_to_s_proc
-                          printed, add_args_ellipsis = debug_safe_proc(
-                            proc_name:'args_to_s_proc',
-                            proc: config_proxy.debug_args_to_s_proc,
-                            args: args,
-                            max_length: config_proxy.debug_args_max_length
-                          )
-                          printed
-                        elsif args.length == 1 && args[0].is_a?(Hash)
-                          # handle double splat
-                          ("**#{args.map(&:inspect).join(', ').tap do |x|
-                                  add_args_ellipsis = x.length > config_proxy.debug_args_max_length
-                                end }")[0..(config_proxy.debug_args_max_length)]
-                        else
-                          args.map(&:inspect).join(', ').tap do |x|
-                            add_args_ellipsis = x.length > config_proxy.debug_args_max_length
-                          end[0..(config_proxy.debug_args_max_length)]
-                        end
+          printed, add_args_ellipsis = debug_safe_proc(
+            proc_name: "args_to_s_proc",
+            proc: config_proxy.debug_args_to_s_proc,
+            args: args,
+            max_length: config_proxy.debug_args_max_length,
+          )
+          printed
+        elsif args.length == 1 && args[0].is_a?(Hash)
+          # handle double splat
+          "**#{args.map(&:inspect).join(", ").tap do |x|
+                 add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+               end }"[0..(config_proxy.debug_args_max_length)]
+        else
+          args.map(&:inspect).join(", ").tap do |x|
+            add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+          end[0..(config_proxy.debug_args_max_length)]
+        end
         printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
       end
       "(#{printed_args})"
@@ -149,34 +169,30 @@ module DebugLogging
         add_ellipsis = false
         printed = String(proc.call(args)).tap do |x|
           add_ellipsis = x.length > max_length
-        end[0..(max_length)]
-        return printed, add_ellipsis
-      rescue => e
-        return "#{e.class}: #{e.message}\nPlease check that your #{proc_name} is able to handle #{args}", false
+        end[0..max_length]
+        [printed, add_ellipsis]
+      rescue StandardError => e
+        ["#{e.class}: #{e.message}\nPlease check that your #{proc_name} is able to handle #{args}", false]
       end
     end
 
     def debug_payload_to_s(payload: nil, config_proxy: nil)
-      return '' unless payload && config_proxy
+      return "" unless payload && config_proxy
 
-      if payload
-        case config_proxy.debug_add_payload
-        when true
-          payload.inspect
-        else
-          printed_payload = ""
-          printed, add_payload_ellipsis = debug_safe_proc(
-            proc_name: "add_payload",
-            proc: config_proxy.debug_add_payload,
-            args: payload,
-            max_length: config_proxy.payload_max_length
-          )
-          printed_payload += printed
-          printed_payload += config_proxy.debug_ellipsis if add_payload_ellipsis
-          printed_payload
-        end
+      case config_proxy.debug_add_payload
+      when true
+        payload.inspect
       else
-        ''
+        printed_payload = ""
+        printed, add_payload_ellipsis = debug_safe_proc(
+          proc_name: "add_payload",
+          proc: config_proxy.debug_add_payload,
+          args: payload,
+          max_length: config_proxy.payload_max_length,
+        )
+        printed_payload += printed
+        printed_payload += config_proxy.debug_ellipsis if add_payload_ellipsis
+        printed_payload
       end
     end
 

data/lib/debug_logging/class_logger.rb

@@ -6,13 +6,13 @@ module DebugLogging
       methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
         method_names: methods_to_log,
         payload: nil,
-        config: nil
+        config: nil,
       )
       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
+          config: config_opts,
         )
         original_method = method(method_to_log)
         (class << self; self; end).class_eval do
@@ -21,16 +21,20 @@ module DebugLogging
               scope: self,
               config_opts: method_config_opts,
               method_name: method_to_log,
-              proxy_ref: 'kl'
+              proxy_ref: "kl",
             )
             method_return_value = nil
             log_prefix = nil
             invocation_id = nil
             begin
               config_proxy.log do
-                paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
-                log_prefix = debug_invocation_to_s(klass: to_s, separator: '.', method_to_log: method_to_log,
-                                                   config_proxy: config_proxy)
+                paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
+                log_prefix = debug_invocation_to_s(
+                  klass: to_s,
+                  separator: ".",
+                  method_to_log: method_to_log,
+                  config_proxy: config_proxy,
+                )
                 invocation_id = debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
                 signature = debug_signature_to_s(args: args, config_proxy: config_proxy)
                 paymud = debug_payload_to_s(payload: paydirt, config_proxy: config_proxy)
@@ -39,20 +43,20 @@ module DebugLogging
               if config_proxy.benchmarkable_for?(:debug_class_benchmarks)
                 tms = Benchmark.measure do
                   method_return_value = if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
-                                          original_method.call(**harsh, &block)
-                                        else
-                                          original_method.call(*args, &block)
-                                        end
+                    original_method.call(**harsh, &block)
+                  else
+                    original_method.call(*args, &block)
+                  end
                 end
                 config_proxy.log do
                   "#{log_prefix} #{debug_benchmark_to_s(tms: tms)}#{invocation_id}"
                 end
               else
                 method_return_value = if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
-                                        original_method.call(**harsh, &block)
-                                      else
-                                        original_method.call(*args, &block)
-                                      end
+                  original_method.call(**harsh, &block)
+                else
+                  original_method.call(*args, &block)
+                end
                 if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
                   config_proxy.log do
                     "#{log_prefix} completed#{invocation_id}"
@@ -60,11 +64,11 @@ module DebugLogging
                 end
               end
               method_return_value
-            rescue => error
+            rescue StandardError => e
               if config_proxy.error_handler_proc
-                config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_log, args)
+                config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args)
               else
-                raise error
+                raise e
               end
             end
           end

data/lib/debug_logging/class_notifier.rb

@@ -6,13 +6,13 @@ module DebugLogging
       methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
         method_names: methods_to_notify,
         payload: nil,
-        config: nil
+        config: nil,
       )
       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
+          config: config_opts,
         )
         original_method = method(method_to_notify)
         (class << self; self; end).class_eval do
@@ -21,24 +21,24 @@ module DebugLogging
               scope: self,
               config_opts: method_config_opts,
               method_name: method_to_notify,
-              proxy_ref: 'kn'
+              proxy_ref: "kn",
             ) do |proxy|
               ActiveSupport::Notifications.subscribe(
-                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify)
+                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
               ) do |*debug_args|
                 proxy.log do
                   DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*debug_args))
                 end
               end
             end
-            paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
+            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
-              }
+                **paydirt,
+              },
             ) do
               begin
                 if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
@@ -46,11 +46,11 @@ module DebugLogging
                 else
                   original_method.call(*args, &block)
                 end
-              rescue => error
+              rescue StandardError => e
                 if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_notify, args)
+                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args)
                 else
-                  raise error
+                  raise e
                 end
               end
             end

data/lib/debug_logging/configuration.rb

@@ -18,7 +18,7 @@ module DebugLogging
     #           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.id}" }
+    #           args_to_s_proc: nil # e.g. ->(*record) { "record id: #{record.first.id}" }
     #           args_max_length: 1_000
     #           instance_benchmarks: false
     #           class_benchmarks: false
@@ -79,17 +79,17 @@ module DebugLogging
     end
 
     def instance_benchmarks=(instance_benchmarks)
-      require 'benchmark' if instance_benchmarks
+      require "benchmark" if instance_benchmarks
       @instance_benchmarks = instance_benchmarks
     end
 
     def class_benchmarks=(class_benchmarks)
-      require 'benchmark' if class_benchmarks
+      require "benchmark" if class_benchmarks
       @class_benchmarks = class_benchmarks
     end
 
     def active_support_notifications=(active_support_notifications)
-      require 'debug_logging/active_support_notifications' if active_support_notifications
+      require "debug_logging/active_support_notifications" if active_support_notifications
       @active_support_notifications = active_support_notifications
     end
 

data/lib/debug_logging/constants.rb

@@ -2,7 +2,7 @@
 
 module DebugLogging
   module Constants
-    DEFAULT_ELLIPSIS = ' ✂️ …'
+    DEFAULT_ELLIPSIS = " ✂️ …"
     CONFIG_ATTRS_DEFAULTS = {
       enabled: true,
       logger: Logger.new($stdout),
@@ -19,13 +19,13 @@ module DebugLogging
       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
+      error_handler_proc: nil,
     }.freeze
     CONFIG_ATTRS = CONFIG_ATTRS_DEFAULTS.keys
     CONFIG_READERS_DEFAULTS = {
       instance_benchmarks: false,
       class_benchmarks: false,
-      active_support_notifications: false
+      active_support_notifications: false,
     }.freeze
     CONFIG_READERS = CONFIG_READERS_DEFAULTS.keys
     CONFIG_KEYS = CONFIG_ATTRS + CONFIG_READERS

data/lib/debug_logging/finalize.rb

@@ -10,7 +10,7 @@ module DebugLogging
           if obj.respond_to?(:debug_finalize)
             obj.debug_finalize
           else
-            warn "#{obj} does not define a debug_finalize"
+            warn("#{obj} does not define a debug_finalize")
           end
           t.disable
         end

data/lib/debug_logging/hooks.rb

@@ -1,5 +1,5 @@
-require 'debug_logging/errors'
-require 'timeout'
+require "debug_logging/errors"
+require "timeout"
 
 module DebugLogging
   module Hooks
@@ -21,7 +21,7 @@ module DebugLogging
                 meth.bind(self).call(*args, &block)
               end
             rescue Timeout::Error
-              error_args = [TimeoutError, 'execution expired', caller]
+              error_args = [TimeoutError, "execution expired", caller]
               raise(*error_args) unless blk
 
               instance_exec(*error_args, &blk)
@@ -33,8 +33,8 @@ module DebugLogging
       def debug_rescue_on_fail(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.rescue_on_fail must be called with a block',
-                caller
+            ".rescue_on_fail must be called with a block",
+            caller
         end
         names.each do |name|
           meth = instance_method(name)
@@ -51,12 +51,12 @@ module DebugLogging
       def debug_before(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.before must be called with a block',
-                caller
+            ".before must be called with a block",
+            caller
         end
         names.each do |name|
           meth = instance_method(name)
-          define_method name do |*args, &block|
+          define_method(name) do |*args, &block|
             instance_exec(name, *args, block, &blk)
             meth.bind(self).call(*args, &block)
           end
@@ -66,12 +66,12 @@ module DebugLogging
       def debug_after(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.after must be called with a block',
-                caller
+            ".after must be called with a block",
+            caller
         end
         names.each do |name|
           meth = instance_method(name)
-          define_method name do |*args, &block|
+          define_method(name) do |*args, &block|
             result = meth.bind(self).call(*args, &block)
             instance_exec(result, &blk)
           end

data/lib/debug_logging/instance_logger.rb

@@ -13,9 +13,11 @@ module DebugLogging
       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)
+      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(
+        methods_to_log: @instance_methods_to_log,
+        payload: @payload,
+        config: @config,
+      )
       base.send(:prepend, instance_method_logger)
     end
   end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -7,13 +7,13 @@ module DebugLogging
         methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
           method_names: Array(methods_to_log),
           payload: payload,
-          config: config
+          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
+            config: config_opts,
           )
           define_method(method_to_log) do |*args, &block|
             method_return_value = nil
@@ -21,13 +21,17 @@ module DebugLogging
               scope: self.class,
               config_opts: method_config_opts,
               method_name: method_to_log,
-              proxy_ref: 'ilm'
+              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,
             )
-            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_vaiable_hydration(scope: self, payload: method_payload)
+              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}"
@@ -42,11 +46,11 @@ module DebugLogging
             else
               begin
                 method_return_value = super(*args, &block)
-              rescue => error
+              rescue StandardError => e
                 if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_log, args)
+                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args)
                 else
-                  raise error
+                  raise e
                 end
               end
               if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?

data/lib/debug_logging/instance_notifier.rb

@@ -13,9 +13,11 @@ module DebugLogging
       return unless @instance_methods_to_notify
 
       base.send(:include, ArgumentPrinter)
-      instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(methods_to_notify: @instance_methods_to_notify,
-                                                                                payload: @payload,
-                                                                                config: @config)
+      instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(
+        methods_to_notify: @instance_methods_to_notify,
+        payload: @payload,
+        config: @config,
+      )
       base.send(:prepend, instance_method_notifier)
     end
   end