debug_logging 3.1.0 → 3.1.5

data/debug_logging.gemspec

@@ -7,7 +7,7 @@ require 'debug_logging/version'
 Gem::Specification.new do |spec|
   spec.name          = 'debug_logging'
   spec.version       = DebugLogging::VERSION
-  spec.authors       = ['Peter Boling']
+  spec.authors       = ['Peter Boling', 'guckin']
   spec.email         = ['peter.boling@gmail.com']
 
   spec.summary       = 'Drop-in debug logging useful when a call stack gets unruly'
@@ -33,7 +33,10 @@ Automatically log selected methods and their arguments as they are called at run
   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 'rubocop', '~> 1.0'
+  spec.add_development_dependency 'rubocop-md'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.0'
   spec.add_development_dependency 'silent_stream', '>= 1'
 end

data/lib/debug_logging.rb

@@ -5,8 +5,12 @@ require 'colorized_string'
 require 'digest'
 
 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'
@@ -61,6 +65,11 @@ module DebugLogging
   def self.extended(base)
     base.send(:extend, ArgumentPrinter)
     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
 
   #### API ####
@@ -154,6 +163,14 @@ module DebugLogging
     @debug_logging_configuration.last_hash_max_length = last_hash_max_length
   end
 
+  def debug_args_to_s_proc
+    @debug_logging_configuration.args_to_s_proc
+  end
+
+  def debug_args_to_s_proc=(args_to_s_proc)
+    @debug_logging_configuration.args_to_s_proc = args_to_s_proc
+  end
+
   def debug_args_max_length
     @debug_logging_configuration.args_max_length
   end

data/lib/debug_logging/argument_printer.rb

@@ -2,15 +2,13 @@
 
 module DebugLogging
   module ArgumentPrinter
-    def debug_benchmark_to_s(tms: nil)
+    def debug_benchmark_to_s(tms:)
       "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)
+      return '' unless args && config_proxy
+
       if config_proxy.debug_add_invocation_id
         invocation = " ~#{args.object_id}@#{(Time.now.to_f.to_s % '%#-21a')[4..-4]}~"
         case config_proxy.debug_add_invocation_id
@@ -25,6 +23,8 @@ module DebugLogging
     end
 
     def debug_invocation_to_s(klass: nil, separator: nil, method_to_log: nil, config_proxy: nil)
+      return '' unless config_proxy
+
       klass_string = if config_proxy.debug_colorized_chain_for_class
                        config_proxy.debug_colorized_chain_for_class.call(ColorizedString[klass.to_s])
                      else
@@ -38,56 +38,152 @@ module DebugLogging
       "#{klass_string}#{separator}#{method_string}"
     end
 
-    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def debug_signature_to_s(args: nil, config_proxy: nil) # rubocop:disable Metrics/CyclomaticComplexity
+      return '' unless args && config_proxy
+
       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
+        add_other_args_ellipsis = false
         if args.length > 1
           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)]
+            other_args_string = if config_proxy.debug_args_to_s_proc
+                                  printed, add_other_args_ellipsis = debug_safe_proc(
+                                    proc_name:'args_to_s_proc',
+                                    proc: config_proxy.debug_args_to_s_proc,
+                                    args: other_args,
+                                    max_length: config_proxy.debug_args_max_length
+                                  )
+                                  printed
+                                else
+                                  other_args.map(&:inspect).join(', ').tap do |x|
+                                    add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                                  end[0..(config_proxy.debug_args_max_length)]
+                                end
+            other_args_string += config_proxy.debug_ellipsis if add_other_args_ellipsis
             # 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)
+            #   because it will go instead after each of the last hashes (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|
               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
+              printed, add_last_hash_ellipsis = debug_safe_proc(
+                proc_name:'last_hash_to_s_proc',
+                proc: config_proxy.debug_last_hash_to_s_proc,
+                args: arg,
+                max_length: config_proxy.debug_last_hash_max_length
+              )
+              printed += config_proxy.debug_ellipsis if add_last_hash_ellipsis
+              arr << printed
               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(&: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)]}"
