debug_logging 3.1.9 → 4.0.0

data/lib/debug_logging/configuration.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module DebugLogging
   class Configuration
     include Constants
@@ -11,21 +9,20 @@ module DebugLogging
     # alias the readers to the debug_* prefix so an instance of this class
     #   can have the same API granted by `extend DebugLogging`
     #
-    #     include DebugLogging::InstanceLogger.new(
-    #       i_methods: [:drive, :stop],
-    #       config: {
-    #           logger: Logger.new(STDOUT) # probably want to override to be the Rails.logger
-    #           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.first.id}" }
-    #           args_max_length: 1_000
-    #           instance_benchmarks: false
-    #           class_benchmarks: false
-    #           add_invocation_id: true # invocation id allows you to identify a method call uniquely in a log
-    #           ellipsis: " ✂️ …".freeze
+    #     extend DebugLogging::InstanceLogger
+    #     i_logged [:drive, :stop],
+    #       {
+    #         logger: Logger.new(STDOUT) # probably want to override to be the Rails.logger
+    #         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.first.id}" }
+    #         args_max_length: 1_000
+    #         instance_benchmarks: false
+    #         class_benchmarks: false
+    #         add_invocation_id: true # invocation id allows you to identify a method call uniquely in a log
+    #         ellipsis: " ✂️ …".freeze
     #       }
-    #     )
     #
     CONFIG_KEYS.each do |key|
       alias_method :"debug_#{key}", :"#{key}"
@@ -39,12 +36,13 @@ module DebugLogging
         "@debug_logging_config_#{type}_#{Digest::MD5.hexdigest(method_to_log.to_s)}".to_sym
       end
     end
+
     def initialize(**options)
       CONFIG_ATTRS.each do |key|
-        send("#{key}=", get_attr_from_options(options, key))
+        send(:"#{key}=", get_attr_from_options(options, key))
       end
       CONFIG_READERS.each do |key|
-        send("#{key}=", get_reader_from_options(options, key))
+        send(:"#{key}=", get_reader_from_options(options, key))
       end
       @methods_to_log = []
     end
@@ -63,7 +61,7 @@ module DebugLogging
     def loggable?
       return @loggable if defined?(@loggable)
 
-      @loggable = logger.send("#{log_level}?")
+      @loggable = logger.send(:"#{log_level}?")
     end
 
     def benchmarkable_for?(benchmarks)
@@ -95,7 +93,7 @@ module DebugLogging
 
     def to_hash
       CONFIG_KEYS.each_with_object({}) do |key, hash|
-        hash[key] = instance_variable_get("@#{key}")
+        hash[key] = instance_variable_get(:"@#{key}")
       end
     end
 

data/lib/debug_logging/constants.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module DebugLogging
   module Constants
     DEFAULT_ELLIPSIS = " ✂️ …"

data/lib/debug_logging/finalize.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # From: https://stackoverflow.com/a/34559282
 # License: https://creativecommons.org/licenses/by-sa/4.0/
 module DebugLogging

data/lib/debug_logging/hooks.rb

@@ -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
@@ -39,11 +37,9 @@ module DebugLogging
         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
@@ -58,7 +54,7 @@ module DebugLogging
           meth = instance_method(name)
           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
@@ -72,7 +68,7 @@ module DebugLogging
         names.each do |name|
           meth = instance_method(name)
           define_method(name) do |*args, &block|
-            result = meth.bind(self).call(*args, &block)
+            result = meth.bind_call(self, *args, &block)
             instance_exec(result, &blk)
           end
         end

data/lib/debug_logging/instance_logger.rb

@@ -1,24 +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
-
-      base.send(:include, ArgumentPrinter)
-      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(
-        methods_to_log: @instance_methods_to_log,
-        payload: @payload,
-        config: @config,
+  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,
       )
-      base.send(:prepend, instance_method_logger)
+      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
+
+      send(:include, wrapped_in_logs)
     end
   end
 end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -1,65 +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_variable_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 StandardError => e
-                if config_proxy.error_handler_proc
-                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_log, args)
-                else
-                  raise e
+              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,24 +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
-
-    def included(base)
-      return unless @instance_methods_to_notify
-
-      base.send(:include, ArgumentPrinter)
+  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: @instance_methods_to_notify,
-        payload: @payload,
-        config: @config,
+        methods_to_notify: Array(method_names),
+        payload: payload,
+        config: config_opts,
       )
-      base.send(:prepend, instance_method_notifier)
+
+      wrapped_in_notifier = Module.new do
+        singleton_class.send(:define_method, :included) do |host_class|
+          host_class.prepend(instance_method_notifier)
+        end
+      end
+
+      send(:include, wrapped_in_notifier)
     end
   end
 end

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -1,51 +1,45 @@
-# 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_variable_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
-                # TODO: I need to split logic based on Ruby version.
-                # TODO: Use VersionGem's minimum Ruby version check
-                # TODO: Switch between positional, and kwargs argument handling
-                # See: https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
-                super(*args, &block)
+              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, e, self, method_to_notify, args)
+                  config_proxy.error_handler_proc.call(config_proxy, e, self, method_to_notify, args, kwargs)
                 else
                   raise e
                 end

data/lib/debug_logging/log_subscriber.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "active_support"
 require "active_support/log_subscriber"
 

data/lib/debug_logging/util.rb

@@ -14,6 +14,7 @@ module DebugLogging
         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

data/lib/debug_logging/version.rb

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

data/lib/debug_logging.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Std Lib
 require "logger"
 require "digest"
@@ -44,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
@@ -59,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
 #
@@ -68,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

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