debug_logging 3.1.2 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb9df42efa08fe95b6c9270a4474132b2dbb55ed8d154d17c20dfde074781a8c
-  data.tar.gz: 459f277689fcb9b328b4c904730ae25bfe1c55fc87a5ab292157393f6b13c36b
+  metadata.gz: e6eee794d14ae44299b2737ff61beab4165c434132262861104d60b4da781445
+  data.tar.gz: c9fdb194a05fa751879a60bb73bd4eb3fe4507b0680b1ee437f5d88fa65b3fa0
 SHA512:
-  metadata.gz: 5af7096cfbadcea5695cc19bdce85e4d6ac8eecf02139378cb2dc0d734d99011bc49ff239fe1d816ce9570a883b75b4f6e0772fdfbf7feda147e7890c56d415a
-  data.tar.gz: f471d3858ad20c1d3347b4ce328254c01572da54fd0e566ccbf6b15827996c561cf86c5fcb23f14ad127d5a9449b045c63281768c082b2375d754e566f3d4561
+  metadata.gz: 8eeb20c2a01e99b3069f8b592f54271497a6835402e76d73edba964645c2b6600e83e3d497b7eddf5720087b89421e61caa7e5224124f5205fdde6f0b82d5426
+  data.tar.gz: fce74d216e19def9b2e8b208036138732fc82add3e889fdd3a09199dab285354c5863b1a11b12feb451faa9e39294507ec704e40031568272ac03a6c1be13077

data/README.md

@@ -1,6 +1,7 @@
 # DebugLogging
 
 Unobtrusive, inheritable-overridable-configurable, drop-in debug logging, that won't leave a mess behind when it is time to remove it.
