debug_logging 3.1.1 → 3.1.7

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}"
@@ -60,7 +40,15 @@ module DebugLogging
                 "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
               end
             else
-              method_return_value = super(*args, &block)
+              begin
+                method_return_value = super(*args, &block)
+              rescue => error
+                if config_proxy.error_handler_proc
+                  config_proxy.error_handler_proc.call(config_proxy, error, self)
+                else
+                  raise error
+                end
+              end
               if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
                 config_proxy.log do
                   "#{log_prefix} completed#{invocation_id}"

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,61 +2,50 @@
 
 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,
               config_proxy: config_proxy,
               **paydirt
             ) do
-              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))
+              begin
+                super(*args, &block)
+              rescue => error
+                if config_proxy.error_handler_proc
+                  config_proxy.error_handler_proc.call(config_proxy, error, self)
+                else
+                  raise error
+                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.1'
+  VERSION = '3.1.7'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.7
 platform: ruby
 authors:
 - Peter Boling
+- guckin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-09 00:00:00.000000000 Z
+date: 2020-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -116,32 +117,74 @@ dependencies:
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-md
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.92'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.92'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: silent_stream
   requirement: !ruby/object:Gem::Requirement
@@ -184,11 +227,16 @@ files:
 - lib/debug_logging/class_logger.rb
 - lib/debug_logging/class_notifier.rb
 - lib/debug_logging/configuration.rb
+- lib/debug_logging/constants.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
@@ -210,7 +258,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