debug_logging 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efda45f99c32dcb0acc32896a61f2d209c527cf62bd74a74282cf044607f396f
-  data.tar.gz: d4af27fc700abaa9a536d15c56af36f8a202db7c40d0107a8d8eb1262252aaeb
+  metadata.gz: a39fc11d3fc815e37db037fd9ce8b08e74e5d98e7612a50f191231ba3ce95231
+  data.tar.gz: 99ef91cf9302dfc413ebba74435464933524cfa1a2e70f9623b97ff64c849729
 SHA512:
-  metadata.gz: d857b33f90f75e8bdfb3f2deedfb5c503bd90adbabb6b9aead0ecb305ba72715c25435f9d543ff8471454b5c9c5ff631792b870a97864fdb30e530ba4c0e6fb0
-  data.tar.gz: 6985ed5caff4dbe017946a61b4f4242867110bcafcf266b62c98ce340d8af28f148b1dee364d3291296d2d5444789a429b254bedcd54bd63be28e4ce5a771b10
+  metadata.gz: 22ec37827bdf34889a023d235315ee4ca85642cdc070a22751be328f58c8f4b8b22c952da52c2d6900f3bc44431d8d0dd5800483419532f3fd5a5aca9227d529
+  data.tar.gz: 5b5456b83dfff252840e31ea81af17e5d3b50bdc025e090d55731fcd16353d41352b2304ba53818c791f9ec3970a447e4b01624fd269d6663951a444a876ac6d

data/README.md

@@ -2,6 +2,12 @@
 
 Unobtrusive, inheritable-overridable-configurable, drop-in debug logging, that won't leave a mess behind when it is time to remove it.
 