+Supports ActiveSupport::Notifications (thanks [@jgillson](https://github.com/jgillson)).  Optional ActiveRecord callback-style hooks that you can decorate your methods with. Hooks logic was taken from the [`slippy_method_hooks` gem](https://github.com/guckin/slippy_method_hooks), (thanks [@guckin](https://github.com/guckin)), and prefaced with `debug_` for this implementation. `DebugLogging::Finalize` is lightly modified from [this stackoverflow answer](https://stackoverflow.com/a/34559282).
 
 ## What do I mean by "unobtrusive"?
 
@@ -32,12 +33,15 @@ Unobtrusive, inheritable-overridable-configurable, drop-in debug logging, that w
 * *colorization by class/method*
 * *robust argument printer with customizable ellipsis*
 * *unique invocation identifiers*
-* *single line config, per class/instance/method config*
-* *separate logger, if needed*
+* *simple single line global config, or per class/instance/method config*
+* *separate loggers, if needed*
 * *log method calls, also when exit scope*
 * *Prevents heavy computation of strings with `logger.debug { 'log me' }` block format, since v1.0.12*
-* *ActiveSupport::Notifications integration for instrumenting/logging events on class and instance methods, since v3.1*
-* *Optional instance variable logging, sine v3.1*
+* *ActiveSupport::Notifications integration for instrumenting/logging events on class and instance methods, since v3.2*
+* *Optional instance, and class-instance, variable logging, since v3.2*
+* *ActiveRecord style callback-hooks (optional: `require 'debug_logging/hooks'` and `include DebugLogging::Hooks`), since v3.2*
+* *All configuration is inheritable to, and overridable by, child classes, since v3.2*
+* *[Class finalization hook](https://stackoverflow.com/a/34559282) (optional: `require 'debug_logging/finalize'` and `extend DebugLogging::Finalize`), since v3.2*
 * **so many free ponies** 🎠🐴🎠🐴🎠🐴
 
 ## Next Level Magic
@@ -381,6 +385,10 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+### License Exceptions
+
+* [`debug_logging/finalize`](https://stackoverflow.com/a/34559282) is licensed under https://creativecommons.org/licenses/by-sa/4.0/
+
 [semver]: http://semver.org/
 [pvc]: http://docs.rubygems.org/read/chapter/16#page74
 [railsbling]: http://www.railsbling.com

data/debug_logging.gemspec

@@ -7,7 +7,7 @@ require 'debug_logging/version'
 Gem::Specification.new do |spec|
   spec.name          = 'debug_logging'
   spec.version       = DebugLogging::VERSION
-  spec.authors       = ['Peter Boling']
+  spec.authors       = ['Peter Boling', 'guckin']
   spec.email         = ['peter.boling@gmail.com']
 
   spec.summary       = 'Drop-in debug logging useful when a call stack gets unruly'

data/lib/debug_logging.rb

@@ -5,8 +5,12 @@ require 'colorized_string'
 require 'digest'
 
 require 'debug_logging/version'
+require 'debug_logging/errors'
 require 'debug_logging/configuration'
+require 'debug_logging/util'
+require 'debug_logging/finalize'
 require 'debug_logging/argument_printer'
+require 'debug_logging/hooks'
 require 'debug_logging/instance_logger_modulizer'
 require 'debug_logging/instance_logger'
 require 'debug_logging/class_logger'
@@ -61,6 +65,11 @@ module DebugLogging
   def self.extended(base)
     base.send(:extend, ArgumentPrinter)
     base.debug_config_reset(Configuration.new(**debug_logging_configuration.to_hash))
+    base.class_eval do
+      def base.inherited(subclass)
+        subclass.debug_config_reset(Configuration.new(**debug_config.to_hash))
+      end
+    end
   end
 
   #### API ####

data/lib/debug_logging/argument_printer.rb

@@ -2,7 +2,7 @@
 
 module DebugLogging
   module ArgumentPrinter
-    def debug_benchmark_to_s(tms: nil)
+    def debug_benchmark_to_s(tms:)
       "completed in #{format('%f', tms.real)}s (#{format('%f', tms.total)}s CPU)"
     end
 
@@ -73,17 +73,17 @@ module DebugLogging
           else
             printed_args += args[0..-2].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[0..(config_proxy.debug_args_max_length)]
             printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
             printed_args += ", #{config_proxy.debug_last_hash_to_s_proc.call(args[-1]).tap do |x|
                                    add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
-                                 end [0..(config_proxy.debug_last_hash_max_length)]}"
+                                 end[0..(config_proxy.debug_last_hash_max_length)]}"
             printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
           end
         else
           printed_args += String(config_proxy.debug_last_hash_to_s_proc.call(args[0])).tap do |x|
                             add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
-                          end [0..(config_proxy.debug_last_hash_max_length)]
+                          end[0..(config_proxy.debug_last_hash_max_length)]
           printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
         end
       else
@@ -95,7 +95,7 @@ module DebugLogging
                         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[0..(config_proxy.debug_args_max_length)]
                         end
         printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
       end

data/lib/debug_logging/class_logger.rb

@@ -3,52 +3,31 @@
 module DebugLogging
   module ClassLogger
     def logged(*methods_to_log)
-      # When opts are present it will always be a new configuration instance per method
-      # When opts are not present it will reuse the class' configuration object
-      payload = methods_to_log.last.is_a?(Hash) && methods_to_log.pop.dup || {}
-      config_opts = {}
-      unless payload.empty?
-        DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
-      end
-      if methods_to_log.first.is_a?(Array)
-        methods_to_log = methods_to_log.shift
-      else
-        # logged :meth1, :meth2, :meth3 without options is valid too
-      end
-      methods_to_log.each do |method_to_log|
-        # method name must be a symbol
-        method_to_log = method_to_log.to_sym
+      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,
+          payload: payload,
+          config: config_opts
+        )
         original_method = method(method_to_log)
         (class << self; self; end).class_eval do
           define_method(method_to_log) do |*args, &block|
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('kl',
-                                                                                                        method_to_log)))
-                             proxy
-                           else
-                             proxy = if config_opts.empty?
-                                       debug_config
-                                     else
-                                       DebugLogging::Configuration.new(**debug_config.to_hash.merge(config_opts))
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('kl', method_to_log),
-                                                   proxy)
-                             proxy
-                           end
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self,
+              config_opts: method_config_opts,
+              method_name: method_to_log,
+              proxy_ref: 'kl'
+            )
             method_return_value = nil
             log_prefix = nil
             invocation_id = nil
             config_proxy.log do
-              paydirt = {}
-              # TODO: Could make instance variable introspection configurable before or after method execution
-              if payload.key?(:instance_variables)
-                paydirt.merge!(payload.reject { |k| k == :instance_variables })
-                payload[:instance_variables].each do |k|
-                  paydirt[k] = instance_variable_get("@#{k}") if instance_variable_defined?("@#{k}")
-                end
-              else
-                paydirt.merge!(payload)
-              end
+              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)
               invocation_id = debug_invocation_id_to_s(args: args, config_proxy: config_proxy)