+            other_args = args[0..-2]
+            other_args_string = if config_proxy.debug_args_to_s_proc
+                                  printed, add_other_args_ellipsis = debug_safe_proc(
+                                    proc_name:'args_to_s_proc',
+                                    proc: config_proxy.debug_args_to_s_proc,
+                                    args: other_args,
+                                    max_length: config_proxy.debug_args_max_length
+                                  )
+                                  printed
+                                else
+                                  other_args.map(&:inspect).join(', ').tap do |x|
+                                    add_other_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                                  end[0..(config_proxy.debug_args_max_length)]
+                                end
+            other_args_string += config_proxy.debug_ellipsis if add_other_args_ellipsis
+            printed_args += other_args_string
+            printed, add_last_hash_ellipsis = debug_safe_proc(
+              proc_name:'last_hash_to_s_proc',
+              proc: config_proxy.debug_last_hash_to_s_proc,
+              args: args[-1],
+              max_length: config_proxy.debug_last_hash_max_length
+            )
+            printed_args += ", #{printed}"
             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, add_last_hash_ellipsis = debug_safe_proc(
+            proc_name:'last_hash_to_s_proc',
+            proc: config_proxy.debug_last_hash_to_s_proc,
+            args: args[0],
+            max_length: config_proxy.debug_last_hash_max_length
+          )
+          printed_args += printed
           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(&: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(&: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 += if config_proxy.debug_args_to_s_proc
+                          printed, add_args_ellipsis = debug_safe_proc(
+                            proc_name:'args_to_s_proc',
+                            proc: config_proxy.debug_args_to_s_proc,
+                            args: args,
+                            max_length: config_proxy.debug_args_max_length
+                          )
+                          printed
+                        elsif args.length == 1 && args[0].is_a?(Hash)
+                          # handle double splat
+                          ("**#{args.map(&:inspect).join(', ').tap do |x|
+                                  add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                                end }")[0..(config_proxy.debug_args_max_length)]
+                        else
+                          args.map(&:inspect).join(', ').tap do |x|
+                            add_args_ellipsis = x.length > config_proxy.debug_args_max_length
+                          end[0..(config_proxy.debug_args_max_length)]
+                        end
         printed_args += config_proxy.debug_ellipsis if add_args_ellipsis
       end
       "(#{printed_args})"
     end
+
+    def debug_safe_proc(proc_name:, proc:, args:, max_length:)
+      max_length ||= 1000 # can't be nil
+      begin
+        add_ellipsis = false
+        printed = String(proc.call(args)).tap do |x|
+          add_ellipsis = x.length > max_length
+        end[0..(max_length)]
+        return printed, add_ellipsis
+      rescue => e
+        return "#{e.class}: #{e.message}\nPlease check that your #{proc_name} is able to handle #{args}", false
+      end
+    end
+
+    def debug_payload_to_s(payload: nil, config_proxy: nil)
+      return '' unless payload && config_proxy
+
+      if payload
+        case config_proxy.debug_add_payload
+        when true
+          payload.inspect
+        else
+          printed_payload = ""
+          printed, add_payload_ellipsis = debug_safe_proc(
+            proc_name: "add_payload",
+            proc: config_proxy.debug_add_payload,
+            args: payload,
+            max_length: config_proxy.payload_max_length
+          )
+          printed_payload += printed
+          printed_payload += config_proxy.debug_ellipsis if add_payload_ellipsis
+          printed_payload
+        end
+      else
+        ''
+      end
+    end
+
+    module_function
+
+    def debug_event_name_to_s(method_to_notify: nil)
+      "#{method_to_notify}.log"
+    end
   end
 end

data/lib/debug_logging/class_logger.rb

@@ -3,50 +3,55 @@
 module DebugLogging
   module ClassLogger
     def logged(*methods_to_log)
-      # When opts are present it will always be a new configuration instance per method
-      # When opts are not present it will reuse the class' configuration object
-      opts = methods_to_log.last.is_a?(Hash) && methods_to_log.pop
-      if methods_to_log.first.is_a?(Array)
-        methods_to_log = methods_to_log.shift
-      else
-        # logged :meth1, :meth2, :meth3 without options is valid too
-      end
-      methods_to_log.each do |method_to_log|
-        # method name must be a symbol
-        method_to_log = method_to_log.to_sym
+      methods_to_log, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_log,
+        payload: nil,
+        config: nil
+      )
+      Array(methods_to_log).each do |method_to_log|
+        method_to_log, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: method_to_log,
+          payload: payload,
+          config: config_opts
+        )
         original_method = method(method_to_log)
         (class << self; self; end).class_eval do
           define_method(method_to_log) do |*args, &block|
-            config_proxy = if (proxy = instance_variable_get(DebugLogging::Configuration.config_pointer('k', method_to_log)))
-                             proxy
-                           else
-                             proxy = if opts
-                                       Configuration.new(**debug_config.to_hash.merge(opts))
-                                     else
-                                       debug_config
-                                     end
-                             proxy.register(method_to_log)
-                             instance_variable_set(DebugLogging::Configuration.config_pointer('k', method_to_log), proxy)
-                             proxy
-                           end
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self,
+              config_opts: method_config_opts,
+              method_name: method_to_log,
+              proxy_ref: 'kl'
+            )
             method_return_value = nil
             log_prefix = nil
             invocation_id = nil
             config_proxy.log do
