debug_logging 1.0.15 → 3.1.0

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "debug_logging"
+require 'bundler/setup'
+require 'debug_logging'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +11,5 @@ require "debug_logging"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/debug_logging.gemspec

@@ -1,35 +1,39 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'debug_logging/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "debug_logging"
+  spec.name          = 'debug_logging'
   spec.version       = DebugLogging::VERSION
-  spec.authors       = ["Peter Boling"]
-  spec.email         = ["peter.boling@gmail.com"]
+  spec.authors       = ['Peter Boling']
+  spec.email         = ['peter.boling@gmail.com']
 
-  spec.summary       = %q{Drop-in debug logging useful when a call stack gets unruly}
-  spec.description   = %q{
+  spec.summary       = 'Drop-in debug logging useful when a call stack gets unruly'
+  spec.description   = '
 Unobtrusive debug logging for Ruby.  NO LITTERING.
 Automatically log selected methods and their arguments as they are called at runtime!
-}
-  spec.license       = "MIT"
-  spec.homepage      = "https://github.com/pboling/debug_logging"
+'
+  spec.license       = 'MIT'
+  spec.homepage      = 'https://github.com/pboling/debug_logging'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.0.0" # Uses named parameters
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.4.0' # Uses magic comments
 
-  spec.add_runtime_dependency "colorize", "~> 0.8"
-  spec.add_development_dependency "rspec-pending_for"
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "coveralls", "~> 0.8"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "activesupport", "~> 5.1"
+  spec.add_runtime_dependency 'colorize', '>= 0'
+  spec.add_development_dependency 'activesupport', '~> 5.2', '>= 5.2.4.4'
+  spec.add_development_dependency 'bundler', '>= 2'
+  spec.add_development_dependency 'byebug', '>= 11'
+  spec.add_development_dependency 'rake', '>= 13'
+  spec.add_development_dependency 'rspec', '>= 3'
+  spec.add_development_dependency 'rspec-pending_for', '>= 0'
+  spec.add_development_dependency 'rubocop', '>= 0.92'
+  spec.add_development_dependency 'rubocop-rspec', '>= 1'
+  spec.add_development_dependency 'silent_stream', '>= 1'
 end

data/lib/debug_logging.rb

@@ -1,13 +1,15 @@
-require "logger"
-require "colorized_string"
-require "digest"
+# frozen_string_literal: true
 
-require "debug_logging/version"
-require "debug_logging/configuration"
-require "debug_logging/argument_printer"
-require "debug_logging/instance_logger_modulizer"
-require "debug_logging/instance_logger"
-require "debug_logging/class_logger"
+require 'logger'
+require 'colorized_string'
+require 'digest'
+
+require 'debug_logging/version'
+require 'debug_logging/configuration'
+require 'debug_logging/argument_printer'
+require 'debug_logging/instance_logger_modulizer'
+require 'debug_logging/instance_logger'
+require 'debug_logging/class_logger'
 
 ####################
 #                  #
@@ -62,12 +64,12 @@ module DebugLogging
   end
 
   #### API ####
-  # Not used by this gem internally, but provides an external interface for 
+  # Not used by this gem internally, but provides an external interface for
   #   classes to also use this logging tool directly,
   #   with configured options like benchmarking, colors, or leg level.
   def debug_log(message = nil, config_proxy = nil, &block)
     # If a, instance-method-level, or class-method-level custom config is not
-    #   passed in, then fall back to the class' default config, which is a 
+    #   passed in, then fall back to the class' default config, which is a
     #   potentially customized copy of the default config for the whole app.
     config_proxy ||= debug_config
     config_proxy.log(message, &block)
@@ -103,81 +105,115 @@ module DebugLogging
   def debug_config_reset(config = Configuration.new)
     @debug_logging_configuration = config
   end
+
+  def debug_enabled
+    @debug_logging_configuration.enabled
+  end
+
+  def debug_enabled=(value)
+    @debug_logging_configuration.enabled = value
+  end
+
   def debug_logger
     @debug_logging_configuration.logger
   end
+
   def debug_logger=(logger)
     @debug_logging_configuration.logger = logger
   end
+
   def debug_log_level
     @debug_logging_configuration.log_level
   end