data/lib/debug_logging/class_notifier.rb

@@ -3,51 +3,41 @@
 module DebugLogging
   module ClassNotifier
     def notifies(*methods_to_notify)
-      # When opts are present it will always be a new configuration instance per method
-      # When opts are not present it will reuse the class' configuration object
-      payload = methods_to_notify.last.is_a?(Hash) && methods_to_notify.pop.dup || {}
-      config_opts = {}
-      unless payload.empty?
-        DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
-      end
-      if methods_to_notify.first.is_a?(Array)
-        methods_to_notify = methods_to_notify.shift
-      else
-        # logged :meth1, :meth2, :meth3 without options is valid too
-      end
-      methods_to_notify.each do |method_to_notify|
-        # method name must be a symbol
-        method_to_notify = method_to_notify.to_sym
+      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,
+          payload: payload,
+          config: config_opts
+        )
         original_method = method(method_to_notify)
         (class << self; self; end).class_eval do
           define_method(method_to_notify) do |*args, &block|
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('kn',
-                                                                                                        method_to_notify)))
-                             proxy
-                           else
-                             proxy = if config_opts.empty?
-                                       debug_config
-                                     else
-                                       DebugLogging::Configuration.new(**debug_config.to_hash.merge(config_opts))
-                                     end
-                             proxy.register(method_to_notify)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('kn', method_to_notify),
-                                                   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
-                             proxy
-                           end
+            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_vaiable_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,
-                **payload
+                **paydirt
               }
             ) do
               if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)

data/lib/debug_logging/errors.rb

@@ -0,0 +1,7 @@
+module DebugLogging
+  class Error < StandardError; end
+
+  class TimeoutError < Error; end
+
+  class NoBlockGiven < Error; end
+end

data/lib/debug_logging/finalize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# From: https://stackoverflow.com/a/34559282
+# 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"
+          end
+          t.disable
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/hooks.rb

@@ -0,0 +1,82 @@
+require 'debug_logging/errors'
+require 'timeout'
+
+module DebugLogging
+  module Hooks
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    def self.extend(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def debug_time_box(time, *names, &blk)
+        names.each do |name|
+          meth = instance_method(name)
+          define_method(name) do |*args, &block|
+            begin
+              Timeout.timeout(time) do
+                meth.bind(self).call(*args, &block)
+              end
+            rescue Timeout::Error
+              error_args = [TimeoutError, 'execution expired', caller]
+              raise(*error_args) unless blk
+
+              instance_exec(*error_args, &blk)
+            end
+          end
+        end
+      end
+
+      def debug_rescue_on_fail(*names, &blk)
+        unless blk
+          raise NoBlockGiven,
+                '.rescue_on_fail must be called with a block',
+                caller
+        end
+        names.each do |name|
+          meth = instance_method(name)
+          define_method(name) do |*args, &block|
+            begin
+              meth.bind(self).call(*args, &block)
+            rescue StandardError => e
+              instance_exec(e, &blk)
+            end
+          end
+        end
+      end
+
+      def debug_before(*names, &blk)
+        unless blk
+          raise NoBlockGiven,
+                '.before must be called with a block',
+                caller
+        end
+        names.each do |name|
+          meth = instance_method(name)
+          define_method name do |*args, &block|
+            instance_exec(name, *args, block, &blk)
+            meth.bind(self).call(*args, &block)
+          end
+        end
+      end
+
+      def debug_after(*names, &blk)
+        unless blk
+          raise NoBlockGiven,
+                '.after must be called with a block',
+                caller
+        end
+        names.each do |name|
+          meth = instance_method(name)
+          define_method name do |*args, &block|
+            result = meth.bind(self).call(*args, &block)
+            instance_exec(result, &blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/instance_logger.rb

@@ -2,9 +2,10 @@
 
 module DebugLogging
   class InstanceLogger < Module
-    def initialize(i_methods: nil, config: nil)
+    def initialize(i_methods: nil, payload: nil, config: nil)
       super()
       @config = config
+      @payload = payload
       @instance_methods_to_log = Array(i_methods) if i_methods
     end
 
@@ -13,6 +14,7 @@ module DebugLogging
 
       base.send(:include, ArgumentPrinter)
       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

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -2,52 +2,32 @@
 
 module DebugLogging
   module InstanceLoggerModulizer
-    def self.to_mod(methods_to_log: nil, config: nil)
+    def self.to_mod(methods_to_log: nil, payload: nil, config: nil)
       Module.new do
+        methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: Array(methods_to_log),
+          payload: payload,
+          config: config
+        )
         Array(methods_to_log).each do |method_to_log|
-          payload = (method_to_log.is_a?(Array) && method_to_log.last.is_a?(Hash) && method_to_log.pop.dup) || {}
-          config_opts = {}
-          unless payload.empty?
-            DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
-          end
-          # method name must be a symbol
-          method_to_log = if method_to_log.is_a?(Array)
-                            method_to_log.first&.to_sym
-                          else
-                            method_to_log.to_sym
-                          end
+          method_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+            method_names: method_to_log,
+            payload: payload,
+            config: config_opts
+          )
           define_method(method_to_log) do |*args, &block|
             method_return_value = nil
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('ilm',
-                                                                                                        method_to_log)))
-                             proxy
-                           else
-                             proxy = if config
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config.merge(config_opts)))
-                                     elsif !config_opts.empty?
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config_opts))
-                                     else
-                                       self.class.debug_config
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('ilm', method_to_log),
-                                                   proxy)
-                             proxy
-                           end
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self.class,
+              config_opts: method_config_opts,
+              method_name: method_to_log,
+              proxy_ref: 'ilm'
+            )
             log_prefix = self.class.debug_invocation_to_s(klass: self.class.to_s, separator: '#',
                                                           method_to_log: method_to_log, config_proxy: config_proxy)
             invocation_id = self.class.debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
             config_proxy.log do
