debug_logging 4.0.1 → 4.0.3

data/RUBOCOP.md

@@ -0,0 +1,71 @@
+# RuboCop Usage Guide
+
+## Overview
+
+A tale of two RuboCop plugin gems.
+
+### RuboCop Gradual
+
+This project uses `rubocop_gradual` instead of vanilla RuboCop for code style checking. The `rubocop_gradual` tool allows for gradual adoption of RuboCop rules by tracking violations in a lock file.
+
+### RuboCop LTS
+
+This project uses `rubocop-lts` to ensure, on a best-effort basis, compatibility with Ruby >= 1.9.2.
+RuboCop rules are meticulously configured by the `rubocop-lts` family of gems to ensure that a project is compatible with a specific version of Ruby. See: https://rubocop-lts.gitlab.io for more.
+
+## Checking RuboCop Violations
+
+To check for RuboCop violations in this project, always use:
+
+```bash
+bundle exec rake rubocop_gradual:check
+```
+
+**Do not use** the standard RuboCop commands like:
+- `bundle exec rubocop`
+- `rubocop`
+
+## Understanding the Lock File
+
+The `.rubocop_gradual.lock` file tracks all current RuboCop violations in the project. This allows the team to:
+
+1. Prevent new violations while gradually fixing existing ones
+2. Track progress on code style improvements
+3. Ensure CI builds don't fail due to pre-existing violations
+
+## Common Commands
+
+- **Check violations**
+    - `bundle exec rake rubocop_gradual`
+    - `bundle exec rake rubocop_gradual:check`
+- **(Safe) Autocorrect violations, and update lockfile if no new violations**
+  - `bundle exec rake rubocop_gradual:autocorrect`
+- **Force update the lock file (w/o autocorrect) to match violations present in code**
+  - `bundle exec rake rubocop_gradual:force_update`
+
+## Workflow
+
+1. Before submitting a PR, run `bundle exec rake rubocop_gradual:autocorrect`
+   a. or just the default `bundle exec rake`, as autocorrection is a pre-requisite of the default task.
+2. If there are new violations, either:
+   - Fix them in your code
+   - Run `bundle exec rake rubocop_gradual:force_update` to update the lock file (only for violations you can't fix immediately)
+3. Commit the updated `.rubocop_gradual.lock` file along with your changes
+
+## Never add inline RuboCop disables
+
+Do not add inline `rubocop:disable` / `rubocop:enable` comments anywhere in the codebase (including specs, except when following the few existing `rubocop:disable` patterns for a rule already being disabled elsewhere in the code). We handle exceptions in two supported ways:
+
+- Permanent/structural exceptions: prefer adjusting the RuboCop configuration (e.g., in `.rubocop.yml`) to exclude a rule for a path or file pattern when it makes sense project-wide.
+- Temporary exceptions while improving code: record the current violations in `.rubocop_gradual.lock` via the gradual workflow:
+  - `bundle exec rake rubocop_gradual:autocorrect` (preferred; will autocorrect what it can and update the lock only if no new violations were introduced)
+  - If needed, `bundle exec rake rubocop_gradual:force_update` (as a last resort when you cannot fix the newly reported violations immediately)
+
+In general, treat the rules as guidance to follow; fix violations rather than ignore them. For example, RSpec conventions in this project expect `described_class` to be used in specs that target a specific class under test.
+
+## Benefits of rubocop_gradual
+
+- Allows incremental adoption of code style rules
+- Prevents CI failures due to pre-existing violations
+- Provides a clear record of code style debt
+- Enables focused efforts on improving code quality over time

data/SECURITY.md

@@ -2,15 +2,20 @@
 
 ## Supported Versions
 
-| Version | Supported |
-|---------|-----------|
-| 4.x     | ✅         |
-| 3.x     | ❌         |
-| 2.x     | ❌         |
-| 1.x     | ❌         |
+| Version  | Supported |
+|----------|-----------|
+| 1.latest | ✅         |
 
-## Reporting a Vulnerability
+## Security contact information
 
-Peter Boling is the primary maintainer of this gem. Please find a way
-to [contact him directly](https://railsbling.com/contact) to report the issue. Include as much relevant information as
-possible.
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+## Additional Support
+
+If you are interested in support for versions older than the latest release,
+please consider sponsoring the project / maintainer @ https://liberapay.com/pboling/donate,
+or find other sponsorship links in the [README].
+
+[README]: README.md

data/certs/pboling.pem

@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
+ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+A2NvbTAeFw0yNTA1MDQxNTMzMDlaFw00NTA0MjkxNTMzMDlaMEMxFTATBgNVBAMM
+DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAruUoo0WA
+uoNuq6puKWYeRYiZekz/nsDeK5x/0IEirzcCEvaHr3Bmz7rjo1I6On3gGKmiZs61
+LRmQ3oxy77ydmkGTXBjruJB+pQEn7UfLSgQ0xa1/X3kdBZt6RmabFlBxnHkoaGY5
+mZuZ5+Z7walmv6sFD9ajhzj+oIgwWfnEHkXYTR8I6VLN7MRRKGMPoZ/yvOmxb2DN
+coEEHWKO9CvgYpW7asIihl/9GMpKiRkcYPm9dGQzZc6uTwom1COfW0+ZOFrDVBuV
+FMQRPswZcY4Wlq0uEBLPU7hxnCL9nKK6Y9IhdDcz1mY6HZ91WImNslOSI0S8hRpj
+yGOWxQIhBT3fqCBlRIqFQBudrnD9jSNpSGsFvbEijd5ns7Z9ZMehXkXDycpGAUj1
+to/5cuTWWw1JqUWrKJYoifnVhtE1o1DZ+LkPtWxHtz5kjDG/zR3MG0Ula0UOavlD
+qbnbcXPBnwXtTFeZ3C+yrWpE4pGnl3yGkZj9SMTlo9qnTMiPmuWKQDatAgMBAAGj
+fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQE8uWvNbPVNRXZ
+HlgPbc2PCzC4bjAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
+ggGBAJbnUwfJQFPkBgH9cL7hoBfRtmWiCvdqdjeTmi04u8zVNCUox0A4gT982DE9
+wmuN12LpdajxZONqbXuzZvc+nb0StFwmFYZG6iDwaf4BPywm2e/Vmq0YG45vZXGR
+L8yMDSK1cQXjmA+ZBKOHKWavxP6Vp7lWvjAhz8RFwqF9GuNIdhv9NpnCAWcMZtpm
+GUPyIWw/Cw/2wZp74QzZj6Npx+LdXoLTF1HMSJXZ7/pkxLCsB8m4EFVdb/IrW/0k
+kNSfjtAfBHO8nLGuqQZVH9IBD1i9K6aSs7pT6TW8itXUIlkIUI2tg5YzW6OFfPzq
+QekSkX3lZfY+HTSp/o+YvKkqWLUV7PQ7xh1ZYDtocpaHwgxe/j3bBqHE+CUPH2vA
+0V/FwdTRWcwsjVoOJTrYcff8pBZ8r2MvtAc54xfnnhGFzeRHfcltobgFxkAXdE6p
+DVjBtqT23eugOqQ73umLcYDZkc36vnqGxUBSsXrzY9pzV5gGr2I8YUxMqf6ATrZt
+L9nRqA==
+-----END CERTIFICATE-----

data/lib/debug_logging/argument_printer.rb

@@ -8,7 +8,8 @@ module DebugLogging
     end
 
     def debug_invocation_id_to_s(args: nil, kwargs: nil, start_at: nil, config_proxy: nil)
-      return "" unless (args || kwargs) && config_proxy
+      return "" unless config_proxy
+      return "" unless args || kwargs
 
       if config_proxy.debug_add_invocation_id
         time = start_at ? Util.debug_time(start_at) : Time.now
@@ -46,7 +47,7 @@ module DebugLogging
       DebugLogging::Constants::EVENT_TIME_FORMATTER.call(time)
     end
 
-    def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
+    def debug_invocation_to_s(klass: nil, separator: nil, decorated_method: nil, config_proxy: nil)
       return "" unless config_proxy
 
       klass_string = if config_proxy.debug_colorized_chain_for_class
@@ -55,21 +56,22 @@ module DebugLogging
         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])