+## What do I mean by "unobtrusive"?
+
+**Ugly** debug logging is added inside the body of a method, so it runs when a method is called. This can create a mess of your git history, and can even introduce new bugs to your code.
+
+**Unobtrusive** debug logging stays out of the method, changes no logic, can't break your code, and yet it still runs when your method is called, and tells you everything you wanted to know. It doesn't mess with the git history of the method at all!
+
 | Project                 |  DebugLogging           |
 |------------------------ | ----------------------- |
 | gem name                |  [debug_logging](https://rubygems.org/gems/debug_logging) |
@@ -43,9 +49,9 @@ Herein you will find:
 * 100% clean, 0% obtrusive
 * 100% tested
 * 100% Ruby 2.1+ compatible
-  - use version ~1.0 for Ruby < 2.3
-  - use version ~2.0 for Ruby 2.3
-  - use version ~3.0 for Ruby 2.4+
+  - use version `gem "debug_logging", "~> 1.0"` for Ruby < 2.3
+  - use version `gem "debug_logging", "~> 2.0"` for Ruby 2.3
+  - use version `gem "debug_logging", "~> 3.0"` for Ruby 2.4+
 
 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.
 
@@ -136,29 +142,45 @@ Every time a method is called, you can now get logs, optionally with arguments,
 
 ```ruby
 class Car
-
-  # adds the helper methods to the class, all are prefixed with debug_*,
-  #   except for the logged class method, which comes from extending DebugLogging::ClassLogger
+  # Adds the helper methods to the class.
+  #   All helpers prefixed with debug_*,
+  #   except for the *logged* decorator, which comes from extending DebugLogging::ClassLogger
   extend DebugLogging
 
   # per class configuration overrides!
   self.debug_class_benchmarks = true
   self.debug_instance_benchmarks = true
 
-  # For instance methods:
-  # Option 1: specify the exact method(s) to add logging to
-  include DebugLogging::InstanceLogger.new(i_methods: [:drive, :stop])
-
-  # Provides the `logged` method decorator
+  # For class methods
+  #   Provides the versatile `logged` method decorator / macro
+  # For instance methods
+  #   Provides the versatile `i_logged` method decorator / macro
   extend DebugLogging::ClassLogger
 
-  logged def make; new; end
-  def design(*args); new; end
-  def safety(*args); new; end
-  def dealer_options(*args); new; end
+  # == BEGIN CLASS METHODS ==
+  # For class methods:
+  # Option 1: Use *logged* as a method decorator
+  logged def self.make; new; end
+  def self.design(*args); new; end
+  def self.safety(*args); new; end
+  def self.dealer_options(*args); new; end
+
+  # Option 2: Use *logged* as a macro
   logged :design, :safety
-  # override options for any instance method(s), by passing a hash as the last argument
-  logged :dealer_options, { multiple_last_hashes: true }
+  # Override configuration options for any class method(s), by passing a hash as the last argument
+  # In the last hash any non-Configuration keys will be data that gets logged,
+  #     and also made available to last_hash_to_s_proc
+  logged :dealer_options, {
+    something: 'here', # <= will be logged, and available to last_hash_to_s_proc
+    multiple_last_hashes: true # <= Overrides config
+  }
+  def self.will_not_be_logged; false; end
+  # == END CLASS METHODS ==
+
+  # == BEGIN INSTANCE METHODS ==
+  # For instance methods:
+  # Option 1: specify the exact method(s) to add logging to
+  include DebugLogging::InstanceLogger.new(i_methods: [:drive, :stop])
 
   def drive(speed); speed; end
   def stop(**opts); 0; end
@@ -167,11 +189,15 @@ class Car
   # Option 2: add logging to all instance methods defined above (but *not* defined below)
   include DebugLogging::InstanceLogger.new(i_methods: self.instance_methods(false))
 
-  # override options for any instance method(s)
-  include DebugLogging::InstanceLogger.new(i_methods: [:stop], config: { multiple_last_hashes: true })
+  def faster(**opts); 0; end
 
-  def will_not_be_logged; false; end
+  # Override configuration options for any instance method(s), by passing a hash as the last argument
+  # In the last hash any non-Configuration keys will be data that gets logged,
+  #     and also made available to last_hash_to_s_proc
+  include DebugLogging::InstanceLogger.new(i_methods: [:faster], config: { add_invocation_id: false })
 
+  def will_not_be_logged; false; end
+  # == END INSTANCE METHODS ==
 end
 ```
 
@@ -195,28 +221,45 @@ Every time a method is called, class and instance method events are instrumented
 
 ```ruby
 class Car
-
-  # adds the helper methods to the class, all are prefixed with debug_*,
-  #   except for the instrumented class method, which comes from extending DebugLogging::ClassNotifier
+  # Adds the helper methods to the class.
+  #   All helpers prefixed with debug_*,
+  #   except for the *notifies* decorator, which comes from extending DebugLogging::ClassNotifier
   extend DebugLogging
 
   # For instance methods:
-  # Option 1: specify the exact method(s) to add instrumentation to (including capturing instance variable values as part of the event payload)
+  # Option 1: specify the exact method(s) to add instrumentation to
+  #   NOTE: You can capture instance variable values as part of the event payload
   include DebugLogging::InstanceNotifier.new(i_methods: [:drive,
                                                          :stop,
                                                          [:turn, { instance_variables: %i[direction angle] }]])
 
-  # Provides the `notifies` method decorator
+  # For class methods
+  #   Provides the versatile `notifies` method decorator / macro
+  # For instance methods
+  #   Provides the versatile `i_notifies` method decorator / macro
   extend DebugLogging::ClassNotifier
 
-  notifies def make; new; end
-  def design(*args); new; end
-  def safety(*args); new; end
-  def dealer_options(*args); new; end
-  notifies :design, :safety
-  # adding additional event payload options for any instance method(s), by passing a hash as the last argument
-  notifies :dealer_options, { sport_package: true }
+  # == BEGIN CLASS METHODS ==
+  # For class methods:
+  # Option 1: Use *notifies* as a method decorator
+  notifies def self.make; new; end
+  def self.design(*args); new; end
+  def self.safety(*args); new; end
+  def self.dealer_options(*args); new; end
 
+  # Option 2: Use *logged* as a macro
+  notifies :design, :safety
+  # Override configuration options for any class method(s), by passing a hash as the last argument
+  # In the last hash any non-Configuration keys will be data that gets added to the event payload,
+  #     and also made available to last_hash_to_s_proc
+  notifies :dealer_options, {
+    something: 'here', # <= will be added to the event payload, and be available to last_hash_to_s_proc
+    add_invocation_id: false # <= Overrides config
+  }
+  def self.will_not_be_notified; false; end
+  # == END CLASS METHODS ==
+
+  # == BEGIN INSTANCE METHODS ==
   def drive(speed); speed; end
   def stop(**opts); 0; end
 
@@ -224,8 +267,15 @@ class Car
   # Option 2: add instrumentation to all instance methods defined above (but *not* defined below)
   include DebugLogging::InstanceNotifier.new(i_methods: self.instance_methods(false))
 
-  def will_not_be_logged; false; end
+  def faster(**opts); 0; end
+
+  # Override options for any instance method(s), by passing a hash as the last argument
+  # In the last hash any non-Configuration keys will be data that gets added to the event payload,
+  #     and also made available to last_hash_to_s_proc
+  include DebugLogging::InstanceNotifier.new(i_methods: [:faster], config: { add_invocation_id: false })
 
+  def will_not_be_notified; false; end
+  # == END INSTANCE METHODS ==
 end
 ```
 

data/lib/debug_logging/argument_printer.rb

@@ -6,11 +6,9 @@ module DebugLogging
       "completed in #{format('%f', tms.real)}s (#{format('%f', tms.total)}s CPU)"
     end
 
-    def debug_event_name_to_s(method_to_notify: nil)
-      "#{method_to_notify}.log"
-    end
-
     def debug_invocation_id_to_s(args: nil, config_proxy: nil)
+      return '' unless args && config_proxy
+
       if config_proxy.debug_add_invocation_id
         invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..-4]}~"
         case config_proxy.debug_add_invocation_id
