debug_logging 3.1.8 → 4.0.0

data/lib/debug_logging/hooks.rb

@@ -1,5 +1,5 @@
-require 'debug_logging/errors'
-require 'timeout'
+require "debug_logging/errors"
+require "timeout"
 
 module DebugLogging
   module Hooks
@@ -16,16 +16,14 @@ module DebugLogging
         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)
+            Timeout.timeout(time) do
+              meth.bind_call(self, *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
@@ -33,17 +31,15 @@ module DebugLogging
       def debug_rescue_on_fail(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.rescue_on_fail must be called with a block',
-                caller
+            ".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
+            meth.bind_call(self, *args, &block)
+          rescue StandardError => e
+            instance_exec(e, &blk)
           end
         end
       end
@@ -51,14 +47,14 @@ module DebugLogging
       def debug_before(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.before must be called with a block',
-                caller
+            ".before must be called with a block",
+            caller
         end
         names.each do |name|
           meth = instance_method(name)
-          define_method name do |*args, &block|
+          define_method(name) do |*args, &block|
             instance_exec(name, *args, block, &blk)
-            meth.bind(self).call(*args, &block)
+            meth.bind_call(self, *args, &block)
           end
         end
       end
@@ -66,13 +62,13 @@ module DebugLogging
       def debug_after(*names, &blk)
         unless blk
           raise NoBlockGiven,
-                '.after must be called with a block',
-                caller
+            ".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)
+          define_method(name) do |*args, &block|
+            result = meth.bind_call(self, *args, &block)
             instance_exec(result, &blk)
           end
         end

data/lib/debug_logging/instance_logger.rb

@@ -1,22 +1,28 @@
-# frozen_string_literal: true
-
 module DebugLogging
-  class InstanceLogger < Module
-    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
-
-    def included(base)
-      return unless @instance_methods_to_log
+  module InstanceLogger
+    def i_logged(*methods_to_log)
+      methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_log,
+        payload: nil,
+        config: nil,
+      )
+      instance_method_modules =
+        Array(methods_to_log).map do |method_to_log|
+          DebugLogging::InstanceLoggerModulizer.to_mod(
+            methods_to_log: Array(method_to_log),
+            payload: payload,
+            config: config_opts,
+          )
+        end
+      wrapped_in_logs = Module.new do
+        singleton_class.send(:define_method, :included) do |host_class|
+          instance_method_modules.each do |mod|
+            host_class.prepend(mod)
+          end
+        end
+      end
 
-      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)
+      send(:include, wrapped_in_logs)
     end
   end
 end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -1,61 +1,65 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module InstanceLoggerModulizer
-    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_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
-            method_names: method_to_log,
-            payload: payload,
-            config: config_opts
+    class << self
+      def 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:,
+            config:,
           )
-          define_method(method_to_log) do |*args, &block|
-            method_return_value = nil
-            config_proxy = DebugLogging::Util.config_proxy_finder(
-              scope: self.class,
-              config_opts: method_config_opts,
-              method_name: method_to_log,
-              proxy_ref: 'ilm'
+          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:,
+              config: config_opts,
             )
-            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)
-              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
-                method_return_value = super(*args, &block)
-              end
+            define_method(method_to_log) do |*args, **kwargs, &block|
+              method_return_value = nil
+              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:, kwargs:, config_proxy:)
               config_proxy.log do
-                "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+                paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
+                signature = self.class.debug_signature_to_s(args:, kwargs:, config_proxy:)
+                paymud = debug_payload_to_s(payload: paydirt, config_proxy:)
+                "#{log_prefix}#{signature}#{invocation_id} debug: #{paymud}"
               end
-            else
-              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
+              if config_proxy.benchmarkable_for?(:debug_instance_benchmarks)
+                tms = Benchmark.measure do
+                  method_return_value = super(*args, **kwargs, &block)
                 end
-              end
-              if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
                 config_proxy.log do
-                  "#{log_prefix} completed#{invocation_id}"
+                  "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+                end
+              else
+                begin
+                  method_return_value = super(*args, **kwargs, &block)
+                rescue StandardError => e
+                  if config_proxy.error_handler_proc
+                    config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args, kwargs)
+                  else
+                    raise e
+                  end
+                end
+                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
             end
-            method_return_value
           end
         end
       end

data/lib/debug_logging/instance_notifier.rb

@@ -1,22 +1,24 @@
-# frozen_string_literal: true
-
 module DebugLogging