+        config_proxy.debug_colorized_chain_for_method.call(ColorizedString[decorated_method.to_s])
       else
-        method_to_log.to_s
+        decorated_method.to_s
       end
       "#{klass_string}#{separator}#{method_string}"
     end
 
     def debug_signature_to_s(args: nil, kwargs: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity
-      return "" unless (args || kwargs) && config_proxy
+      return "" unless config_proxy
+      return "" unless args || kwargs
 
       printed_args = ""
 
       add_args_ellipsis = false
       args = args.dup
-      args.push(kwargs) if kwargs
+      args.push(kwargs) if kwargs&.keys && !kwargs&.keys&.length&.zero?
       if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
         add_other_args_ellipsis = false
         if args.length > 1
@@ -86,7 +88,7 @@ module DebugLogging
               )
               printed
             else
-              other_args.map(&:inspect).join(", ").tap do |x|
+              debug_args_to_s(other_args).tap do |x|
                 add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
               end[0..(config_proxy.debug_args_max_length)]
             end
@@ -120,7 +122,7 @@ module DebugLogging
               )
               printed
             else
-              other_args.map(&:inspect).join(", ").tap do |x|
+              debug_args_to_s(other_args).tap do |x|
                 add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
               end[0..(config_proxy.debug_args_max_length)]
             end