+
   def debug_log_level=(log_level)
     @debug_logging_configuration.log_level = log_level
   end
+
   def debug_multiple_last_hashes
     @debug_logging_configuration.multiple_last_hashes
   end
+
   def debug_multiple_last_hashes=(multiple_last_hashes)
     @debug_logging_configuration.multiple_last_hashes = multiple_last_hashes
   end
+
   def debug_last_hash_to_s_proc
     @debug_logging_configuration.last_hash_to_s_proc
   end
+
   def debug_last_hash_to_s_proc=(last_hash_to_s_proc)
     @debug_logging_configuration.last_hash_to_s_proc = last_hash_to_s_proc
   end
+
   def debug_last_hash_max_length
     @debug_logging_configuration.last_hash_max_length
   end
+
   def debug_last_hash_max_length=(last_hash_max_length)
     @debug_logging_configuration.last_hash_max_length = last_hash_max_length
   end
+
   def debug_args_max_length
     @debug_logging_configuration.args_max_length
   end
+
   def debug_args_max_length=(args_max_length)
     @debug_logging_configuration.args_max_length = args_max_length
   end
+
   def debug_instance_benchmarks
     @debug_logging_configuration.instance_benchmarks
   end
+
   def debug_instance_benchmarks=(instance_benchmarks)
     @debug_logging_configuration.instance_benchmarks = instance_benchmarks
   end
+
   def debug_class_benchmarks
     @debug_logging_configuration.class_benchmarks
   end
+
   def debug_class_benchmarks=(class_benchmarks)
     @debug_logging_configuration.class_benchmarks = class_benchmarks
   end
+
   def debug_colorized_chain_for_method
     @debug_logging_configuration.colorized_chain_for_method
   end
+
   def debug_colorized_chain_for_method=(colorized_chain_for_method)
     @debug_logging_configuration.colorized_chain_for_method = colorized_chain_for_method
   end
+
   def debug_colorized_chain_for_class
     @debug_logging_configuration.colorized_chain_for_class
   end
+
   def debug_colorized_chain_for_class=(colorized_chain_for_class)
     @debug_logging_configuration.colorized_chain_for_class = colorized_chain_for_class
   end
+
   def debug_add_invocation_id
     @debug_logging_configuration.add_invocation_id
   end
+
   def debug_add_invocation_id=(add_invocation_id)
     @debug_logging_configuration.add_invocation_id = add_invocation_id
   end
+
   def debug_mark_scope_exit
     @debug_logging_configuration.mark_scope_exit
   end
+
   def debug_mark_scope_exit=(mark_scope_exit)
     @debug_logging_configuration.mark_scope_exit = mark_scope_exit
   end
+
   def debug_ellipsis
     @debug_logging_configuration.ellipsis
   end
+
   def debug_ellipsis=(ellipsis)
     @debug_logging_configuration.ellipsis = ellipsis
   end

data/lib/debug_logging/active_support_notifications.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'debug_logging/log_subscriber'
+require 'debug_logging/class_notifier'
+require 'debug_logging/instance_notifier_modulizer'
+require 'debug_logging/instance_notifier'

data/lib/debug_logging/argument_printer.rb

@@ -1,21 +1,29 @@
+# frozen_string_literal: true
+
 module DebugLogging
   module ArgumentPrinter
     def debug_benchmark_to_s(tms: nil)
-      "completed in #{sprintf("%f", tms.real)}s (#{sprintf("%f", tms.total)}s CPU)"
+      "completed in #{format('%f', tms.real)}s (#{format('%f', tms.total)}s CPU)"
     end
+
+    def debug_event_name_to_s(method_to_notify: nil)
+      "#{method_to_notify}.log"
+    end
+
     def debug_invocation_id_to_s(args: nil, config_proxy: nil)
       if config_proxy.debug_add_invocation_id
-        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..(-4)]}~"
+        invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..-4]}~"
         case config_proxy.debug_add_invocation_id
-        when true then
+        when true
           invocation
         else
           config_proxy.debug_add_invocation_id.call(ColorizedString[invocation])
         end
       else
-        ""
+        ''
       end
     end
+
     def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
       klass_string = if config_proxy.debug_colorized_chain_for_class
                        config_proxy.debug_colorized_chain_for_class.call(ColorizedString[klass.to_s])