-              paydirt = {}
-              # TODO: Could make instance variable introspection configurable before or after method execution
-              if payload.key?(:instance_variables)
-                paydirt.merge!(payload.reject { |k| k == :instance_variables })
-                payload[:instance_variables].each do |k|
-                  paydirt[k] = instance_variable_get("@#{k}") if instance_variable_defined?("@#{k}")
-                end
-              else
-                paydirt.merge!(payload)
-              end
+              paydirt = DebugLogging::Util.payload_instance_vaiable_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}"

data/lib/debug_logging/instance_notifier.rb

@@ -2,8 +2,10 @@
 
 module DebugLogging
   class InstanceNotifier < Module
-    def initialize(i_methods: nil)
+    def initialize(i_methods: nil, payload: nil, config: nil)
       super()
+      @config = config
+      @payload = payload
       @instance_methods_to_notify = Array(i_methods) if i_methods
     end
 
@@ -11,7 +13,9 @@ 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)
+      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

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -2,47 +2,35 @@
 
 module DebugLogging
   module InstanceNotifierModulizer
-    def self.to_mod(methods_to_notify: nil)
+    def self.to_mod(methods_to_notify: nil, payload: nil, config: nil)
       Module.new do
-        config_proxy = nil
-
+        methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: Array(methods_to_notify),
+          payload: payload,
+          config: config
+        )
         Array(methods_to_notify).each do |method_to_notify|
-          # method name must be a symbol
-          payload = (method_to_notify.is_a?(Array) && method_to_notify.last.is_a?(Hash) && method_to_notify.pop.dup) || {}
-          config_opts = {}
-          unless payload.empty?
-            DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
-          end
-          method_to_notify = if method_to_notify.is_a?(Array)
-                               method_to_notify.first&.to_sym
-                             else
-                               method_to_notify.to_sym
-                             end
+          method_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+            method_names: method_to_notify,
+            payload: payload,
+            config: config_opts
+          )
           define_method(method_to_notify) do |*args, &block|
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('inm',
-                                                                                                        method_to_notify)))
-                             proxy
-                           else
-                             proxy = if config_opts.empty?
-                                       self.class.debug_config
-                                     else
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config_opts))
-                                     end
-                             proxy.register(method_to_notify)
-                             instance_variable_set(
-                               DebugLogging::Configuration.config_pointer('inm', method_to_notify), proxy
-                             )
-                             proxy
-                           end
-            paydirt = {}
-            if payload.key?(:instance_variables)
-              paydirt.merge!(payload.reject { |k| k == :instance_variables })
-              payload[:instance_variables].each do |k|
-                paydirt[k] = instance_variable_get("@#{k}") if instance_variable_defined?("@#{k}")
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self.class,
+              config_opts: method_config_opts,
+              method_name: method_to_notify,
+              proxy_ref: 'inm'
+            ) do |config_proxy|
+              ActiveSupport::Notifications.subscribe(
+                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify)
+              ) do |*args|
+                config_proxy&.log do
+                  DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
+                end
               end
