debug_logging 3.1.2 → 3.1.8

data/lib/debug_logging/class_logger.rb

@@ -3,83 +3,70 @@
 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
-      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
-        # 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('kl',
-                                                                                                        method_to_log)))
-                             proxy
-                           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('kl', 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
-              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}")
+            begin
+              config_proxy.log do
+                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)
+                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 = 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
-                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)
-              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 = 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 = 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}"
+                if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+                  config_proxy.log do
+                    "#{log_prefix} completed#{invocation_id}"
+                  end
                 end
               end
+              method_return_value
+            rescue => error
+              if config_proxy.error_handler_proc
+                config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_log, args)
+              else
+                raise error
+              end
             end
-            method_return_value
           end
         end
       end

data/lib/debug_logging/class_notifier.rb

@@ -3,57 +3,55 @@
 module DebugLogging
   module ClassNotifier
     def notifies(*methods_to_notify)
-      # 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
-        # logged :meth1, :meth2, :meth3 without options is valid too
-      end
-      methods_to_notify.each do |method_to_notify|
-        # method name must be a symbol
-        method_to_notify = method_to_notify.to_sym
+      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 = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('kn',
-                                                                                                        method_to_notify)))
-                             proxy
-                           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('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
+            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,
-                **payload
+                **paydirt
               }
             ) do
-              if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
-                original_method.call(**harsh, &block)
-              else
-                original_method.call(*args, &block)
+              begin
+                if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                  original_method.call(**harsh, &block)
+                else
+                  original_method.call(*args, &block)
+                end
+              rescue => error
+                if config_proxy.error_handler_proc
+                  config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_notify, args)
+                else
+                  raise error
+                end
               end
             end
           end

data/lib/debug_logging/configuration.rb

@@ -2,31 +2,7 @@
 
 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
-
+    include Constants
     # For reference, log levels as integers mapped to symbols:
     # LEVELS = { 0 => :debug, 1 => :info, 2 => :warn, 3 => :error, 4 => :fatal, 5 => :unknown }
     attr_accessor(*CONFIG_ATTRS)
@@ -42,6 +18,7 @@ module DebugLogging
     #           log_level: :debug # at what level do the messages created by this gem sent at?
     #           last_hash_to_s_proc: nil # e.g. ->(hash) { "keys: #{hash.keys}" }
     #           last_hash_max_length: 1_000
+    #           args_to_s_proc: nil # e.g. ->(record) { "record id: #{record.id}" }
     #           args_max_length: 1_000
     #           instance_benchmarks: false
     #           class_benchmarks: false

data/lib/debug_logging/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  module Constants
+    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_to_s_proc: nil,
+      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, # Can also be a proc returning a string, which will be called when printing the payload
+      payload_max_length: 1_000,
+      error_handler_proc: nil
+    }.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
+  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

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
 
@@ -13,6 +14,7 @@ module DebugLogging
 
       base.send(:include, ArgumentPrinter)
       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

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -2,52 +2,32 @@
 
 module DebugLogging
   module InstanceLoggerModulizer
-    def self.to_mod(methods_to_log: nil, config: nil)
+    def self.to_mod(methods_to_log: nil, payload: nil, config: nil)
       Module.new do
+        methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: Array(methods_to_log),
+          payload: payload,
+          config: config
+        )
         Array(methods_to_log).each do |method_to_log|
-          payload = (method_to_log.is_a?(Array) && method_to_log.last.is_a?(Hash) && method_to_log.pop.dup) || {}
-          config_opts = {}
-          unless payload.empty?
-            DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
-          end
-          # method name must be a symbol
-          method_to_log = if method_to_log.is_a?(Array)
-                            method_to_log.first&.to_sym
-                          else
-                            method_to_log.to_sym
-                          end
+          method_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+            method_names: method_to_log,
+            payload: payload,
+            config: config_opts
+          )
           define_method(method_to_log) do |*args, &block|
             method_return_value = nil
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('ilm',
-                                                                                                        method_to_log)))
-                             proxy
-                           else
-                             proxy = if config
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config.merge(config_opts)))
-                                     elsif !config_opts.empty?
-                                       Configuration.new(**self.class.debug_config.to_hash.merge(config_opts))
-                                     else
-                                       self.class.debug_config
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('ilm', method_to_log),
-                                                   proxy)
-                             proxy
-                           end
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self.class,
+              config_opts: method_config_opts,
+              method_name: method_to_log,
+              proxy_ref: 'ilm'
+            )
             log_prefix = self.class.debug_invocation_to_s(klass: self.class.to_s, separator: '#',
                                                           method_to_log: method_to_log, config_proxy: config_proxy)
             invocation_id = self.class.debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
             config_proxy.log do
-              paydirt = {}
-              # TODO: Could make instance variable introspection configurable before or after method execution
-              if payload.key?(:instance_variables)
-                paydirt.merge!(payload.reject { |k| k == :instance_variables })
-                payload[:instance_variables].each do |k|
-                  paydirt[k] = instance_variable_get("@#{k}") if instance_variable_defined?("@#{k}")
-                end
-              else
-                paydirt.merge!(payload)
-              end
+              paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
               signature = self.class.debug_signature_to_s(args: args, config_proxy: config_proxy)
               paymud = debug_payload_to_s(payload: paydirt, config_proxy: config_proxy)
               "#{log_prefix}#{signature}#{invocation_id} debug: #{paymud}"
@@ -60,7 +40,15 @@ module DebugLogging
                 "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
               end
             else
-              method_return_value = super(*args, &block)
+              begin
+                method_return_value = super(*args, &block)
+              rescue => error
+                if config_proxy.error_handler_proc
+                  config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_log, args)
+                else
+                  raise error
+                end
+              end
               if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
                 config_proxy.log do
                   "#{log_prefix} completed#{invocation_id}"