debug_logging 1.0.16 → 3.1.1

data/lib/debug_logging/class_notifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+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
+        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
+            ActiveSupport::Notifications.instrument(
+              DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
+              {
+                debug_args: args,
+                config_proxy: config_proxy,
+                **payload
+              }
+            ) do
+              if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                original_method.call(**harsh, &block)
+              else
+                original_method.call(*args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/configuration.rb

@@ -1,22 +1,37 @@
+# frozen_string_literal: true
+
 module DebugLogging
   class Configuration
-    DEFAULT_ELLIPSIS = " ✂️ …".freeze
+    DEFAULT_ELLIPSIS = ' ✂️ …'
+    CONFIG_ATTRS_DEFAULTS = {
+      enabled: true,
+      logger: Logger.new($stdout),
+      log_level: :debug,
+      multiple_last_hashes: false,
+      last_hash_to_s_proc: nil,
+      last_hash_max_length: 1_000,
+      args_max_length: 1_000,
+      colorized_chain_for_method: false,
+      colorized_chain_for_class: false,
+      add_invocation_id: true,
+      ellipsis: DEFAULT_ELLIPSIS,
+      mark_scope_exit: false,
+      add_payload: true
+    }.freeze
+    CONFIG_ATTRS = CONFIG_ATTRS_DEFAULTS.keys
+    CONFIG_READERS_DEFAULTS = {
+      instance_benchmarks: false,
+      class_benchmarks: false,
+      active_support_notifications: false
+    }.freeze
+    CONFIG_READERS = CONFIG_READERS_DEFAULTS.keys
+    CONFIG_KEYS = CONFIG_ATTRS + CONFIG_READERS
+
+    # For reference, log levels as integers mapped to symbols:
     # LEVELS = { 0 => :debug, 1 => :info, 2 => :warn, 3 => :error, 4 => :fatal, 5 => :unknown }
-    attr_accessor :enabled
-    attr_accessor :logger
-    attr_accessor :log_level
-    attr_accessor :multiple_last_hashes
-    attr_accessor :last_hash_to_s_proc
-    attr_accessor :last_hash_max_length
-    attr_accessor :args_max_length
-    attr_accessor :instance_benchmarks
-    attr_accessor :class_benchmarks
-    attr_accessor :colorized_chain_for_method
-    attr_accessor :colorized_chain_for_class
-    attr_accessor :add_invocation_id
-    attr_accessor :ellipsis
-    attr_accessor :mark_scope_exit
-    attr_reader :methods_to_log
+    attr_accessor(*CONFIG_ATTRS)
+    attr_reader :methods_to_log, *CONFIG_READERS
+
     # alias the readers to the debug_* prefix so an instance of this class
     #   can have the same API granted by `extend DebugLogging`
     #
@@ -35,21 +50,10 @@ module DebugLogging
     #       }
     #     )
     #
-    alias :debug_enabled :enabled
-    alias :debug_logger :logger
-    alias :debug_log_level :log_level
-    alias :debug_multiple_last_hashes :multiple_last_hashes
-    alias :debug_last_hash_to_s_proc :last_hash_to_s_proc
-    alias :debug_last_hash_max_length :last_hash_max_length
-    alias :debug_args_max_length :args_max_length
-    alias :debug_instance_benchmarks :instance_benchmarks
-    alias :debug_class_benchmarks :class_benchmarks
-    alias :debug_colorized_chain_for_method :colorized_chain_for_method
-    alias :debug_colorized_chain_for_class :colorized_chain_for_class
-    alias :debug_add_invocation_id :add_invocation_id
-    alias :debug_ellipsis :ellipsis
-    alias :debug_mark_scope_exit :mark_scope_exit
-    
+    CONFIG_KEYS.each do |key|
+      alias :"debug_#{key}" :"#{key}"
+    end
+
     class << self
       def config_pointer(type, method_to_log)
         # Methods names that do not match the following regex can't be part of an ivar name
@@ -59,70 +63,77 @@ module DebugLogging
       end
     end
     def initialize(**options)
-      @enabled = options.key?(:enabled) ? options[:enabled] : true
-      @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
-      @log_level = options.key?(:log_level) ? options[:log_level] : :debug
-      @multiple_last_hashes = options.key?(:multiple_last_hashes) ? options[:multiple_last_hashes] : false
-      @last_hash_to_s_proc = options.key?(:last_hash_to_s_proc) ? options[:last_hash_to_s_proc] : nil
-      @last_hash_max_length = options.key?(:last_hash_max_length) ? options[:last_hash_max_length] : 1_000
-      @args_max_length = options.key?(:args_max_length) ? options[:args_max_length] : 1_000
-      @instance_benchmarks = options.key?(:instance_benchmarks) ? options[:instance_benchmarks] : false
-      @class_benchmarks = options.key?(:class_benchmarks) ? options[:class_benchmarks] : false
-      @colorized_chain_for_method = options.key?(:colorized_chain_for_method) ? options[:colorized_chain_for_method] : false
-      @colorized_chain_for_class = options.key?(:colorized_chain_for_class) ? options[:colorized_chain_for_class] : false
-      @add_invocation_id = options.key?(:add_invocation_id) ? options[:add_invocation_id] : true
-      @ellipsis = options.key?(:ellipsis) ? options[:ellipsis] : DEFAULT_ELLIPSIS
-      @mark_scope_exit = options.key?(:mark_scope_exit) ? options[:mark_scope_exit] : false
+      CONFIG_ATTRS.each do |key|
+        send("#{key}=", get_attr_from_options(options, key))
+      end
+      CONFIG_READERS.each do |key|
+        send("#{key}=", get_reader_from_options(options, key))
+      end
       @methods_to_log = []
     end
+
     def log(message = nil, &block)
       return unless enabled
       return unless logger
+
       if block_given?
         logger.send(log_level, &block)
       else
         logger.send(log_level, message)
       end
     end
+
     def loggable?
       return @loggable if defined?(@loggable)
+
       @loggable = logger.send("#{log_level}?")
     end
+
     def benchmarkable_for?(benchmarks)
       return @benchmarkable if defined?(@benchmarkable)
-      @benchmarkable = loggable? && self.send(benchmarks)
+
+      @benchmarkable = loggable? && send(benchmarks)
     end
+
     def exit_scope_markable?
       return @exit_scope_markable if defined?(@exit_scope_markable)
+
       @exit_scope_markable = loggable? && mark_scope_exit
     end
+
     def instance_benchmarks=(instance_benchmarks)
-      require "benchmark" if instance_benchmarks
+      require 'benchmark' if instance_benchmarks
       @instance_benchmarks = instance_benchmarks
     end
+
     def class_benchmarks=(class_benchmarks)
-      require "benchmark" if class_benchmarks
+      require 'benchmark' if class_benchmarks
       @class_benchmarks = class_benchmarks
     end
+
+    def active_support_notifications=(active_support_notifications)
+      require 'debug_logging/active_support_notifications' if active_support_notifications
+      @active_support_notifications = active_support_notifications
+    end
+
     def to_hash
-      {
-          logger: logger,
-          log_level: log_level,
-          multiple_last_hashes: multiple_last_hashes,
-          last_hash_to_s_proc: last_hash_to_s_proc,
-          last_hash_max_length: last_hash_max_length,
-          args_max_length: args_max_length,
-          instance_benchmarks: instance_benchmarks,
-          class_benchmarks: class_benchmarks,
-          colorized_chain_for_method: colorized_chain_for_method,
-          colorized_chain_for_class: colorized_chain_for_class,
-          add_invocation_id: add_invocation_id,
-          ellipsis: ellipsis,
-          mark_scope_exit: mark_scope_exit
-      }
+      CONFIG_KEYS.each_with_object({}) do |key, hash|
+        hash[key] = instance_variable_get("@#{key}")
+      end
     end
+
     def register(method_lo_log)
       @methods_to_log << method_lo_log
     end
+
+    private
+
+    def get_attr_from_options(options, key)
+      options.key?(key) ? options[key] : CONFIG_ATTRS_DEFAULTS[key]
+    end
+
+    def get_reader_from_options(options, key)
+      options.key?(key) ? options[key] : CONFIG_READERS_DEFAULTS[key]
+    end
   end
 end

data/lib/debug_logging/instance_logger.rb

@@ -1,13 +1,19 @@
+# frozen_string_literal: true
+
 module DebugLogging
   class InstanceLogger < Module
     def initialize(i_methods: nil, config: nil)
+      super()
       @config = config
       @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, config: @config)
