debug_logging 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74f20737ddaf59151ab3118f196f2d811cfe4687
-  data.tar.gz: 21a1c19d58110b20436788e74f94c2c5fdc62c10
+  metadata.gz: 95c155d2751e4ed8027d638174dd657f1205e009
+  data.tar.gz: 26c3390ea291a866f51c77b55961ae12c8439123
 SHA512:
-  metadata.gz: 7ebb58f828a34bfa2be6c31228c977dd08e796070c2af386781efaf434d5453b7d333552908f47f8e3df5fe6a2a56148499f14d364c203cf1210309f54fa7378
-  data.tar.gz: ee69b5dab10dbb4a5a076bd62ee0d3540747201d41e7bbf22b5b71d11321c2db5dce2bbb44cbc2afb08bd2bb93a5928a24cfce9e4872d49942c327f1907b77a3
+  metadata.gz: b58918fd56b134e8e1285a4b4551e1b722c58a3138c178dcea67b0250156cb13d34588d8ed5858112024753192ba9f399c3131e50794f68ac47c814045ce1407
+  data.tar.gz: 8f6addac4962c57b13dfa9b9140775a548b845ead6df02b0c47393b3723bf26adf997807b38f84f6b6b6eb0536d8e5c0475e25ba2577a0b33344d5031e9585b7

data/README.md

@@ -79,6 +79,10 @@ end
 **All** of the above **config** is **inheritable** and **configurable** at the **per-class** level as well!
 Just prepend `debug_` to any config value you want to override in a class.
 
