debug_logging 4.0.1 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca22c0dbc789a56d7f02d3ef685d92fb0423592bde3fccaa733afcd577c88a78
-  data.tar.gz: 279bdd5ecde603ff0be14ec128bea893a05a53d0d4c0f42fbdb6663964fff178
+  metadata.gz: c5059baba71c02b6f460a6cc3badf9871441b16e926afe59636ad7ef2f8b907c
+  data.tar.gz: 9ac589b2e46cd7f439f45751c50404e09bf07f0cc2b5e9713b93d83338e2f5e6
 SHA512:
-  metadata.gz: 352720fb350ee3c404f64b631c6f27f178ca8bb07b66e779cb26a66077708df9e716f7b0ef49e80035f44a45bc8081e436f420a14ac07f17d44a6b7e67ba46d1
-  data.tar.gz: 5effc5e2ef194e6e90c9c57f3378523a6fda0d5ab2b4d5fd7c4161bc542385b9796cfef56f015a756a75ead1969bb83f94c81d3dc4ba54607b7d9e2adab4c46f
+  metadata.gz: ed2fdd91670149c07f1ef0c118fda035b858b63cbe87d7d09000c18ab14f4133bf37a340ad11ec0c851be4bd2f1e2b807444a21b3bb002cdbaa6f8b9ddb6b17e
+  data.tar.gz: 41bedf5260a5e667d0dc6570987f26c05a66651638623e2cfddbaf132782e50067693d1f1bc9660808146456a06ab5e4c8f497de5555783e6aa073c5cabb811e

data/CHANGELOG.md

@@ -11,6 +11,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 ### Removed
 
+## [4.0.2] ([tag][4.0.2t]) - 2024-05-12
+### Added
+- More documentation
+### Changed
+- DRY logic for `DebugLogging::ClassLogger` & `DebugLogging::InstanceLogger` via `LambDart`
+- Refactored test suite; increased test coverage to 97%
+- Refactored ActiveSupport::Notification integration (DRY)
+### Fixed
+- Add undeclared runtime dependency `version_gem`
+- `DebugLogging::Hooks` integration via `extend`
+- `DebugLogging::ClassNotifier` support for method signatures with kwargs
+- `error_handler_proc` support for method signatures with kwargs
+
 ## [4.0.1] ([tag][4.0.1t]) - 2024-03-01
 ### Added
 - Support for all Numeric types to be used as monotonic timestamps for ActiveSupport::Notifications
@@ -105,7 +118,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.0] ([tag][0.1.0t]) - 2017-03-25
 - Initial release
 
-[Unreleased]: https://gitlab.com/kettle-rb/kettle-soup-cover/-/compare/v4.0.1...HEAD
+[Unreleased]: https://gitlab.com/kettle-rb/kettle-soup-cover/-/compare/v4.0.2...HEAD
+[4.0.2t]: https://gitlab.com/pboling/debug_logging/-/tags/v4.0.2
+[4.0.2]: https://gitlab.com/kettle-rb/kettle-soup-cover/-/compare/v4.0.1...v4.0.2
 [4.0.1t]: https://gitlab.com/pboling/debug_logging/-/tags/v4.0.1
 [4.0.1]: https://gitlab.com/kettle-rb/kettle-soup-cover/-/compare/v4.0.0...v4.0.1
 [4.0.0t]: https://gitlab.com/pboling/debug_logging/-/tags/v4.0.0

data/CONTRIBUTING.md

@@ -20,7 +20,7 @@ To release a new version:
 6. Run `git checkout main` (Or whichever branch is considered `trunk`, e.g. `master`)
 7. Run `git pull origin main` to ensure you will release the latest trunk code.
 8. Set `SOURCE_DATE_EPOCH` so `rake build` and `rake release` use same timestamp, and generate same checksums