+      instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(methods_to_log: @instance_methods_to_log,
+                                                                            config: @config)
       base.send(:prepend, instance_method_logger)
     end
   end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -1,28 +1,56 @@
+# frozen_string_literal: true
+
 module DebugLogging
   module InstanceLoggerModulizer
     def self.to_mod(methods_to_log: nil, config: nil)
       Module.new do
         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
-          define_method(method_to_log.to_sym) do |*args, &block|
+          method_to_log = if method_to_log.is_a?(Array)
+                            method_to_log.first&.to_sym
+                          else
+                            method_to_log.to_sym
+                          end
+          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)))
+            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))) 
+                                       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('i', method_to_log), proxy)
+                             instance_variable_set(DebugLogging::Configuration.config_pointer('ilm', 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)
+            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
               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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  class InstanceNotifier < Module
+    def initialize(i_methods: nil)
+      super()
+      @instance_methods_to_notify = Array(i_methods) if i_methods
+    end
+
+    def included(base)
+      return unless @instance_methods_to_notify
+
+      base.send(:include, ArgumentPrinter)
+      instance_method_notifier = DebugLogging::InstanceNotifierModulizer.to_mod(methods_to_notify: @instance_methods_to_notify)
+      base.send(:prepend, instance_method_notifier)
+    end
+  end
+end

data/lib/debug_logging/instance_notifier_modulizer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  module InstanceNotifierModulizer
+    def self.to_mod(methods_to_notify: nil)
+      Module.new do
+        config_proxy = nil
+
+        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.dup) || {}
+          config_opts = {}
+          unless payload.empty?
+            DebugLogging::Configuration::CONFIG_KEYS.each { |k| config_opts[k] = payload.delete(k) if payload.key?(k) }
+          end
+          method_to_notify = if method_to_notify.is_a?(Array)
+                               method_to_notify.first&.to_sym
+                             else
+                               method_to_notify.to_sym
+                             end
+          define_method(method_to_notify) do |*args, &block|
+            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('inm',
+                                                                                                        method_to_notify)))
+                             proxy
+                           else
+                             proxy = if config_opts.empty?
+                                       self.class.debug_config
+                                     else
+                                       Configuration.new(**self.class.debug_config.to_hash.merge(config_opts))
+                                     end
+                             proxy.register(method_to_notify)
+                             instance_variable_set(
+                               DebugLogging::Configuration.config_pointer('inm', method_to_notify), proxy
+                             )
+                             proxy
+                           end
+            paydirt = {}
+            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
+            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
+              super(*args, &block)
+            end
+          end
+          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
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/log_subscriber.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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 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
+    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,
+        args: debug_signature_to_s(args: args, config_proxy: config_proxy),
+        payload: debug_payload_to_s(payload: payload, config_proxy: config_proxy)
+      }
+    end
+  end
+end