@@ -156,11 +158,11 @@ module DebugLogging
           printed
         elsif args.length == 1 && args[0].is_a?(Hash)
           # handle double splat
-          "**#{args.map(&:inspect).join(", ").tap do |x|
+          "**#{debug_args_to_s(args).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|
+          debug_args_to_s(args).tap do |x|
             add_args_ellipsis = x.length > config_proxy.debug_args_max_length
           end[0..(config_proxy.debug_args_max_length)]
         end
@@ -187,7 +189,7 @@ module DebugLogging
 
       case config_proxy.debug_add_payload
       when true
-        payload.inspect
+        debug_value_to_s(payload)
       else
         printed_payload = ""
         printed, add_payload_ellipsis = debug_safe_proc(
@@ -204,8 +206,27 @@ module DebugLogging
 
     module_function
 
-    def debug_event_name_to_s(method_to_notify: nil)
-      "#{method_to_notify}.log"
+    def debug_args_to_s(args)
+      args.map { |arg| debug_value_to_s(arg) }.join(", ")
+    end
+
+    def debug_value_to_s(value)
+      case value
+      when Hash
+        "{#{value.map { |key, inner_value| "#{debug_hash_key_to_s(key)}: #{debug_value_to_s(inner_value)}" }.join(", ")}}"
+      when Array
+        "[#{value.map { |inner_value| debug_value_to_s(inner_value) }.join(", ")}]"
+      else
+        value.inspect
+      end
+    end
+
+    def debug_hash_key_to_s(key)
+      key.is_a?(Symbol) ? key.to_s : key.inspect
+    end
+
+    def debug_event_name_to_s(decorated_method: nil)
+      "#{decorated_method}.log"
     end
   end
 end

data/lib/debug_logging/class_logger.rb

@@ -1,72 +1,42 @@
 module DebugLogging
   module ClassLogger
+    class << self
+      def extended(base)
+        base.extend(LambDartable::Log)
+      end
+    end
+
     def 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,
       )
-      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,
+      Array(methods_to_log).each do |decorated_method|
+        decorated_method, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: decorated_method,
           payload: payload,
           config: config_opts,
         )
-        original_method = method(method_to_log)
+        original_method = method(decorated_method)
         (class << self; self; end).class_eval do
-          define_method(method_to_log) do |*args, &block|
-            config_proxy = DebugLogging::Util.config_proxy_finder(
-              scope: self,
-              config_opts: method_config_opts,
-              method_name: method_to_log,
-              proxy_ref: "kl",
+          define_method(decorated_method) do |*args, **kwargs, &block|
+            lamb_dart = LambDart::Log.new(
+              klass: self,
+              method_config_opts:,
+              method_payload:,
+              args:,
+              kwargs:,
+              decorated_method:,
             )
-            method_return_value = nil
-            log_prefix = nil
-            invocation_id = nil
-            begin
-              config_proxy.log do
-                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)
-                "#{log_prefix}#{signature}#{invocation_id} debug: #{paymud}"
-              end
-              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
-                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
-                if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
-                  config_proxy.log do
-                    "#{log_prefix} completed#{invocation_id}"
-                  end
-                end
-              end
-              method_return_value
-            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
+            real_mccoy = ->() {
+              original_method.call(*args, **kwargs, &block)
+            }
+            _dl_ld_enter_log(lamb_dart) do
+              _dl_ld_error_handle(lamb_dart) do
+                return _dl_ld_benchmarked(lamb_dart) { real_mccoy.call } if lamb_dart.bench?
+
+                _dl_ld_exit_log(lamb_dart) { real_mccoy.call }
               end
             end
           end

