debug_logging 1.0.17 → 3.1.2

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "debug_logging"
+require 'bundler/setup'
+require 'debug_logging'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "debug_logging"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/debug_logging.gemspec

@@ -1,34 +1,42 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'debug_logging/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "debug_logging"
+  spec.name          = 'debug_logging'
   spec.version       = DebugLogging::VERSION
-  spec.authors       = ["Peter Boling"]
-  spec.email         = ["peter.boling@gmail.com"]
+  spec.authors       = ['Peter Boling']
+  spec.email         = ['peter.boling@gmail.com']
 
-  spec.summary       = %q{Drop-in debug logging useful when a call stack gets unruly}
-  spec.description   = %q{
+  spec.summary       = 'Drop-in debug logging useful when a call stack gets unruly'
+  spec.description   = '
 Unobtrusive debug logging for Ruby.  NO LITTERING.
 Automatically log selected methods and their arguments as they are called at runtime!
-}
-  spec.license       = "MIT"
-  spec.homepage      = "https://github.com/pboling/debug_logging"
+'
+  spec.license       = 'MIT'
+  spec.homepage      = 'https://github.com/pboling/debug_logging'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.0.0" # Uses named parameters
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4.0' # Uses magic comments
 
-  spec.add_runtime_dependency "colorize", "~> 0.8"
-  spec.add_development_dependency "rspec-pending_for"
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 12.2"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "activesupport", "~> 5.1"
+  spec.add_runtime_dependency 'colorize', '>= 0'
+  spec.add_development_dependency 'activesupport', '~> 5.2', '>= 5.2.4.4'
+  spec.add_development_dependency 'bundler', '>= 2'
+  spec.add_development_dependency 'byebug', '>= 11'
+  spec.add_development_dependency 'rake', '>= 13'
+  spec.add_development_dependency 'rspec', '>= 3'
+  spec.add_development_dependency 'rspec-pending_for', '>= 0'
+  spec.add_development_dependency 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-md'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
+  spec.add_development_dependency 'silent_stream', '>= 1'
 end

data/lib/debug_logging.rb

@@ -1,13 +1,15 @@
-require "logger"
-require "colorized_string"
-require "digest"
+# frozen_string_literal: true
 
-require "debug_logging/version"
-require "debug_logging/configuration"
-require "debug_logging/argument_printer"
-require "debug_logging/instance_logger_modulizer"
-require "debug_logging/instance_logger"
-require "debug_logging/class_logger"
+require 'logger'
+require 'colorized_string'
+require 'digest'
+
+require 'debug_logging/version'
+require 'debug_logging/configuration'
+require 'debug_logging/argument_printer'
+require 'debug_logging/instance_logger_modulizer'
+require 'debug_logging/instance_logger'
+require 'debug_logging/class_logger'
 
 ####################
 #                  #
@@ -62,12 +64,12 @@ module DebugLogging
   end
 
   #### API ####
-  # Not used by this gem internally, but provides an external interface for 
+  # Not used by this gem internally, but provides an external interface for
   #   classes to also use this logging tool directly,
   #   with configured options like benchmarking, colors, or leg level.
   def debug_log(message = nil, config_proxy = nil, &block)
     # If a, instance-method-level, or class-method-level custom config is not
-    #   passed in, then fall back to the class' default config, which is a 
+    #   passed in, then fall back to the class' default config, which is a
     #   potentially customized copy of the default config for the whole app.
     config_proxy ||= debug_config
     config_proxy.log(message, &block)
@@ -103,87 +105,115 @@ module DebugLogging
   def debug_config_reset(config = Configuration.new)
     @debug_logging_configuration = config
   end
+
   def debug_enabled
     @debug_logging_configuration.enabled
   end
+
   def debug_enabled=(value)
     @debug_logging_configuration.enabled = value
   end
+
   def debug_logger
     @debug_logging_configuration.logger
   end
+
   def debug_logger=(logger)
     @debug_logging_configuration.logger = logger
   end
+
   def debug_log_level
     @debug_logging_configuration.log_level
   end
+
   def debug_log_level=(log_level)
     @debug_logging_configuration.log_level = log_level
   end
+
   def debug_multiple_last_hashes
     @debug_logging_configuration.multiple_last_hashes
   end
+
   def debug_multiple_last_hashes=(multiple_last_hashes)
     @debug_logging_configuration.multiple_last_hashes = multiple_last_hashes
   end
+
   def debug_last_hash_to_s_proc
     @debug_logging_configuration.last_hash_to_s_proc
   end
+
   def debug_last_hash_to_s_proc=(last_hash_to_s_proc)
     @debug_logging_configuration.last_hash_to_s_proc = last_hash_to_s_proc
   end
+
   def debug_last_hash_max_length
     @debug_logging_configuration.last_hash_max_length
   end
+
   def debug_last_hash_max_length=(last_hash_max_length)
     @debug_logging_configuration.last_hash_max_length = last_hash_max_length
   end
+
   def debug_args_max_length
     @debug_logging_configuration.args_max_length
   end
+
   def debug_args_max_length=(args_max_length)
     @debug_logging_configuration.args_max_length = args_max_length
   end
+
   def debug_instance_benchmarks
     @debug_logging_configuration.instance_benchmarks
   end
+
   def debug_instance_benchmarks=(instance_benchmarks)
     @debug_logging_configuration.instance_benchmarks = instance_benchmarks
   end
+
   def debug_class_benchmarks
     @debug_logging_configuration.class_benchmarks
   end