@@ -25,6 +23,8 @@ module DebugLogging
     end
 
     def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
+      return '' unless config_proxy
+
       klass_string = if config_proxy.debug_colorized_chain_for_class
                        config_proxy.debug_colorized_chain_for_class.call(ColorizedString[klass.to_s])
                      else
@@ -39,6 +39,8 @@ module DebugLogging
     end
 
     def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      return '' unless args && config_proxy
+
       printed_args = ''
 
       add_args_ellipsis = false
@@ -69,25 +71,56 @@ module DebugLogging
             printed_args += ', ' if !other_args_string.empty? && !last_hash_args_string.empty?
             printed_args += last_hash_args_string if last_hash_args_string && !last_hash_args_string.empty?
           else
-            printed_args += args[0..-2].map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }[0..(config_proxy.debug_args_max_length)]
+            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)]
             printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
-            printed_args += ", #{config_proxy.debug_last_hash_to_s_proc.call(args[-1]).tap { |x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length }[0..(config_proxy.debug_last_hash_max_length)]}"
+            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)]}"
             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 { |x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length }[0..(config_proxy.debug_last_hash_max_length)]
+          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)]
           printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
         end
       else
-        if args.length == 1 && args[0].is_a?(Hash)
-          # handle double splat
-          printed_args += ("**#{args.map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }}")[0..(config_proxy.debug_args_max_length)]
-        else
-          printed_args += args.map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }[0..(config_proxy.debug_args_max_length)]
-        end
+        printed_args += if args.length == 1 && args[0].is_a?(Hash)
+                          # handle double splat
+                          ("**#{args.map(&:inspect).join(', ').tap do |x|
+                                  add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                                end }")[0..(config_proxy.debug_args_max_length)]
+                        else
+                          args.map(&:inspect).join(', ').tap do |x|
+                            add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                          end [0..(config_proxy.debug_args_max_length)]
+                        end
         printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
       end
       "(#{printed_args})"
     end