@@ -29,50 +37,55 @@ module DebugLogging
                       end
       "#{klass_string}#{separator}#{method_string}"
     end
-    def debug_signature_to_s(args: nil, config_proxy: nil)
-      printed_args = ""
+
+    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      printed_args = ''
+
       add_args_ellipsis = false
       if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
+        add_last_hash_ellipsis = false
         if args.length > 1
-          add_last_hash_ellipsis = false
           if config_proxy.debug_multiple_last_hashes
             last_hash_args, other_args = args.partition do |arg|
-                                            arg.is_a?(Hash)
-                                          end
-            other_args_string = other_args.map(&:inspect).join(", ")[0..(config_proxy.debug_args_max_length)]
-              # On the debug_multiple_last_hashes truthy branch we don't print the ellipsis after regular args
-              #   because it will go instead after the last hash (if needed)
-              #   ...join(", ").tap {|x| _add_args_ellipsis = x.length > config_proxy.debug_args_max_length}
+              arg.is_a?(Hash)
+            end
+            other_args_string = other_args.map(&:inspect).join(', ')[0..(config_proxy.debug_args_max_length)]
+            # On the debug_multiple_last_hashes truthy branch we don't print the ellipsis after regular args
+            #   because it will go instead after the last hash (if needed)
+            #   ...join(", ").tap {|x| _add_args_ellipsis = x.length > config_proxy.debug_args_max_length}
             last_hash_args_string = last_hash_args.map do |arg|
-                                      config_proxy.debug_last_hash_to_s_proc.call(arg).to_s.
-                                          tap {|x|
-                                                add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
-                                              }[0..(config_proxy.debug_last_hash_max_length)].
-                                          tap {|x|
-                                                x << config_proxy.debug_ellipsis if add_last_hash_ellipsis
-                                              }
-                                    end.join(", ")
-            printed_args << other_args_string if other_args_string
-            printed_args << ", " if !other_args_string.empty? && !last_hash_args_string.empty?
-            printed_args << last_hash_args_string if last_hash_args_string
+              arr = []
+              arr << config_proxy.debug_last_hash_to_s_proc.call(arg).to_s
+                                 .tap do |x|
+                add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length
+              end
+              if add_last_hash_ellipsis
+                arr[-1] = arr[-1][0..(config_proxy.debug_last_hash_max_length)]
+                arr << config_proxy.debug_ellipsis
+              end
+              arr
+            end.flatten.join(', ')
+            printed_args += other_args_string if other_args_string
+            printed_args += ', ' if !other_args_string.empty? && !last_hash_args_string.empty?
+            printed_args += last_hash_args_string if last_hash_args_string && !last_hash_args_string.empty?
           else
-            printed_args << args[0..(-2)].map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length}[0..(config_proxy.debug_args_max_length)]
-            printed_args << config_proxy.debug_ellipsis if add_args_ellipsis
-            printed_args << ", " << config_proxy.debug_last_hash_to_s_proc.call(args[-1]).tap {|x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length}[0..(config_proxy.debug_last_hash_max_length)]
-            printed_args << config_proxy.debug_ellipsis if add_last_hash_ellipsis
+            printed_args += args[0..-2].map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }[0..(config_proxy.debug_args_max_length)]
+            printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
+            printed_args += ", #{config_proxy.debug_last_hash_to_s_proc.call(args[-1]).tap { |x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length }[0..(config_proxy.debug_last_hash_max_length)]}"
+            printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
           end
         else
-          printed_args << String(config_proxy.debug_last_hash_to_s_proc.call(args[0])).tap {|x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length}[0..(config_proxy.debug_last_hash_max_length)]
-          printed_args << config_proxy.debug_ellipsis if add_last_hash_ellipsis
+          printed_args += String(config_proxy.debug_last_hash_to_s_proc.call(args[0])).tap { |x| add_last_hash_ellipsis = x.length > config_proxy.debug_last_hash_max_length }[0..(config_proxy.debug_last_hash_max_length)]
+          printed_args += config_proxy.debug_ellipsis if add_last_hash_ellipsis
         end
       else
         if args.length == 1 && args[0].is_a?(Hash)
           # handle double splat