-            else
-              paydirt.merge!(payload)
             end
+            paydirt = DebugLogging::Util.payload_instance_vaiable_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,
@@ -52,13 +40,6 @@ module DebugLogging
               super(*args, &block)
             end
           end
-          ActiveSupport::Notifications.subscribe(
-            DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify)
-          ) do |*args|
-            config_proxy&.log do
-              DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
-            end
-          end
         end
       end
     end

data/lib/debug_logging/util.rb

@@ -0,0 +1,75 @@
+module DebugLogging
+  module Util
+    module_function
+
+    # methods_to_log may be an array of a single method name, followed by config options and payload,
+    #   or it could be an array of method names followed by config options and payload to be shared by the whole set.
+    def extract_payload_and_config(method_names:, payload: nil, config: nil)
+      # When scoped config is present it will always be a new configuration instance per method
+      # When scoped config is not present it will reuse the class' configuration object
+      scoped_payload = (method_names.is_a?(Array) && method_names.last.is_a?(Hash) && method_names.pop.clone(freeze: false)) || {}
+      payload = if payload
+                  payload.merge(scoped_payload)
+                else
+                  scoped_payload
+                end
+      config_opts = config&.clone(freeze: false) || {}
+      unless payload.empty?
+        DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
+      end
+      method_names =
+        case method_names
+        when Symbol
+          method_names
+        when String
+          method_names.to_sym
+        when Array
+          if method_names.first.is_a?(Array)
+            # Array of arrays?
+            method_names.shift
+          elsif method_names.size == 1 && method_names.first.is_a?(Symbol)
+            # when set as i_methods: [[:i_with_dsplat_payload, { tags: %w[blue green] }], ...]
+            method_names.shift.to_sym
+          else
+            # Or an array of method name symbols?
+            # logged :meth1, :meth2, :meth3 without options is valid
+            method_names
+          end
+        end
+      [method_names, payload, config_opts]
+    end
+
+    def payload_instance_vaiable_hydration(scope:, payload:)
+      paydirt = {}
+      # TODO: Could make instance variable introspection configurable before or after method execution
+      if payload.key?(:instance_variables)
+        paydirt.merge!(payload.reject { |k| k == :instance_variables })
+        payload[:instance_variables].each do |k|
+          paydirt[k] = scope.send(:instance_variable_get, "@#{k}") if scope.send(:instance_variable_defined?, "@#{k}")
+        end
+      else
+        paydirt.merge!(payload)
+      end
+      paydirt
+    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
+      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
+      end
+    end
+  end
+end

data/lib/debug_logging/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DebugLogging
-  VERSION = '3.1.2'
+  VERSION = '3.1.3'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors:
 - Peter Boling
+- guckin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-10 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -226,11 +227,15 @@ files:
 - lib/debug_logging/class_logger.rb
 - lib/debug_logging/class_notifier.rb
 - lib/debug_logging/configuration.rb
+- lib/debug_logging/errors.rb
+- lib/debug_logging/finalize.rb
+- lib/debug_logging/hooks.rb
 - lib/debug_logging/instance_logger.rb
 - lib/debug_logging/instance_logger_modulizer.rb
 - lib/debug_logging/instance_notifier.rb
 - lib/debug_logging/instance_notifier_modulizer.rb
 - lib/debug_logging/log_subscriber.rb
+- lib/debug_logging/util.rb
 - lib/debug_logging/version.rb
 - lib/simple_debug_logging.rb
 homepage: https://github.com/pboling/debug_logging
@@ -252,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.1
 signing_key:
 specification_version: 4
 summary: Drop-in debug logging useful when a call stack gets unruly