+
+    def debug_payload_to_s(payload: nil, config_proxy: nil)
+      return '' unless payload && config_proxy
+
+      if payload
+        case config_proxy.debug_add_payload
+        when true
+          payload.inspect
+        else
+          config_proxy.debug_add_payload.call(**payload)
+        end
+      else
+        ''
+      end
+    end
+
+    module_function
+
+    def debug_event_name_to_s(method_to_notify: nil)
+      "#{method_to_notify}.log"
+    end
   end
 end

data/lib/debug_logging/class_logger.rb

@@ -5,7 +5,11 @@ module DebugLogging
     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
-      opts = methods_to_log.last.is_a?(Hash) && methods_to_log.pop
+      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
@@ -17,36 +21,58 @@ module DebugLogging
         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('k', method_to_log)))
+            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('kl',
+                                                                                                        method_to_log)))
                              proxy
                            else
-                             proxy = if opts
-                                       Configuration.new(**debug_config.to_hash.merge(opts))
-                                     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('k', method_to_log), proxy)
+                             instance_variable_set(DebugLogging::Configuration.config_pointer('kl', method_to_log),
+                                                   proxy)
                              proxy
                            end
             method_return_value = nil
             log_prefix = nil
             invocation_id = nil
             config_proxy.log do
-              log_prefix = debug_invocation_to_s(klass: to_s, separator: '.', method_to_log: method_to_log, config_proxy: config_proxy)
+              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
+              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)
-              "#{log_prefix}#{signature}#{invocation_id}"
+              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 = original_method.call(*args, &block)
+                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 = original_method.call(*args, &block)
+              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}"

data/lib/debug_logging/class_notifier.rb

@@ -3,7 +3,13 @@
 module DebugLogging
   module ClassNotifier
     def notifies(*methods_to_notify)
-      payload = methods_to_notify.last.is_a?(Hash) && methods_to_notify.pop || {}
+      # 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
@@ -13,34 +19,45 @@ module DebugLogging
         # method name must be a symbol
         method_to_notify = method_to_notify.to_sym
         original_method = method(method_to_notify)
-        config_proxy = nil
         (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('k', method_to_notify)))
+            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('kn',
+                                                                                                        method_to_notify)))
                              proxy
                            else
-                             proxy = if !payload.empty?
-                                       Configuration.new(**debug_config.to_hash.merge(payload))
-                                     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('k', method_to_notify), proxy)
+                             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
             ActiveSupport::Notifications.instrument(
-              debug_event_name_to_s(method_to_notify: method_to_notify), { args: args }.merge(payload)
+              DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
+              {
+                debug_args: args,
+                config_proxy: config_proxy,
+                **payload
+              }
             ) do
-              original_method.call(*args, &block)
+              if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                original_method.call(**harsh, &block)
+              else
+                original_method.call(*args, &block)
+              end
             end
           end
         end
-
-        ActiveSupport::Notifications.subscribe(/log/) do |*args|
-          config_proxy&.log do
-            DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
-          end
-        end
       end
     end
   end

data/lib/debug_logging/configuration.rb

@@ -3,13 +3,35 @@
 module DebugLogging
   class Configuration
     DEFAULT_ELLIPSIS = ' ✂️ …'