-          printed_args << ("**" << args.map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length})[0..(config_proxy.debug_args_max_length)]
+          printed_args += ("**#{args.map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }}")[0..(config_proxy.debug_args_max_length)]
         else
-          printed_args << args.map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length}[0..(config_proxy.debug_args_max_length)]
+          printed_args += args.map(&:inspect).join(', ').tap { |x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length }[0..(config_proxy.debug_args_max_length)]
         end
-        printed_args << config_proxy.debug_ellipsis if add_args_ellipsis
+        printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
       end
       "(#{printed_args})"
     end

data/lib/debug_logging/class_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DebugLogging
   module ClassLogger
     def logged(*methods_to_log)
@@ -19,7 +21,7 @@ module DebugLogging
                              proxy
                            else
                              proxy = if opts
-                                       Configuration.new(**(debug_config.to_hash.merge(opts)))
+                                       Configuration.new(**debug_config.to_hash.merge(opts))
                                      else
                                        debug_config
                                      end
@@ -31,7 +33,7 @@ module DebugLogging
             log_prefix = nil
             invocation_id = nil
             config_proxy.log do
-              log_prefix = debug_invocation_to_s(klass: to_s, separator: ".", method_to_log: method_to_log, config_proxy: config_proxy)
+              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)
               "#{log_prefix}#{signature}#{invocation_id}"

data/lib/debug_logging/class_notifier.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DebugLogging
+  module ClassNotifier
+    def notifies(*methods_to_notify)
+      payload = methods_to_notify.last.is_a?(Hash) && methods_to_notify.pop || {}
+      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)
+        config_proxy = nil
+        (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('k', method_to_notify)))
+                             proxy
+                           else
+                             proxy = if !payload.empty?
+                                       Configuration.new(**debug_config.to_hash.merge(payload))
+                                     else
+                                       debug_config
+                                     end
+                             proxy.register(method_to_notify)
+                             instance_variable_set(DebugLogging::Configuration.config_pointer('k', method_to_notify), proxy)
+                             proxy
+                           end
+            ActiveSupport::Notifications.instrument(
+              debug_event_name_to_s(method_to_notify: method_to_notify), { args: args }.merge(payload)
+            ) do
+              original_method.call(*args, &block)
+            end
+          end
+        end
+
+        ActiveSupport::Notifications.subscribe(/log/) do |*args|
+          config_proxy&.log do
+            DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/debug_logging/configuration.rb

@@ -1,21 +1,15 @@
+# frozen_string_literal: true
+
 module DebugLogging
   class Configuration
-    DEFAULT_ELLIPSIS = " ✂️ …".freeze
+    DEFAULT_ELLIPSIS = ' ✂️ …'
+    # For reference, log levels as integers mapped to symbols:
     # LEVELS = { 0 => :debug, 1 => :info, 2 => :warn, 3 => :error, 4 => :fatal, 5 => :unknown }
-    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 :enabled
+    attr_accessor :logger, :log_level, :multiple_last_hashes, :last_hash_to_s_proc, :last_hash_max_length,
+                  :args_max_length, :colorized_chain_for_method, :colorized_chain_for_class, :add_invocation_id,
+                  :ellipsis, :mark_scope_exit
+    attr_reader :instance_benchmarks, :class_benchmarks, :active_support_notifications, :methods_to_log
     # alias the readers to the debug_* prefix so an instance of this class
     #   can have the same API granted by `extend DebugLogging`
     #
@@ -34,20 +28,21 @@ module DebugLogging
     #       }
     #     )
     #
-    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
-    
+    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
+
     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
@@ -57,66 +52,87 @@ module DebugLogging
       end
     end
     def initialize(**options)
-      @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
+      @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
+      self.instance_benchmarks = options.key?(:instance_benchmarks) ? options[:instance_benchmarks] : false
+      self.class_benchmarks = options.key?(:class_benchmarks) ? options[:class_benchmarks] : false
+      self.active_support_notifications = options.key?(:active_support_notifications) ? options[:active_support_notifications] : false
       @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
+        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,
+        active_support_notifications: active_support_notifications
       }
     end
+
     def register(method_lo_log)
       @methods_to_log << method_lo_log
     end