-  class InstanceNotifier < Module
-    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
+  module InstanceNotifier
+    def i_notified(*methods_to_log)
+      method_names, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_log,
+        payload: nil,
+        config: nil,
+      )
+      instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(
+        methods_to_notify: Array(method_names),
+        payload: payload,
+        config: config_opts,
+      )
 
-    def included(base)
-      return unless @instance_methods_to_notify
+      wrapped_in_notifier = Module.new do
+        singleton_class.send(:define_method, :included) do |host_class|
+          host_class.prepend(instance_method_notifier)
+        end
+      end
 
-      base.send(:include, ArgumentPrinter)
-      instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(methods_to_notify: @instance_methods_to_notify,
-                                                                                payload: @payload,
-                                                                                config: @config)
-      base.send(:prepend, instance_method_notifier)
+      send(:include, wrapped_in_notifier)
     end
   end
 end

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -1,49 +1,47 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module InstanceNotifierModulizer
-    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_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
-            method_names: method_to_notify,
-            payload: payload,
-            config: config_opts
+    class << self
+      def 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:,
+            config:,
           )
-          define_method(method_to_notify) do |*args, &block|
-            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))
+          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:,
+              config: config_opts,
+            )
+            define_method(method_to_notify) do |*args, **kwargs, &block|
+              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:),
+                ) do |*subscribe_args|
+                  config_proxy&.log do
+                    DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*subscribe_args))
+                  end
                 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
-              begin
-                super(*args, &block)
-              rescue => error
+              paydirt = DebugLogging::Util.payload_instance_variable_hydration(scope: self, payload: method_payload)
+              ActiveSupport::Notifications.instrument(
+                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify:),
+                debug_args: kwargs.empty? ? args : args + [kwargs],
+                config_proxy: config_proxy,
+                **paydirt,
+              ) do
+                super(*args, **kwargs, &block)
+              rescue StandardError => e
                 if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, error, self, method_to_notify, args)
+                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args, kwargs)
                 else
-                  raise error
+                  raise e
                 end
               end
             end

data/lib/debug_logging/log_subscriber.rb

@@ -1,6 +1,5 @@
-# frozen_string_literal: true
-
-require 'active_support/log_subscriber'
+require "active_support"
+require "active_support/log_subscriber"
 
 module DebugLogging
   class LogSubscriber < ActiveSupport::LogSubscriber
@@ -12,7 +11,7 @@ module DebugLogging
     end
     attach_to :log
 
-    EVENT_FORMAT_STRING = '%<name>s (%<duration>.3f secs) start=%<time>s end=%<end>s args=%<args>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
@@ -33,10 +32,10 @@ module DebugLogging
       {
         name: event.name,
         duration: Rational(event.duration, 1000).to_f,
-        time: event.time,
-        end: event.end,
+        time: debug_time_to_s(event.time),
+        end: debug_time_to_s(event.end),
         args: debug_signature_to_s(args: args, config_proxy: config_proxy),
-        payload: debug_payload_to_s(payload: payload, config_proxy: config_proxy)
+        payload: debug_payload_to_s(payload: payload, config_proxy: config_proxy),
       }
     end
   end

data/lib/debug_logging/util.rb

@@ -9,11 +9,12 @@ module DebugLogging
       # 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
+        payload.merge(scoped_payload)
+      else
+        scoped_payload
+      end
       config_opts = config&.clone(freeze: false) || {}
+      # puts "[EPAC] config: #{config}, scoped_payload: #{scoped_payload}, payload: #{payload}, config_opts: #{config_opts}"
       unless payload.empty?
         DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
       end
@@ -39,7 +40,7 @@ module DebugLogging
       [method_names, payload, config_opts]
     end
 
-    def payload_instance_vaiable_hydration(scope:, payload:)
+    def payload_instance_variable_hydration(scope:, payload:)
       paydirt = {}
       # TODO: Could make instance variable introspection configurable before or after method execution
       if payload.key?(:instance_variables)
@@ -54,19 +55,24 @@ module DebugLogging
     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)))
+      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
+          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)
+        scope.send(
+          :instance_variable_set,
+          DebugLogging::Configuration.config_pointer(proxy_ref, method_name),
+          proxy,
+        )
         yield proxy if block
         proxy
       end

data/lib/debug_logging/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
 module DebugLogging
-  VERSION = '3.1.8'
+  module Version
+    VERSION = "4.0.0"
+  end
 end

data/lib/debug_logging.rb