+    CONFIG_ATTRS_DEFAULTS = {
+      enabled: true,
+      logger: Logger.new($stdout),
+      log_level: :debug,
+      multiple_last_hashes: false,
+      last_hash_to_s_proc: nil,
+      last_hash_max_length: 1_000,
+      args_max_length: 1_000,
+      colorized_chain_for_method: false,
+      colorized_chain_for_class: false,
+      add_invocation_id: true,
+      ellipsis: DEFAULT_ELLIPSIS,
+      mark_scope_exit: false,
+      add_payload: true
+    }.freeze
+    CONFIG_ATTRS = CONFIG_ATTRS_DEFAULTS.keys
+    CONFIG_READERS_DEFAULTS = {
+      instance_benchmarks: false,
+      class_benchmarks: false,
+      active_support_notifications: false
+    }.freeze
+    CONFIG_READERS = CONFIG_READERS_DEFAULTS.keys
+    CONFIG_KEYS = CONFIG_ATTRS + CONFIG_READERS
+
     # For reference, log levels as integers mapped to symbols:
     # LEVELS = { 0 => :debug, 1 => :info, 2 => :warn, 3 => :error, 4 => :fatal, 5 => :unknown }
-    attr_accessor :enabled
-    attr_accessor :logger, :log_level, :multiple_last_hashes, :last_hash_to_s_proc, :last_hash_max_length,
-                  :args_max_length, :colorized_chain_for_method, :colorized_chain_for_class, :add_invocation_id,
-                  :ellipsis, :mark_scope_exit
-    attr_reader :instance_benchmarks, :class_benchmarks, :active_support_notifications, :methods_to_log
+    attr_accessor(*CONFIG_ATTRS)
+    attr_reader :methods_to_log, *CONFIG_READERS
+
     # alias the readers to the debug_* prefix so an instance of this class
     #   can have the same API granted by `extend DebugLogging`
     #
@@ -28,20 +50,9 @@ module DebugLogging
     #       }
     #     )
     #
-    alias debug_enabled enabled
-    alias debug_logger logger
-    alias debug_log_level log_level
-    alias debug_multiple_last_hashes multiple_last_hashes
-    alias debug_last_hash_to_s_proc last_hash_to_s_proc
-    alias debug_last_hash_max_length last_hash_max_length
-    alias debug_args_max_length args_max_length
-    alias debug_instance_benchmarks instance_benchmarks
-    alias debug_class_benchmarks class_benchmarks
-    alias debug_colorized_chain_for_method colorized_chain_for_method
-    alias debug_colorized_chain_for_class colorized_chain_for_class
-    alias debug_add_invocation_id add_invocation_id
-    alias debug_ellipsis ellipsis
-    alias debug_mark_scope_exit mark_scope_exit
+    CONFIG_KEYS.each do |key|
+      alias :"debug_#{key}" :"#{key}"
+    end
 
     class << self
       def config_pointer(type, method_to_log)
@@ -52,21 +63,12 @@ module DebugLogging
       end
     end
     def initialize(**options)
-      @enabled = options.key?(:enabled) ? options[:enabled] : true
-      @logger = options.key?(:logger) ? options[:logger] : Logger.new($stdout)
-      @log_level = options.key?(:log_level) ? options[:log_level] : :debug
-      @multiple_last_hashes = options.key?(:multiple_last_hashes) ? options[:multiple_last_hashes] : false
-      @last_hash_to_s_proc = options.key?(:last_hash_to_s_proc) ? options[:last_hash_to_s_proc] : nil
-      @last_hash_max_length = options.key?(:last_hash_max_length) ? options[:last_hash_max_length] : 1_000
-      @args_max_length = options.key?(:args_max_length) ? options[:args_max_length] : 1_000
-      @colorized_chain_for_method = options.key?(:colorized_chain_for_method) ? options[:colorized_chain_for_method] : false
-      @colorized_chain_for_class = options.key?(:colorized_chain_for_class) ? options[:colorized_chain_for_class] : false
-      @add_invocation_id = options.key?(:add_invocation_id) ? options[:add_invocation_id] : true
-      @ellipsis = options.key?(:ellipsis) ? options[:ellipsis] : DEFAULT_ELLIPSIS
-      @mark_scope_exit = options.key?(:mark_scope_exit) ? options[:mark_scope_exit] : false
-      self.instance_benchmarks = options.key?(:instance_benchmarks) ? options[:instance_benchmarks] : false
-      self.class_benchmarks = options.key?(:class_benchmarks) ? options[:class_benchmarks] : false
-      self.active_support_notifications = options.key?(:active_support_notifications) ? options[:active_support_notifications] : false
+      CONFIG_ATTRS.each do |key|
+        send("#{key}=", get_attr_from_options(options, key))
+      end
+      CONFIG_READERS.each do |key|
+        send("#{key}=", get_reader_from_options(options, key))
+      end
       @methods_to_log = []
     end
 