+**All** of the above **config** is **inheritable** and **configurable** at the **per-method** level as well!
+Just send along a hash of the config options when you call `logged` or `include DebugLogging::InstanceLogger.new(i_methods: [:drive, :stop])`.  See the example class below:
+
+
 Every time a method is called, get logs, optionally with arguments, a benchmarck, and a unique invocation identifier:
 
 ```ruby
@@ -98,18 +102,25 @@ class Car
 
   extend DebugLogging::ClassLogger
 
-  logged def debug_make; new; end
+  logged def make; new; end
   def design(*args); new; end
   def safety(*args); new; end
+  def dealer_options(*args); new; end
   logged :design, :safety
+  # override options for any instance method(s), by passing a hash as the last argument
+  logged :dealer_options, { multiple_last_hashes: true }
+
 
   def drive(speed); speed; end
-  def stop; 0; end
+  def stop(**opts); 0; end
 
   # For instance methods:
   # Option 2: add logging to all instance methods defined above (but *not* defined below)
   include DebugLogging::InstanceLogger.new(i_methods: debug_instance_methods(false))
 
+  # override options for any instance method(s)
+  include DebugLogging::InstanceLogger.new(i_methods: [:stop], config: { multiple_last_hashes: true })
+
   def will_not_be_logged; false; end
 
 end

data/lib/debug_logging/argument_printer.rb

@@ -1,27 +1,48 @@
 module DebugLogging
   module ArgumentPrinter
-    def debug_arguments_to_s(args)
-      if debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
+    def debug_arguments_to_s(args: nil, config_proxy: nil)
+      printed_args = ""
+      add_args_ellipsis = false
+      if config_proxy.debug_last_hash_to_s_proc && args[-1].is_a?(Hash)
         if args.length > 1
-          add_args_ellipsis = false
           add_last_hash_ellipsis = false
-          printed_args = args[0..(-2)].map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > debug_args_max_length}[0..(debug_args_max_length)]
-          printed_args << debug_ellipsis if add_args_ellipsis
-          printed_args << ", " << debug_last_hash_to_s_proc.call(args[-1]).tap {|x| add_last_hash_ellipsis = x.length > debug_last_hash_max_length}[0..(debug_last_hash_max_length)]
-          printed_args << debug_ellipsis if add_last_hash_ellipsis
+          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(", ").tap {|x| add_args_ellipsis = x.length > config_proxy.debug_args_max_length}[0..(config_proxy.debug_args_max_length)]
+            last_hash_args_string = last_hash_args.map do |arg|
+                                      String(config_proxy.
+                                          debug_last_hash_to_s_proc.
+                                          call(arg)).
+                                          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
+          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
+          end
         else
-          printed_args = debug_last_hash_to_s_proc.call(args[0]).tap {|x| add_last_hash_ellipsis = x.length > debug_last_hash_max_length}[0..(debug_last_hash_max_length)]
-          printed_args << 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
-        add_args_ellipsis = false
         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 > debug_args_max_length})[0..(debug_args_max_length)]
+          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)]
         else
-          printed_args = args.map {|x| x.inspect}.join(", ").tap {|x| add_args_ellipsis = x.length > debug_args_max_length}[0..(debug_args_max_length)]
+          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)]
         end
-        printed_args << 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,16 +1,27 @@
 module DebugLogging
   module ClassLogger
     def logged(*methods_to_log)
+      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 is valid
+      end
       methods_to_log.each do |method_to_log|
         # method name must be a symbol
         method_to_log = method_to_log.to_sym
         original_method = method(method_to_log)
         (class << self; self; end).class_eval do
           define_method(method_to_log) do |*args|
+            config_proxy = if opts
+                             Configuration.new(**(debug_config.to_hash.merge(opts)))
+                           else
+                             self
+                           end
             method_return_value = nil
-            invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if debug_add_invocation_id
-            debug_log "#{self}.#{method_to_log}#{debug_arguments_to_s(args)}#{invocation_id}"
-            if debug_class_benchmarks
+            invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if config_proxy.debug_add_invocation_id
+            debug_log "#{self}.#{method_to_log}#{debug_arguments_to_s(args: args, config_proxy: config_proxy)}#{invocation_id}"
+            if config_proxy.debug_class_benchmarks
               elapsed = Benchmark.realtime do
                 method_return_value = original_method.call(*args)
               end

data/lib/debug_logging/configuration.rb

@@ -1,7 +1,9 @@
 module DebugLogging
   class Configuration
+    DEFAULT_ELLIPSIS = " ✂️ …".freeze
     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
@@ -9,16 +11,45 @@ module DebugLogging
     attr_accessor :class_benchmarks
     attr_accessor :add_invocation_id
     attr_accessor :ellipsis
-    def initialize
-      @logger = Logger.new(STDOUT)
-      @log_level = :debug
-      @last_hash_to_s_proc = nil
-      @last_hash_max_length = 1_000
-      @args_max_length = 1_000
-      @instance_benchmarks = false
-      @class_benchmarks = false
-      @add_invocation_id = true
-      @ellipsis = " ✂️ …".freeze
+    # 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_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
+    #       }
+    #     )
+    #
+    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_add_invocation_id :add_invocation_id
+    alias :debug_ellipsis :ellipsis
+    def initialize(**options)
+      @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
+      @add_invocation_id = options.key?(:add_invocation_id) ? options[:add_invocation_id] : true
+      @ellipsis = options.key?(:ellipsis) ? options[:ellipsis] : DEFAULT_ELLIPSIS
     end
     def instance_benchmarks=(instance_benchmarks)
       require "benchmark" if instance_benchmarks
@@ -28,5 +59,19 @@ module DebugLogging
       require "benchmark" if class_benchmarks
       @class_benchmarks = class_benchmarks
     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,
+          add_invocation_id: add_invocation_id,
+          ellipsis: ellipsis
+      }
+    end
   end
 end

data/lib/debug_logging/instance_logger.rb

@@ -1,14 +1,14 @@
 module DebugLogging
   class InstanceLogger < Module
-    def initialize(i_methods: nil)
+    def initialize(i_methods: nil, config: nil)
+      @config = config
       @instance_methods_to_log = Array(i_methods) if i_methods
     end
     def included(base)
-      if @instance_methods_to_log
-        base.send(:include, ArgumentPrinter)
-        instance_method_logger = DebugLogging::InstanceLoggerModulizer.to_mod(@instance_methods_to_log)
-        base.send(:prepend, instance_method_logger)
-      end
+      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_proxy: @config)
+      base.send(:prepend, instance_method_logger)
     end
   end
 end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -1,18 +1,24 @@
 module DebugLogging
   module InstanceLoggerModulizer
-    def self.to_mod(methods_to_log = [])
+    def self.to_mod(methods_to_log: nil, config_proxy: nil)
       Module.new do
         Array(methods_to_log).each do |method_to_log|
           # method name must be a symbol
           define_method(method_to_log.to_sym) do |*args, &block|
+            config_proxy = if config_proxy.is_a?(Hash)
+                             Configuration.new(**(self.class.debug_config.to_hash.merge(config_proxy)))
+                           else
+                             self.class
+                           end
             method_return_value = nil
-            invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if self.class.debug_add_invocation_id && args
-            self.class.debug_log "#{self.class}##{method_to_log}#{self.class.debug_arguments_to_s(args)}#{invocation_id}"
-            if self.class.debug_instance_benchmarks
+            log_prefix = "#{self.class}##{method_to_log}"
+            invocation_id = " ~#{args.object_id}@#{Time.now.to_i}~" if config_proxy.debug_add_invocation_id && args
+            self.class.debug_log "#{log_prefix}#{self.class.debug_arguments_to_s(args: args, config_proxy: config_proxy)}#{invocation_id}"
+            if config_proxy.debug_instance_benchmarks
               elapsed = Benchmark.realtime do
                 method_return_value = super(*args, &block)
               end
-              self.class.debug_log "#{self.class}##{method_to_log} completed in #{sprintf("%f", elapsed)}s#{invocation_id}"
+              self.class.debug_log "#{log_prefix} completed in #{sprintf("%f", elapsed)}s#{invocation_id}"
             else
               method_return_value = super(*args, &block)
             end

data/lib/debug_logging/version.rb

@@ -1,3 +1,3 @@
 module DebugLogging
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/lib/debug_logging.rb

@@ -62,6 +62,12 @@ module DebugLogging
     debug_logger.send(debug_log_level, message)
   end
 
+  # There are times when the class will need access to the configuration object,
+  #   such as to override it per instance method
+  def debug_config
+    @debug_logging_configuration
+  end
+
   # For single statement global config in an initializer
   # e.g. DebugLogging.configuration.ellipsis = "..."
   def self.configuration
@@ -98,6 +104,12 @@ module DebugLogging
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-26 00:00:00.000000000 Z
+date: 2017-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-pending_for
@@ -124,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Drop-in debug logging useful when a call stack gets unruly