+
   def debug_class_benchmarks=(class_benchmarks)
     @debug_logging_configuration.class_benchmarks = class_benchmarks
   end
+
   def debug_colorized_chain_for_method
     @debug_logging_configuration.colorized_chain_for_method
   end
+
   def debug_colorized_chain_for_method=(colorized_chain_for_method)
     @debug_logging_configuration.colorized_chain_for_method = colorized_chain_for_method
   end
+
   def debug_colorized_chain_for_class
     @debug_logging_configuration.colorized_chain_for_class
   end
+
   def debug_colorized_chain_for_class=(colorized_chain_for_class)
     @debug_logging_configuration.colorized_chain_for_class = colorized_chain_for_class
   end
+
   def debug_add_invocation_id
     @debug_logging_configuration.add_invocation_id
   end
+
   def debug_add_invocation_id=(add_invocation_id)
     @debug_logging_configuration.add_invocation_id = add_invocation_id
   end
+
   def debug_mark_scope_exit
     @debug_logging_configuration.mark_scope_exit
   end
+
   def debug_mark_scope_exit=(mark_scope_exit)
     @debug_logging_configuration.mark_scope_exit = mark_scope_exit
   end
+
   def debug_ellipsis
     @debug_logging_configuration.ellipsis
   end
+
   def debug_ellipsis=(ellipsis)
     @debug_logging_configuration.ellipsis = ellipsis
   end

data/lib/debug_logging/active_support_notifications.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'debug_logging/log_subscriber'
+require 'debug_logging/class_notifier'
+require 'debug_logging/instance_notifier_modulizer'
+require 'debug_logging/instance_notifier'

data/lib/debug_logging/argument_printer.rb

@@ -1,22 +1,30 @@
+# frozen_string_literal: true
+
 module DebugLogging
   module ArgumentPrinter
     def debug_benchmark_to_s(tms: nil)
-      "completed in #{sprintf("%f", tms.real)}s (#{sprintf("%f", tms.total)}s CPU)"
+      "completed in #{format('%f', tms.real)}s (#{format('%f', tms.total)}s CPU)"
     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)]}~"
+        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..-4]}~"
         case config_proxy.debug_add_invocation_id
-        when true then
+        when true
           invocation
         else
           config_proxy.debug_add_invocation_id.call(ColorizedString[invocation])
         end
       else
-        ""
+        ''
       end
     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
@@ -29,52 +37,90 @@ module DebugLogging
                       end
       "#{klass_string}#{separator}#{method_string}"
     end
-    def debug_signature_to_s(args: nil, config_proxy: nil)
-      printed_args = ""
+
+    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity
+      return '' unless args && config_proxy
+
+      printed_args = ''
+
       add_args_ellipsis = false
       if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
+        add_last_hash_ellipsis = false
         if args.length > 1
-          add_last_hash_ellipsis = false
           if config_proxy.debug_multiple_last_hashes
             last_hash_args, other_args = args.partition do |arg|
-                                            arg.is_a?(Hash)
-                                          end
-            other_args_string = other_args.map(&:inspect).join(", ")[0..(config_proxy.debug_args_max_length)]
-              # On the debug_multiple_last_hashes truthy branch we don't print the ellipsis after regular args
-              #   because it will go instead after the last hash (if needed)
-              #   ...join(", ").tap {|x| _add_args_ellipsis = x.length > config_proxy.debug_args_max_length}
+              arg.is_a?(Hash)
+            end
+            other_args_string = other_args.map(&:inspect).join(', ')[0..(config_proxy.debug_args_max_length)]
+            # On the debug_multiple_last_hashes truthy branch we don't print the ellipsis after regular args
+            #   because it will go instead after the last hash (if needed)
+            #   ...join(", ").tap {|x| _add_args_ellipsis = x.length > config_proxy.debug_args_max_length}
             last_hash_args_string = last_hash_args.map do |arg|
-                                      config_proxy.debug_last_hash_to_s_proc.call(arg).to_s.
-                                          tap {|x|
-                                                add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
-                                              }[0..(config_proxy.debug_last_hash_max_length)].
-                                          tap {|x|
-                                                x << config_proxy.debug_ellipsis if add_last_hash_ellipsis
-                                              }
-                                    end.join(", ")
-            printed_args << other_args_string if other_args_string
-            printed_args << ", " if !other_args_string.empty? && !last_hash_args_string.empty?
-            printed_args << last_hash_args_string if last_hash_args_string
+              arr = []
+              arr << config_proxy.debug_last_hash_to_s_proc.call(arg).to_s
+                                 .tap do |x|
+                add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
+              end
+              if add_last_hash_ellipsis
+                arr[-1] = arr[-1][0..(config_proxy.debug_last_hash_max_length)]
+                arr << config_proxy.debug_ellipsis
+              end
+              arr
+            end.flatten.join(', ')
+            printed_args += other_args_string if other_args_string
+            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 {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length}[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_ellipsis if add_last_hash_ellipsis
+            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 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 << config_proxy.debug_ellipsis if add_last_hash_ellipsis
+          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 {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length})[0..(config_proxy.debug_args_max_length)]
+        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
-          printed_args << args.map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length}[0..(config_proxy.debug_args_max_length)]
+          config_proxy.debug_add_payload.call(**payload)
         end
-        printed_args << config_proxy.debug_ellipsis if add_args_ellipsis
+      else
+        ''
       end
-      "(#{printed_args})"
+    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

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 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
-      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
@@ -15,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}"