debug_logging 3.1.0 → 3.1.5

data/lib/debug_logging/errors.rb

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

data/lib/debug_logging/finalize.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# From: https://stackoverflow.com/a/34559282
+# License: https://creativecommons.org/licenses/by-sa/4.0/
+module DebugLogging
+  module Finalize
+    def self.extended(obj)
+      TracePoint.trace(:end) do |t|
+        if obj == t.self
+          if obj.respond_to?(:debug_finalize)
+            obj.debug_finalize
+          else
+            warn "#{obj} does not define a debug_finalize"
+          end
+          t.disable
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/hooks.rb

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

data/lib/debug_logging/instance_logger.rb

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

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -2,29 +2,35 @@
 
 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|
-          # method name must be a symbol
-          define_method(method_to_log.to_sym) do |*args, &block|
+          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('i', method_to_log)))
-                             proxy
-                           else
-                             proxy = if config
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config))
-                                     else
-                                       self.class.debug_config
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('i', 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)
+            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 = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
               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.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,48 +2,44 @@
 
 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
+        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 || {}
-          if method_to_notify.is_a?(Array)
-            method_to_notify = method_to_notify.first&.to_sym
-          else
-            method_to_notify.to_sym
-          end
-          config_proxy = nil
+          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('i', method_to_notify)))
-                             proxy
-                           else
-                             proxy = if !payload.empty?
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(payload))
-                                     else
-                                       self.class.debug_config
-                                     end
-                             proxy.register(method_to_notify)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('i', method_to_notify), proxy)
-                             proxy
-                           end
-            if payload.key?(:instance_variables)
-              payload[:instance_variables].each do |k|
-                payload[k] = instance_variable_get("@#{k}") if instance_variable_get("@#{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
-              payload.delete(:instance_variables)
             end
+            paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
             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|
-            config_proxy&.log do
-              DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
-            end
-          end
         end
       end
     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/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.0'
+  VERSION = '3.1.5'
 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,15 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.5
 platform: ruby
 authors:
 - Peter Boling
-autorequire: 
+- guckin
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-24 00:00:00.000000000 Z
+date: 2020-12-18 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,18 +227,22 @@ files:
 - lib/debug_logging/class_logger.rb
 - lib/debug_logging/class_notifier.rb
 - lib/debug_logging/configuration.rb
+- lib/debug_logging/errors.rb
+- lib/debug_logging/finalize.rb
+- lib/debug_logging/hooks.rb
 - lib/debug_logging/instance_logger.rb
 - lib/debug_logging/instance_logger_modulizer.rb
 - lib/debug_logging/instance_notifier.rb
 - lib/debug_logging/instance_notifier_modulizer.rb
 - lib/debug_logging/log_subscriber.rb
+- lib/debug_logging/util.rb
 - lib/debug_logging/version.rb
 - lib/simple_debug_logging.rb
 homepage: https://github.com/pboling/debug_logging
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -210,8 +257,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.2.1
+signing_key:
 specification_version: 4
 summary: Drop-in debug logging useful when a call stack gets unruly
 test_files: []