@@ -115,26 +117,23 @@ module DebugLogging
     end
 
     def to_hash
-      {
-        logger: logger,
-        log_level: log_level,
-        multiple_last_hashes: multiple_last_hashes,
-        last_hash_to_s_proc: last_hash_to_s_proc,
-        last_hash_max_length: last_hash_max_length,
-        args_max_length: args_max_length,
-        instance_benchmarks: instance_benchmarks,
-        class_benchmarks: class_benchmarks,
-        colorized_chain_for_method: colorized_chain_for_method,
-        colorized_chain_for_class: colorized_chain_for_class,
-        add_invocation_id: add_invocation_id,
-        ellipsis: ellipsis,
-        mark_scope_exit: mark_scope_exit,
-        active_support_notifications: active_support_notifications
-      }
+      CONFIG_KEYS.each_with_object({}) do |key, hash|
+        hash[key] = instance_variable_get("@#{key}")
+      end
     end
 
     def register(method_lo_log)
       @methods_to_log << method_lo_log
     end
+
+    private
+
+    def get_attr_from_options(options, key)
+      options.key?(key) ? options[key] : CONFIG_ATTRS_DEFAULTS[key]
+    end
+
+    def get_reader_from_options(options, key)
+      options.key?(key) ? options[key] : CONFIG_READERS_DEFAULTS[key]
+    end
   end
 end

data/lib/debug_logging/instance_logger.rb

@@ -12,7 +12,8 @@ module DebugLogging
       return unless @instance_methods_to_log
 
       base.send(:include, ArgumentPrinter)
-      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(methods_to_log: @instance_methods_to_log, config: @config)
+      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(methods_to_log: @instance_methods_to_log,
+                                                                            config: @config)
       base.send(:prepend, instance_method_logger)
     end
   end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -5,26 +5,52 @@ module DebugLogging
     def self.to_mod(methods_to_log: nil, config: nil)
       Module.new do
         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
-          define_method(method_to_log.to_sym) do |*args, &block|
+          method_to_log = if method_to_log.is_a?(Array)
+                            method_to_log.first&.to_sym
+                          else
+                            method_to_log.to_sym
+                          end
+          define_method(method_to_log) do |*args, &block|
             method_return_value = nil
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('i', method_to_log)))
+            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))
+                                       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('i', method_to_log), proxy)
+                             instance_variable_set(DebugLogging::Configuration.config_pointer('ilm', method_to_log),
+                                                   proxy)
                              proxy
                            end
-            log_prefix = self.class.debug_invocation_to_s(klass: self.class.to_s, separator: '#', method_to_log: method_to_log, config_proxy: config_proxy)
+            log_prefix = self.class.debug_invocation_to_s(klass: self.class.to_s, separator: '#',
+                                                          method_to_log: method_to_log, config_proxy: config_proxy)
             invocation_id = self.class.debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
             config_proxy.log do
+              paydirt = {}
+              # 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
               signature = self.class.debug_signature_to_s(args: args, config_proxy: config_proxy)
-              "#{log_prefix}#{signature}#{invocation_id}"
+              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_instance_benchmarks)
               tms = Benchmark.measure do

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -4,42 +4,57 @@ module DebugLogging
   module InstanceNotifierModulizer
     def self.to_mod(methods_to_notify: nil)
       Module.new do