-              log_prefix = debug_invocation_to_s(klass: to_s, separator: '.', method_to_log: method_to_log, config_proxy: config_proxy)
+              paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
+              log_prefix = debug_invocation_to_s(klass: to_s, separator: '.', method_to_log: method_to_log,
+                                                 config_proxy: config_proxy)
               invocation_id = debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
               signature = debug_signature_to_s(args: args, config_proxy: config_proxy)
-              "#{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_class_benchmarks)
               tms = Benchmark.measure do
-                method_return_value = original_method.call(*args, &block)
+                method_return_value = if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                                        original_method.call(**harsh, &block)
+                                      else
+                                        original_method.call(*args, &block)
+                                      end
               end
               config_proxy.log do
                 "#{log_prefix} #{debug_benchmark_to_s(tms: tms)}#{invocation_id}"
               end
             else
-              method_return_value = original_method.call(*args, &block)
+              method_return_value = if args.size == 1 && (harsh = args[0]) && harsh.is_a?(Hash)
+                                      original_method.call(**harsh, &block)
+                                    else
+                                      original_method.call(*args, &block)
+                                    end
               if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
                 config_proxy.log do
                   "#{log_prefix} completed#{invocation_id}"

data/lib/debug_logging/class_notifier.rb

@@ -3,44 +3,51 @@
 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
+      methods_to_notify, payload, config_opts = DebugLogging::Util.extract_payload_and_config(
+        method_names: methods_to_notify,
+        payload: nil,
+        config: nil
+      )
+      Array(methods_to_notify).each do |method_to_notify|
+        method_to_notify, method_payload, method_config_opts = DebugLogging::Util.extract_payload_and_config(
+          method_names: method_to_notify,
+          payload: payload,
+          config: config_opts
+        )
         original_method = method(method_to_notify)
-        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
+            config_proxy = DebugLogging::Util.config_proxy_finder(
+              scope: self,
+              config_opts: method_config_opts,
+              method_name: method_to_notify,
+              proxy_ref: 'kn'
+            ) do |proxy|
+              ActiveSupport::Notifications.subscribe(
+                DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify)
+              ) do |*debug_args|
+                proxy.log do
+                  DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*debug_args))
+                end
+              end
+            end
+            paydirt = DebugLogging::Util.payload_instance_vaiable_hydration(scope: self, payload: method_payload)
             ActiveSupport::Notifications.instrument(
-              debug_event_name_to_s(method_to_notify: method_to_notify), { args: args }.merge(payload)
+              DebugLogging::ArgumentPrinter.debug_event_name_to_s(method_to_notify: method_to_notify),
+              {
+                debug_args: args,
+                config_proxy: config_proxy,
+                **paydirt
+              }
             ) do
-              original_method.call(*args, &block)
+              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
-
-        ActiveSupport::Notifications.subscribe(/log/) do |*args|
-          config_proxy&.log do
-            DebugLogging::LogSubscriber.log_event(ActiveSupport::Notifications::Event.new(*args))
-          end
-        end
       end
     end
   end

data/lib/debug_logging/configuration.rb

@@ -3,13 +3,37 @@
 module DebugLogging
   class Configuration
     DEFAULT_ELLIPSIS = ' ✂️ …'
+    CONFIG_ATTRS_DEFAULTS = {
+      enabled: true,
+      logger: Logger.new($stdout),
+      log_level: :debug,
+      multiple_last_hashes: false,
+      last_hash_to_s_proc: nil,
+      last_hash_max_length: 1_000,
+      args_to_s_proc: nil,
+      args_max_length: 1_000,
+      colorized_chain_for_method: false,
+      colorized_chain_for_class: false,
+      add_invocation_id: true,
+      ellipsis: DEFAULT_ELLIPSIS,
+      mark_scope_exit: false,
+      add_payload: true, # Can also be a proc returning a string, which will be called when printing the payload
+      payload_max_length: 1_000
+    }.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, :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
+    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`
     #
@@ -20,6 +44,7 @@ module DebugLogging
     #           log_level: :debug # at what level do the messages created by this gem sent at?
     #           last_hash_to_s_proc: nil # e.g. ->(hash) { "keys: #{hash.keys}" }
     #           last_hash_max_length: 1_000
+    #           args_to_s_proc: nil # e.g. ->(record) { "record id: #{record.id}" }
     #           args_max_length: 1_000
     #           instance_benchmarks: false
     #           class_benchmarks: false
@@ -28,20 +53,9 @@ 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_method :"debug_#{key}", :"#{key}"
+    end
 
     class << self
       def config_pointer(type, method_to_log)
@@ -52,21 +66,12 @@ 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
-      @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
+      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
 
@@ -74,7 +79,7 @@ module DebugLogging
       return unless enabled
       return unless logger
 
-      if block_given?
+      if block
         logger.send(log_level, &block)
       else
         logger.send(log_level, message)
@@ -115,26 +120,23 @@ module DebugLogging
     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,
-        active_support_notifications: active_support_notifications
-      }
+      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