debug_logging 2.0.0 → 3.1.3

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'
@@ -24,15 +24,19 @@ Automatically log selected methods and their arguments as they are called at run
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.3.0' # Uses magic comments
+  spec.required_ruby_version = '>= 2.4.0' # Uses magic comments
 
   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', '>= 0'
-  spec.add_development_dependency 'rubocop-rspec', '>= 1'
+  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

@@ -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/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

@@ -2,11 +2,13 @@
 
 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
 
     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
@@ -21,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
@@ -34,7 +38,9 @@ module DebugLogging
       "#{klass_string}#{separator}#{method_string}"
     end
 
-    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    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
@@ -65,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

@@ -3,50 +3,55 @@
 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
-      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('k', method_to_log)))
-                             proxy
-                           else
-                             proxy = if opts
-                                       Configuration.new(**debug_config.to_hash.merge(opts))
-                                     else
-                                       debug_config
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('k', 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
-              log_prefix = debug_invocation_to_s(klass: to_s, separator: '.', method_to_log: method_to_log, config_proxy: config_proxy)
+              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)
               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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  module ClassNotifier
+    def notifies(*methods_to_notify)
+      methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_notify,
+        payload: nil,
+        config: nil
+      )
+      Array(methods_to_notify).each do |method_to_notify|
+        method_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: method_to_notify,
+          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 = 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,
+                **paydirt
+              }
+            ) do
+              if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                original_method.call(**harsh, &block)
+              else
+                original_method.call(*args, &block)
+              end
+            end
+          end
+        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, :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_method :"debug_#{key}", :"#{key}"
+    end
 
     class << self
       def config_pointer(type, method_to_log)
@@ -52,20 +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
-      @instance_benchmarks = options.key?(:instance_benchmarks) ? options[:instance_benchmarks] : false
-      @class_benchmarks = options.key?(:class_benchmarks) ? options[:class_benchmarks] : false
-      @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
+      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
 
@@ -73,7 +76,7 @@ module DebugLogging
       return unless enabled
       return unless logger
 
-      if block_given?
+      if block
         logger.send(log_level, &block)
       else
         logger.send(log_level, message)
@@ -108,26 +111,29 @@ module DebugLogging
       @class_benchmarks = class_benchmarks
     end
 
+    def active_support_notifications=(active_support_notifications)
+      require 'debug_logging/active_support_notifications' if active_support_notifications
+      @active_support_notifications = active_support_notifications
+    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
-      }
+      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/errors.rb

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