-   a. Run `export SOURCE_DATE_EPOCH=$EPOCHSECONDS`
+   a. Run `export SOURCE_DATE_EPOCH=$EPOCHSECONDS && echo $SOURCE_DATE_EPOCH`
 9. Run `bundle exec rake build`
 10. Run [`bin/checksums`](https://github.com/rubygems/guides/pull/325) to create SHA-256 and SHA-512 checksums
    a. Checksums will be committed automatically by the script, but not pushed

data/README.md

@@ -60,7 +60,7 @@ Supports `ActiveSupport::Notifications` (thanks [@jgillson](https://github.com/j
 [✌️wellfound-img]: https://img.shields.io/badge/peter--boling-orange?style=plastic&logo=angellist
 [🐦twitter]: http://twitter.com/intent/user?screen_name=galtzo
 [🐦twitter-img]: https://img.shields.io/twitter/follow/galtzo.svg?style=social&label=Follow%20@galtzo
-[🚎blog]: http://www.railsbling.com/tags/oauth2/
+[🚎blog]: http://www.railsbling.com/tags/debug_logging/
 [🚎blog-img]: https://img.shields.io/badge/blog-railsbling-brightgreen.svg?style=flat
 [my🧪lab]: https://gitlab.com/pboling
 [my🧊berg]: https://codeberg.org/pboling
@@ -82,6 +82,7 @@ Supports `ActiveSupport::Notifications` (thanks [@jgillson](https://github.com/j
 * *All configuration is inheritable to, and overridable by, child classes, since v3.1.3*
 * *[Class finalization hook](https://stackoverflow.com/a/34559282) (optional: `require 'debug_logging/finalize'` and `extend DebugLogging::Finalize`), since v3.1.3*
 * *Error handling hooks you can use to log problems when they happen, since v3.1.7*
+  * *Fixed: Works with benchmarking options since v4.0.2*
 * **so many free ponies** 🎠🐴🎠🐴🎠🐴
 
 ## Next Level Magic
@@ -89,7 +90,7 @@ Supports `ActiveSupport::Notifications` (thanks [@jgillson](https://github.com/j
 Herein you will find:
 
 * ~~Classes inheriting from Module~~ Refactored to use standard Modules and `prepend`!
-* Zero tolerance policy on monkey patching
+* Zero tolerance policy on global monkey patching
   * When the gem is loaded there are no monkey patches.
   * Rather, your own classes/methods get "patched" and "hooked" as you configure them.
 * 100% clean, 0% obtrusive
@@ -166,7 +167,7 @@ DebugLogging.configuration.ellipsis = " ✂️ …".freeze
 DebugLogging.configuration.mark_scope_exit = true # Only has an effect if benchmarking is off, since benchmarking always marks the scope exit
 DebugLogging.configuration.add_payload = false # or a proc which will be called to print the payload
 DebugLogging.configuration.payload_max_length = 1000
-DebugLogging.configuration.error_handler_proc = nil # e.g. ->(error, config, obj, method_name, args) { config.log { "#{error.class}: #{error.message} in #{method_name}\nargs: #{args.inspect}" } }
+DebugLogging.configuration.error_handler_proc = nil # e.g. ->(error, config, obj, method_name, *args, **kwargs) { config.log { "#{error.class}: #{error.message} in #{method_name}\nargs: #{args.inspect}" } }
 ```
 
 If you prefer to use the block style:
@@ -192,7 +193,7 @@ DebugLogging.configure do |config|
   config.mark_scope_exit = true # Only has an effect if benchmarking is off, since benchmarking always marks the scope exit
   config.add_payload = false # or a proc which will be called to print the payload
   config.payload_max_length = 1000
-  config.error_handler_proc = nil # e.g. ->(error, config, obj, method_name, args) { config.log { "#{error.class}: #{error.message} in #{method_name}\nargs: #{args.inspect}" } }
+  config.error_handler_proc = nil # e.g. ->(error, config, obj, method_name, *args, **kwargs) { config.log { "#{error.class}: #{error.message} in #{method_name}\nargs: #{args.inspect}" } }
 end
 ```
 
@@ -264,6 +265,7 @@ class Car
   logged :dealer_options, {
     something: "here", # <= will be logged, and available to last_hash_to_s_proc
     multiple_last_hashes: true, # <= Overrides config
+    error_handler_proc: nil, # NOTE: if you define the error_handler_proc inside a class like this you can use self inside the proc to refer to the class the method was called on!
   }
   def self.will_not_be_logged
     false
@@ -314,7 +316,7 @@ class Car
     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, # NOTE: if you define the error_handler_proc inside a class like this you can use self inside the proc to refer to the instance of the class the method was called on!
     time_formatter_proc: DebugLogging::Constants::DEFAULT_TIME_FORMATTER,
     add_timestamp: false,
     instance_benchmarks: false,
@@ -439,8 +441,8 @@ end
 Run tests!
 
 ```shell
-bundle install
-bundle exec rake
+bin/setup
+bin/rake
 ```
 
 ## Contributing
@@ -511,13 +513,15 @@ See [LICENSE.txt][📄license] for the official [Copyright Notice][📄copyright
 [homepage]: https://github.com/pboling/debug_logging
 [blogpage]: http://www.railsbling.com/tags/debug_logging/
 
-[comment]: <> ( PERSONAL LINKS )
+[comment]: <> ( 💁🏼‍♂️ PERSONAL LINKS )
 
 [💁🏼‍♂️aboutme]: https://about.me/peter.boling
 [💁🏼‍♂️angellist]: https://angel.co/peter-boling
 [💁🏼‍♂️devto]: https://dev.to/galtzo
 [💁🏼‍♂️followme]: https://img.shields.io/twitter/follow/galtzo.svg?style=social&label=Follow
 [💁🏼‍♂️twitter]: http://twitter.com/galtzo
+[💁🏼‍♂️peterboling]: http://www.peterboling.com
+[💁🏼‍♂️railsbling]: http://www.railsbling.com
 
 [comment]: <> ( KEYED LINKS )
 

data/lib/debug_logging/argument_printer.rb

@@ -46,7 +46,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,9 +55,9 @@ 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
@@ -69,7 +69,7 @@ module DebugLogging
 
       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
@@ -204,8 +204,8 @@ module DebugLogging
 
     module_function
 
-    def debug_event_name_to_s(method_to_notify: nil)
-      "#{method_to_notify}.log"
+    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/configuration.rb

@@ -38,11 +38,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/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,
           )

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -8,61 +8,31 @@ module DebugLogging
             payload:,
             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,
+          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:,
               config: config_opts,
             )
-            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",
+            define_method(decorated_method) do |*args, **kwargs, &block|
+              lamb_dart = LambDart::Log.new(
+                instance: self,
+                method_config_opts:,
+                method_payload:,
+                args:,
+                kwargs:,
+                decorated_method:,
               )
-              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
-                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
-              if config_proxy.benchmarkable_for?(:debug_instance_benchmarks)
-                tms = Benchmark.measure do
-                  method_return_value = super(*args, **kwargs, &block)
-                end
-                end_timestamp = self.class.debug_time_to_s(Time.now, config_proxy:)
-                config_proxy.log do
-                  "#{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
+              real_mccoy = ->() {
+                super(*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
-              method_return_value
             end
           end
         end

data/lib/debug_logging/instance_notifier.rb

@@ -1,5 +1,11 @@
 module DebugLogging
   module InstanceNotifier
+    class << self
+      def extended(base)
+        base.include(LambDartable::Note)
+      end
+    end
+
     def i_notified(*methods_to_log)
       method_names, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
         method_names: methods_to_log,

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -8,40 +8,24 @@ module DebugLogging
             payload:,
             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,
+          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:,
               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
-              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, kwargs)
-                else
-                  raise e
+            define_method(decorated_method) do |*args, **kwargs, &block|
+              lamb_dart = LambDart::Note.new(
+                instance: self,
+                method_config_opts:,
+                method_payload:,
+                args:,
+                kwargs:,
+                decorated_method:,
+              )
+              _dl_ld_notify(lamb_dart) do
+                _dl_ld_error_handle(lamb_dart) do
+                  super(*args, **kwargs, &block)
                 end
               end
             end

data/lib/debug_logging/lamb_dart/base.rb

@@ -0,0 +1,46 @@
+require "forwardable"
+
+module DebugLogging
+  module LambDart
+    class Base
+      extend Forwardable
+
+      attr_reader :instance, # For ClassLogger, this will be the same as klass
+        :klass,
+        :is_class,
+        :config_proxy,
+        :method_payload,
+        :args,
+        :kwargs,
+        :scope_term,
+        :decorated_method
+
+      def_delegator :@config_proxy, :error_handler_proc
+
+      def initialize(instance: nil, klass: nil, method_config_opts:, method_payload:, args:, kwargs:, decorated_method:)
+        @instance = instance || klass
+        @klass = klass || instance.class
+        @method_payload = method_payload
+        @args = args
+        @kwargs = kwargs
+        @decorated_method = decorated_method
+        @is_class = (self.klass == self.instance)
+        @scope_term = is_class ? "class" : "instance"
+        @config_proxy = DebugLogging::Util.config_proxy_finder(
+          scope: self.klass,
+          config_opts: method_config_opts,
+          method_name: self.decorated_method,
+          proxy_ref:,
+        ) do |proxy|
+          yield proxy if block_given?
+        end
+      end
+
+      private
+
+      def proxy_ref
+        raise "#{self.class}##{__method__} is not defined, please fix!"
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_dart/log.rb

@@ -0,0 +1,47 @@
+module DebugLogging
+  module LambDart
+    class Log < Base
+      attr_reader :log_prefix,
+        :invocation_id,
+        :start_at
+
+      def initialize(...)
+        @start_at = Time.now
+        super
+        @log_prefix = klass.debug_invocation_to_s(
+          klass: klass.to_s,
+          separator: is_class ? "::" : "#",
+          decorated_method:,
+          config_proxy:,
+        )
+        @invocation_id = klass.debug_invocation_id_to_s(args:, config_proxy:)
+      end
+
+      def end_timestamp
+        klass.debug_time_to_s(Time.now, config_proxy:)
+      end
+
+      def benchmarked(tms)
+        klass.debug_benchmark_to_s(tms: tms)
+      end
+
+      def mark_exit_scope?
+        config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+      end
+
+      def bench_scope
+        "debug_#{scope_term}_benchmarks".to_sym
+      end
+
+      def bench?
+        config_proxy.benchmarkable_for?(bench_scope)
+      end
+
+      private
+
+      def proxy_ref
+        is_class ? "kl" : "ilm"
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_dart/note.rb

@@ -0,0 +1,30 @@
+module DebugLogging
+  module LambDart
+    class Note < Base
+      attr_reader :debug_args
+
+      def initialize(...)
+        super do |proxy|
+          subscribe(proxy)
+        end
+        @debug_args = kwargs.empty? ? args : args + [kwargs]
+      end
+
+      private
+
+      def subscribe(proxy)
+        ActiveSupport::Notifications.subscribe(
+          DebugLogging::ArgumentPrinter.debug_event_name_to_s(decorated_method: decorated_method),
+        ) do |*subscribe_args|
+          proxy.log do
+            DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*subscribe_args))
+          end
+        end
+      end
+
+      def proxy_ref
+        is_class ? "kn" : "inm"
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_dart.rb

@@ -0,0 +1,9 @@
+require_relative "lamb_dart/base"
+require_relative "lamb_dart/log"
+require_relative "lamb_dart/note"
+
+module DebugLogging
+  module LambDart
+    # Namespace
+  end
+end

data/lib/debug_logging/lamb_dartable.rb

@@ -0,0 +1,41 @@
+require_relative "lamb_darts/benchmarked"
+require_relative "lamb_darts/enter_log"
+require_relative "lamb_darts/error_handle"
+require_relative "lamb_darts/exit_log"
+require_relative "lamb_darts/notify"
+
+module DebugLogging
+  module LambDartable
+    module Log
+      class << self
+        def included(base)
+          base.include(LambDarts::Benchmarked)
+          base.include(LambDarts::EnterLog)
+          base.include(LambDarts::ErrorHandle)
+          base.include(LambDarts::ExitLog)
+        end
+
+        def extended(base)
+          base.extend(LambDarts::Benchmarked)
+          base.extend(LambDarts::EnterLog)
+          base.extend(LambDarts::ErrorHandle)
+          base.extend(LambDarts::ExitLog)
+        end
+      end
+    end
+
+    module Note
+      class << self
+        def included(base)
+          base.include(LambDarts::ErrorHandle)
+          base.include(LambDarts::Notify)
+        end
+
+        def extended(base)
+          base.extend(LambDarts::ErrorHandle)
+          base.extend(LambDarts::Notify)
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_darts/benchmarked.rb

@@ -0,0 +1,19 @@
+module DebugLogging
+  module LambDarts
+    module Benchmarked
+      def _dl_ld_benchmarked(ld)
+        brv = nil
+        # Benchmarking as close to the real mccoy as possible,
+        #   so as to not pollute performance tracking with the effects of debug_logging,
+        #   which may be removed once data has been gathered, or turned off.
+        tms = Benchmark.measure do
+          brv = yield
+        end
+        ld.config_proxy.log do
+          "#{ld.end_timestamp}#{ld.log_prefix} #{ld.benchmarked(tms)}#{ld.invocation_id}"
+        end
+        brv
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_darts/enter_log.rb

@@ -0,0 +1,16 @@
+module DebugLogging
+  module LambDarts
+    module EnterLog
+      def _dl_ld_enter_log(ld)
+        start_timestamp = ld.klass.debug_time_to_s(ld.start_at, config_proxy: ld.config_proxy)
+        ld.config_proxy.log do
+          paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: ld.instance, payload: ld.method_payload)
+          signature = ld.klass.debug_signature_to_s(args: ld.args, kwargs: ld.kwargs, config_proxy: ld.config_proxy)
+          paymud = ld.instance.debug_payload_to_s(payload: paydirt, config_proxy: ld.config_proxy)
+          "#{start_timestamp}#{ld.log_prefix}#{signature}#{ld.invocation_id} debug: #{paymud}"
+        end
+        yield
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_darts/error_handle.rb

@@ -0,0 +1,28 @@
+module DebugLogging
+  module LambDarts
+    module ErrorHandle
+      def _dl_ld_error_handle(ld)
+        if ld.config_proxy.error_handler_proc
+          begin
+            yield
+          rescue StandardError => e
+            if ld.error_handler_proc
+              ld.error_handler_proc.call(
+                ld.config_proxy,
+                e,
+                self,
+                ld.decorated_method,
+                *ld.args,
+                **ld.kwargs,
+              )
+            else
+              raise e
+            end
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_darts/exit_log.rb

@@ -0,0 +1,15 @@
+module DebugLogging
+  module LambDarts
+    module ExitLog
+      def _dl_ld_exit_log(ld)
+        hrv = yield
+        return hrv unless ld.mark_exit_scope?
+
+        ld.config_proxy.log do
+          "#{ld.end_timestamp}#{ld.log_prefix} completed#{ld.invocation_id}"
+        end
+        hrv
+      end
+    end
+  end
+end

data/lib/debug_logging/lamb_darts/notify.rb

@@ -0,0 +1,17 @@
+module DebugLogging
+  module LambDarts
+    module Notify
+      def _dl_ld_notify(ld)
+        paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: ld.instance, payload: ld.method_payload)
+        ActiveSupport::Notifications.instrument(
+          DebugLogging::ArgumentPrinter.debug_event_name_to_s(decorated_method: ld.decorated_method),
+          debug_args: ld.debug_args,
+          config_proxy: ld.config_proxy,
+          **paydirt,
+        ) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/util.rb

@@ -71,27 +71,31 @@ module DebugLogging
     end
 
     def config_proxy_finder(scope:, method_name:, proxy_ref:, config_opts: {}, &block)
-      if (proxy = scope.send(:instance_variable_get, DebugLogging::Configuration.config_pointer(
-        proxy_ref,
-        method_name,
-      )))
-        proxy
+      proxy = scope.send(
+        :instance_variable_get,
+        DebugLogging::Configuration.config_pointer(
+          proxy_ref,
+          method_name,
+        ),
+      )
+      # short circuit on subsequent calls is required
+      #   so we only register notifications once
+      return proxy if proxy
+
+      base = scope.respond_to?(:debug_config) ? scope.debug_config : DebugLogging.debug_logging_configuration
+      proxy = if config_opts.empty?
+        base
       else
-        base = scope.respond_to?(:debug_config) ? scope.debug_config : DebugLogging.debug_logging_configuration
-        proxy = if config_opts.empty?
-          base
-        else
-          DebugLogging::Configuration.new(**base.to_hash.merge(config_opts))
-        end
-        proxy.register(method_name)
-        scope.send(
-          :instance_variable_set,
-          DebugLogging::Configuration.config_pointer(proxy_ref, method_name),
-          proxy,
-        )
-        yield proxy if block
-        proxy
+        DebugLogging::Configuration.new(**base.to_hash.merge(config_opts))
       end
+      proxy.register(method_name)
+      scope.send(
+        :instance_variable_set,
+        DebugLogging::Configuration.config_pointer(proxy_ref, method_name),
+        proxy,
+      )
+      yield proxy if block
+      proxy
     end
   end
 end

data/lib/debug_logging/version.rb

@@ -1,5 +1,5 @@
 module DebugLogging
   module Version
-    VERSION = "4.0.1"
+    VERSION = "4.0.2"
   end
 end

data/lib/debug_logging.rb

@@ -15,17 +15,12 @@ require "debug_logging/util"
 require "debug_logging/finalize"
 require "debug_logging/argument_printer"
 require "debug_logging/hooks"
+require "debug_logging/lamb_dart"
+require "debug_logging/lamb_dartable"
 require "debug_logging/instance_logger_modulizer"
 require "debug_logging/instance_logger"
 require "debug_logging/class_logger"
 
-####################
-#                  #
-# NOTE: The manner this is made to work for class methods is totally different
-#       than the way this is made to work for instance methods.
-# NOTE: The instance method manner works on Ruby 2.0+
-# NOTE: The class method manner works on Ruby 2.1+
-#                  #
 ####################
 #                  #
 # USAGE (see specs)#

data/lib/simple_debug_logging.rb

@@ -49,17 +49,17 @@ class SimpleDebugLogging < Module
 
   module ClassMethodLogger
     def logged(*methods_to_log)
-      methods_to_log.each do |method_to_log|
-        original_method = method(method_to_log)
+      methods_to_log.each do |decorated_method|
+        original_method = method(decorated_method)
         (class << self; self; end).class_eval do
-          define_method(method_to_log.to_sym) do |*args|
+          define_method(decorated_method.to_sym) do |*args|
             method_return_value = nil
             invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if args
-            puts "#{self}::#{method_to_log}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
+            puts "#{self}::#{decorated_method}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
             elapsed = Benchmark.realtime do
               method_return_value = original_method.call(*args)
             end
-            puts "#{self}::#{method_to_log} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
+            puts "#{self}::#{decorated_method} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
             method_return_value
           end
         end
@@ -68,18 +68,20 @@ class SimpleDebugLogging < Module
   end
 
   module InstanceMethodLoggerModulizer
-    def self.to_mod(methods_to_log = [])
-      Module.new do
-        Array(methods_to_log).each do |method_to_log|
-          define_method(method_to_log.to_sym) do |*args, &block|
-            method_return_value = nil
-            invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if args
-            puts "#{self.class}##{method_to_log}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
-            elapsed = Benchmark.realtime do
-              method_return_value = super(*args, &block)
+    class << self
+      def to_mod(methods_to_log = [])
+        Module.new do
+          Array(methods_to_log).each do |decorated_method|
+            define_method(decorated_method.to_sym) do |*args, &block|
+              method_return_value = nil
+              invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if args
+              puts "#{self.class}##{decorated_method}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
+              elapsed = Benchmark.realtime do
+                method_return_value = super(*args, &block)
+              end
+              puts "#{self.class}##{decorated_method} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
+              method_return_value
             end
-            puts "#{self.class}##{method_to_log} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
-            method_return_value
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.0.2
 platform: ruby
 authors:
 - Peter Boling
@@ -38,7 +38,7 @@ cert_chain:
   KuxrfYrN+9HvMdm+nZ6TypmKftHY3Gj+/uu+g8Icm/zrvTWAEE0mcJOkfrIoNPJb
   pF8dMA==
   -----END CERTIFICATE-----
-date: 2024-03-01 00:00:00.000000000 Z
+date: 2024-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -55,33 +55,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: version_gem
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.4.4
-  type: :development
+        version: 1.1.4
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.4.4
+        version: 1.1.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '13'
+        version: 13.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.2.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.4.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '13'
+        version: 5.2.4.4
 - !ruby/object:Gem::Dependency
   name: kettle-soup-cover
   requirement: !ruby/object:Gem::Requirement
@@ -204,6 +224,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.25'
+- !ruby/object:Gem::Dependency
+  name: standard-rubocop-lts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.10
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -310,6 +350,16 @@ files:
 - lib/debug_logging/instance_logger_modulizer.rb
 - lib/debug_logging/instance_notifier.rb
 - lib/debug_logging/instance_notifier_modulizer.rb
+- lib/debug_logging/lamb_dart.rb
+- lib/debug_logging/lamb_dart/base.rb
+- lib/debug_logging/lamb_dart/log.rb
+- lib/debug_logging/lamb_dart/note.rb
+- lib/debug_logging/lamb_dartable.rb
+- lib/debug_logging/lamb_darts/benchmarked.rb
+- lib/debug_logging/lamb_darts/enter_log.rb
+- lib/debug_logging/lamb_darts/error_handle.rb
+- lib/debug_logging/lamb_darts/exit_log.rb
+- lib/debug_logging/lamb_darts/notify.rb
 - lib/debug_logging/log_subscriber.rb
 - lib/debug_logging/util.rb
 - lib/debug_logging/version.rb
@@ -319,10 +369,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/pboling/debug_logging
-  source_code_uri: https://github.com/pboling/debug_logging/tree/v4.0.1
-  changelog_uri: https://github.com/pboling/debug_logging/blob/v4.0.1/CHANGELOG.md
+  source_code_uri: https://github.com/pboling/debug_logging/tree/v4.0.2
+  changelog_uri: https://github.com/pboling/debug_logging/blob/v4.0.2/CHANGELOG.md
   bug_tracker_uri: https://github.com/pboling/debug_logging/issues
-  documentation_uri: https://www.rubydoc.info/gems/debug_logging/4.0.1
+  documentation_uri: https://www.rubydoc.info/gems/debug_logging/4.0.2
   wiki_uri: https://github.com/pboling/debug_logging/wiki
   funding_uri: https://liberapay.com/pboling
   rubygems_mfa_required: 'true'
@@ -341,7 +391,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Drop-in debug logging useful when a call stack gets unruly