+        config_proxy = nil
+
         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 || {}
-          if method_to_notify.is_a?(Array)
-            method_to_notify = method_to_notify.first&.to_sym
-          else
-            method_to_notify.to_sym
+          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
-          config_proxy = nil
+          method_to_notify = if method_to_notify.is_a?(Array)
+                               method_to_notify.first&.to_sym
+                             else
+                               method_to_notify.to_sym
+                             end
           define_method(method_to_notify) do |*args, &block|
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('i', method_to_notify)))
+            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('inm',
+                                                                                                        method_to_notify)))
                              proxy
                            else
-                             proxy = if !payload.empty?
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(payload))
-                                     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('i', method_to_notify), proxy)
+                             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|
-                payload[k] = instance_variable_get("@#{k}") if instance_variable_get("@#{k}")
+                paydirt[k] = instance_variable_get("@#{k}") if instance_variable_defined?("@#{k}")
               end
-              payload.delete(:instance_variables)
+            else
+              paydirt.merge!(payload)
             end
             ActiveSupport::Notifications.instrument(
-              self.class.debug_event_name_to_s(method_to_notify: method_to_notify), { args: args }.merge(payload)
+              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(/log/) do |*args|
+          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

data/lib/debug_logging/log_subscriber.rb

@@ -4,31 +4,39 @@ require 'active_support/log_subscriber'
 
 module DebugLogging
   class LogSubscriber < ActiveSupport::LogSubscriber
+    EXCLUDE_FROM_PAYLOAD = %i[debug_args config_proxy].freeze
+    extend DebugLogging::ArgumentPrinter
+
     class << self
       attr_accessor :event
     end
     attach_to :log
 
-    EVENT_FORMAT_STRING = '%<name>s (%<duration>.3f secs) start=%<time>s end=%<end>s payload=%<payload>s'
+    EVENT_FORMAT_STRING = '%<name>s (%<duration>.3f secs) start=%<time>s end=%<end>s args=%<args>s payload=%<payload>s'
 
     def self.log_event(event)
       @event = event
       if event.payload && event.payload[:exception_object]
         exception = event.payload[:exception_object]
         "#{event.name} [ERROR] : \n#{exception.class} : #{exception.message}\n" + exception.backtrace.join("\n")
+      else
+        format(EVENT_FORMAT_STRING, event_to_format_options(event))
       end
-      format(EVENT_FORMAT_STRING, event_to_format_options(event))
     end
 
     # @param [ActiveSupport::Notifications::Event]
     # @return [Hash]
     def self.event_to_format_options(event)
+      args = event.payload[:debug_args]
+      config_proxy = event.payload[:config_proxy]
+      payload = event.payload.reject { |k, _| EXCLUDE_FROM_PAYLOAD.include?(k) }
       {
         name: event.name,
         duration: Rational(event.duration, 1000).to_f,
         time: event.time,
         end: event.end,
-        payload: event.payload
+        args: debug_signature_to_s(args: args, config_proxy: config_proxy),
+        payload: debug_payload_to_s(payload: payload, config_proxy: config_proxy)
       }
     end
   end

data/lib/debug_logging/version.rb

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

data/lib/simple_debug_logging.rb

@@ -48,6 +48,7 @@ class SimpleDebugLogging < Module
     base.send(:prepend, instance_method_logger)
     base.send(:extend, ClassMethodLogger)
   end
+
   module ClassMethodLogger
     def logged(*methods_to_log)
       methods_to_log.each do |method_to_log|
@@ -67,6 +68,7 @@ class SimpleDebugLogging < Module
       end
     end
   end
+
   module InstanceMethodLoggerModulizer
     def self.to_mod(methods_to_log = [])
       Module.new do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Peter Boling
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-24 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -195,7 +195,7 @@ homepage: https://github.com/pboling/debug_logging
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -211,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.4
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Drop-in debug logging useful when a call stack gets unruly
 test_files: []