data/lib/debug_logging/class_notifier.rb

@@ -1,53 +1,37 @@
 module DebugLogging
   module ClassNotifier
+    class << self
+      def extended(base)
+        base.extend(LambDartable::Note)
+      end
+    end
+
     def notified(*methods_to_notify)
       methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
         method_names: methods_to_notify,
         payload: 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,
+      Array(methods_to_notify).each do |decorated_method|
+        decorated_method, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: decorated_method,
           payload: payload,
           config: config_opts,
         )
-        original_method = method(method_to_notify)
+        original_method = method(decorated_method)
         (class << self; self; end).class_eval do
-          define_method(method_to_notify) do |*args, &block|
-            config_proxy = DebugLogging::Util.config_proxy_finder(
-              scope: self,
-              config_opts: method_config_opts,
-              method_name: method_to_notify,
-              proxy_ref: "kn",
-            ) do |proxy|
-              ActiveSupport::Notifications.subscribe(
-                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_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
-              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
+          define_method(decorated_method) do |*args, **kwargs, &block|
+            lamb_dart = LambDart::Note.new(
+              klass: self,
+              method_config_opts:,
+              method_payload:,
+              args:,
+              kwargs:,
+              decorated_method:,
+            )
+            _dl_ld_notify(lamb_dart) do
+              _dl_ld_error_handle(lamb_dart) do
+                original_method.call(*args, **kwargs, &block)
               end
             end
           end

data/lib/debug_logging/colorized_string.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  class ColorizedString < String
+    FOREGROUND_CODES = {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+      light_black: 90,
+      light_red: 91,
+      light_green: 92,
+      light_yellow: 93,
+      light_blue: 94,
+      light_magenta: 95,
+      light_cyan: 96,
+      light_white: 97,
+      default: 39,
+    }.freeze
+    BACKGROUND_CODES = FOREGROUND_CODES.transform_values { |code| code + 10 }.merge(default: 49).freeze
+    FORMAT_CODES = {
+      bold: 1,
+      italic: 3,
+      underline: 4,
+      blink: 5,
+      reverse_color: 7,
+      conceal: 8,
+      hide: 8,
+      strikethrough: 9,
+      double_underline: 21,
+    }.freeze
+
+    class << self
+      def [](value)
+        new(value.to_s)
+      end
+    end
+
+    def initialize(value, foreground: nil, background: nil, formats: [])
+      @raw = value.to_s
+      @foreground = foreground
+      @background = background
+      @formats = formats.dup
+      super(render)
+    end
+
+    def colorize(color = nil, options = {})
+      options = color if color.is_a?(Hash)
+      foreground = options.fetch(:color, nil) || options.fetch("color", nil)
+      foreground ||= color unless color.is_a?(Hash)
+      background = options.fetch(:background, nil) || options.fetch("background", nil)
+      formats = Array(options[:mode]) + Array(options[:modes])
+
+      self.class.new(
+        @raw,
+        foreground: foreground ? normalized_color(foreground) : @foreground,
+        background: background ? normalized_color(background) : @background,
+        formats: merge_formats(formats),
+      )
+    end
+
+    def colorized?
+      @foreground || @background || @formats.any?
+    end
+
+    def uncolorize
+      @raw.dup
+    end
+
+    FOREGROUND_CODES.each_key do |color|
+      next if color == :default
+
+      define_method(color) do
+        colorize(color)
+      end
+
+      define_method(:"on_#{color}") do
+        colorize(background: color)
+      end
+    end
+    alias_method :on_gray, :on_light_black
+    alias_method :on_grey, :on_light_black
+
+    FORMAT_CODES.each_key do |format|
+      define_method(format) do
+        self.class.new(@raw, foreground: @foreground, background: @background, formats: merge_formats([format]))
+      end
+    end
+
+    private
+
+    def background_code
+      BACKGROUND_CODES.fetch(@background, 49)
+    end
+
+    def foreground_code
+      FOREGROUND_CODES.fetch(@foreground, 39)
+    end
+
+    def style_codes
+      format_codes = @formats.map { |format| FORMAT_CODES.fetch(format) }
+      format_codes = [0] if format_codes.empty?
+      [*format_codes, foreground_code, background_code]
+    end
+
+    def normalized_color(color)
+      color.to_s.tr(" ", "_").downcase.to_sym
+    end
+
+    def merge_formats(formats)
+      normalized_formats = formats.filter_map do |format|
+        normalized = format.to_sym
+        normalized if FORMAT_CODES.key?(normalized)
+      end
+      @formats | normalized_formats
+    end
+
+    def render
+      return @raw.dup unless colorized?
+
+      "\e[#{style_codes.join(";")}m#{@raw}\e[0m"
+    end
+  end
+end
+
+ColorizedString = DebugLogging::ColorizedString unless Object.const_defined?(:ColorizedString)

data/lib/debug_logging/configuration.rb

@@ -1,6 +1,7 @@
 module DebugLogging
   class Configuration
     include Constants
+
     # For reference, log levels as integers mapped to symbols:
     # LEVELS = { 0 => :debug, 1 => :info, 2 => :warn, 3 => :error, 4 => :fatal, 5 => :unknown }
     attr_accessor(*CONFIG_ATTRS)
@@ -38,11 +39,11 @@ module DebugLogging
     end
 
     class << self
-      def config_pointer(type, method_to_log)
+      def config_pointer(type, decorated_method)
         # Methods names that do not match the following regex can't be part of an ivar name
         #   /[a-zA-Z_][a-zA-Z0-9_]*/
         # Thus we have to use a different form of the method name that is compatible with ivar name conventions
-        "@debug_logging_config_#{type}_#{Digest::MD5.hexdigest(method_to_log.to_s)}".to_sym
+        "@debug_logging_config_#{type}_#{Digest::MD5.hexdigest(decorated_method.to_s)}".to_sym
       end
     end
 

data/lib/debug_logging/finalize.rb

@@ -2,15 +2,17 @@
 # License: https://creativecommons.org/licenses/by-sa/4.0/
 module DebugLogging
   module Finalize
-    def self.extended(obj)
-      TracePoint.trace(:end) do |t|
-        if obj == t.self
-          if obj.respond_to?(:debug_finalize)
-            obj.debug_finalize
-          else
-            warn("#{obj} does not define a debug_finalize")
+    class << self
+      def extended(obj)
+        TracePoint.trace(:end) do |t|
+          if obj == t.self
+            if obj.respond_to?(:debug_finalize)
+              obj.debug_finalize
+            else
+              warn("#{obj} does not define a debug_finalize")
+            end
+            t.disable
           end
-          t.disable
         end
       end
     end

data/lib/debug_logging/hooks.rb

@@ -3,12 +3,14 @@ require "timeout"
 
 module DebugLogging
   module Hooks
-    def self.included(mod)
-      mod.extend(ClassMethods)
-    end
+    class << self
+      def included(mod)
+        mod.extend(ClassMethods)
+      end
 
-    def self.extend(mod)
-      mod.extend(ClassMethods)
+      def extended(mod)
+        mod.extend(ClassMethods)
+      end
     end
 
     module ClassMethods

data/lib/debug_logging/instance_logger.rb

@@ -1,5 +1,11 @@
 module DebugLogging
   module InstanceLogger
+    class << self
+      def extended(base)
+        base.include(LambDartable::Log)
+      end
+    end
+
     # 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
@@ -29,9 +35,9 @@ module DebugLogging
         config: nil,
       )
       instance_method_modules =
-        Array(methods_to_log).map do |method_to_log|
+        Array(methods_to_log).map do |decorated_method|
           DebugLogging::InstanceLoggerModulizer.to_mod(
-            methods_to_log: Array(method_to_log),
+            methods_to_log: Array(decorated_method),
             payload: payload,
             config: config_opts,
           )