@@ -1,20 +1,23 @@
-# frozen_string_literal: true
-
-require 'logger'
-require 'colorized_string'
-require 'digest'
-
-require 'debug_logging/constants'
-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'
+# Std Lib
+require "logger"
+require "digest"
+
+# External gems
+require "version_gem"
+require "colorized_string"
+
+# This gem
+require "debug_logging/constants"
+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"
 
 ####################
 #                  #
@@ -39,7 +42,8 @@ require 'debug_logging/class_logger'
 #
 #       # For instance methods:
 #       # Option 1: specify the exact method(s) to add logging to
-#       include DebugLogging::InstanceLogger.new(i_methods: [:drive, :stop])
+#       extend DebugLogging::InstanceLogger
+#       i_logged [:drive, :stop]
 #
 #       # Provides the `logged` method decorator
 #       extend DebugLogging::ClassLogger
@@ -54,7 +58,8 @@ require 'debug_logging/class_logger'
 #
 #       # For instance methods:
 #       # Option 2: add logging to all instance methods defined above (but *not* defined below)
-#       include DebugLogging::InstanceLogger.new(i_methods: self.instance_methods(false))
+#       extend DebugLogging::InstanceLogger
+#       i_logged instance_methods(false)
 #
 #       def will_not_be_logged; false; end
 #
@@ -63,29 +68,36 @@ require 'debug_logging/class_logger'
 ####################
 
 module DebugLogging
-  def self.extended(base)
-    base.send(:extend, ArgumentPrinter)
-    base.send(:extend, ApiClassMethods)
-    base.send(:extend, ConfigClassMethods)
-    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))
+  # We can't compare with nil to check for no arguments passed as a configuration value,
+  #   because nil can be an argument passed, hence:
+  ACTUAL_NOTHING = Object.new
+
+  class << self
+    def extended(base)
+      base.send(:extend, ArgumentPrinter)
+      base.send(:include, ArgumentPrinter)
+      base.send(:extend, ApiClassMethods)
+      base.send(:extend, ConfigClassMethods)
+      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
-  end
 
-  #### API ####
+    #### API ####
 
-  # For single statement global config in an initializer
-  # e.g. DebugLogging.configuration.ellipsis = "..."
-  def self.configuration
-    self.debug_logging_configuration ||= Configuration.new
-  end
+    # For single statement global config in an initializer
+    # e.g. DebugLogging.configuration.ellipsis = "..."
+    def configuration
+      self.debug_logging_configuration ||= Configuration.new
+    end
 
-  # For global config in an initializer with a block
-  def self.configure
-    yield(configuration)
+    # For global config in an initializer with a block
+    def configure
+      yield(configuration)
+    end
   end
 
   module ApiClassMethods
@@ -272,3 +284,7 @@ module DebugLogging
 
   self.debug_logging_configuration = Configuration.new # setup defaults
 end
+
+DebugLogging::Version.class_eval do
+  extend VersionGem::Basic
+end

data/lib/simple_debug_logging.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Simpler version of what the sibling DebugLogging library does.  Included as a bauble.
 #
 ############# THIS IS A BAUBLE
@@ -35,7 +33,7 @@
 # NOTE: The instance method manner of logging works on Ruby 2.0+
 # NOTE: The class method manner of logging works on Ruby 2.1+
 
-require 'benchmark'
+require "benchmark"
 
 class SimpleDebugLogging < Module
   def initialize(i_methods: nil)
@@ -57,11 +55,11 @@ class SimpleDebugLogging < Module
           define_method(method_to_log.to_sym) do |*args|
             method_return_value = nil
             invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if args
-            puts "#{self}.#{method_to_log}(#{args.map(&:inspect).join(', ')})#{invocation_id}"
+            puts "#{self}::#{method_to_log}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
             elapsed = Benchmark.realtime do
               method_return_value = original_method.call(*args)
             end
-            puts "#{self}.#{method_to_log} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
+            puts "#{self}::#{method_to_log} ~#{args.hash}~ complete in #{elapsed}s#{invocation_id}"
             method_return_value
           end
         end
@@ -76,7 +74,7 @@ class SimpleDebugLogging < Module
           define_method(method_to_log.to_sym) do |*args, &block|
             method_return_value = nil
             invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if args
-            puts "#{self.class}##{method_to_log}(#{args.map(&:inspect).join(', ')})#{invocation_id}"
+            puts "#{self.class}##{method_to_log}(#{args.map(&:inspect).join(", ")})#{invocation_id}"
             elapsed = Benchmark.realtime do
               method_return_value = super(*args, &block)
             end