debug_logging 1.0.11 → 1.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ea3afaf91b55426d0c4f6674c0515a261dfa77e
-  data.tar.gz: 537a3865676eda1263d32ed4a63b08644724cca6
+  metadata.gz: fd9ac9873cb177a6864e30599bdcfe3093837415
+  data.tar.gz: cde61e395a53bf5289ead7d0cd823de06c2925a3
 SHA512:
-  metadata.gz: 5185c10484ed70e559c6b97671e2b64b4e4d70a65db62f09f9e6af07b4bda6d288887bfd7675d22b9989c5542a36ebee354d0638b48854daf1096d04b3b6fcd6
-  data.tar.gz: 500daf82402c0709b67c016f4e03b7d96a605949f9255bdb54269577952b55ff1d691acecc8202a25e1082afe0d0a4bd02438593e3a4d2216606727e686b28e8
+  metadata.gz: 31bf8b39f62289b7bf0e8ef845cdca2a8049ba492ce259ba9c19b2cf11fb364a004228d710e1d791ef6c83251e029a8f65c884ff0bcff03d39d901a47a7299c6
+  data.tar.gz: f6a1ec5e93ad0c074a3fa91ff50a676db59afaff1406d7b382616cfc383a54690769e763ef1b4b2d9f7bd7342c0446e903b71a633857e1dfd9eaaba9d63bfc29

data/.travis.yml

@@ -1,9 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - ruby-2.1.10
-  - ruby-2.2.7
   - ruby-2.3.4
-  - ruby-2.4.1
+  - ruby-2.4.2
   - jruby-9.1.9.0
 before_install: gem install bundler -v 1.15.4

data/README.md

@@ -7,9 +7,11 @@ Unobtrusive, inheritable-overridable-configurable, drop-in debug logging, that w
 * *colorization by class/method*
 * *robust argument printer with customizable ellipsis*
 * *unique invocation identifiers*
-* *single line config*
-* *separate logger*
-* a free pony
+* *single line config, per class/instance/method config*
+* *separate logger, if needed*
+* *log method calls, also when exit scope*
+* *Prevents heavy computation of strings with `logger.debug { 'log me' }` block format.*
+* **so many free ponies** 🎠🐴🎠🐴🎠🐴
 
 | Project                 |  DebugLogging     |
 |------------------------ | ----------------- |
@@ -65,7 +67,9 @@ Or install it yourself as:
 
 ## Usage
 
-Crack open the specs for usage examples.
+NOTE: Starting with version `1.0.12` this gem utilizes the `logger.debug { "block format" }` to avoid heavy debug processing when the log level threshold is set higher than the level of the statements produced as a result of the configuration of this gem.
+
+Crack open the specs for more complex usage examples than the ones below.
 
 ### Without Rails
 
@@ -90,6 +94,7 @@ DebugLogging.configuration.colorized_chain_for_method = false # e.g. ->(colorize
 DebugLogging.configuration.colorized_chain_for_class = false # e.g. ->(colorized_string) { colorized_string.colorize(:light_blue ).colorize( :background => :red) }
 DebugLogging.configuration.add_invocation_id = true # identify a method call uniquely in a log, pass a proc for colorization, e.g. ->(colorized_string) { colorized_string.light_black }
 DebugLogging.configuration.ellipsis = " ✂️ …".freeze
+DebugLogging.configuration.mark_scope_exit = true # Only has an effect if benchmarking is off, since benchmarking always marks the scope exit
 ```
 
 If you prefer to use the block style:
@@ -108,14 +113,18 @@ DebugLogging.configure do |config|
   config.colorized_chain_for_class = false # e.g. ->(colorized_string) { colorized_string.colorize(:light_blue ).colorize( :background => :red) }
   config.add_invocation_id = true # identify a method call uniquely in a log, pass a proc for colorization, e.g. ->(colorized_string) { colorized_string.light_black }
   config.ellipsis = " ✂️ …".freeze
+  config.mark_scope_exit = true # Only has an effect if benchmarking is off, since benchmarking always marks the scope exit
 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-instance** level as well!
+Just prepend `debug_` to any config value you want to override on an instance of 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, and the specs.
+Just send along a hash of the config options when you call `logged` or `include DebugLogging::InstanceLogger.new(i_methods: [:drive, :stop], config: { ellipsis = " ✂️ 2 much" })`.  See the example class below, and the specs.
 
 **NOTE ON** `Rails.logger` - It will probably be nil in your initializer, so setting the `config.logger` to `Rails.logger` there will result in setting it to `nil`, which means the default will end up being used: `Logger.new(STDOUT)`. Instead just config the logger in your application.rb, or anytime later, but *before your classes get loaded* and start inheriting the config:
 

data/debug_logging.gemspec

@@ -31,4 +31,5 @@ Automatically log selected methods and their arguments as they are called at run
   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"
 end

data/lib/debug_logging.rb

@@ -60,9 +60,15 @@ module DebugLogging
   end
 
   #### API ####
-  def debug_log(message, config_proxy = nil)
-    config_proxy ||= self
-    config_proxy.debug_logger.send(config_proxy.debug_log_level, message) if config_proxy.debug_logger
+  # 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 
+    #   potentially customized copy of the default config for the whole app.
+    config_proxy ||= debug_config
+    config_proxy.log(message, &block)
   end
 
   # There are times when the class will need access to the configuration object,
@@ -161,6 +167,12 @@ module DebugLogging
   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

data/lib/debug_logging/class_logger.rb

@@ -1,11 +1,13 @@
 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 is valid
+        # logged :meth1, :meth2, :meth3 without options is valid too
       end
       methods_to_log.each do |method_to_log|
         # method name must be a symbol
@@ -19,24 +21,35 @@ module DebugLogging
                              proxy = if opts
                                        Configuration.new(**(debug_config.to_hash.merge(opts)))
                                      else
-                                       self
+                                       debug_config
                                      end
+                             proxy.register(method_to_log)
                              instance_variable_set("@debug_config_proxy_for_k_#{method_to_log}".to_sym, proxy)
                              proxy
                            end
             method_return_value = nil
-            # TODO: Put all the logic into a logger block, so it will never be computed at runtime if the log level is too high
-            log_prefix = debug_invocation_to_s(klass: self.to_s, separator: ".", method_to_log: method_to_log, config_proxy: config_proxy)
-            signature = debug_signature_to_s(args: args, config_proxy: config_proxy)
-            invocation_id = debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
-            debug_log("#{log_prefix}#{signature}#{invocation_id}", config_proxy)
-            if config_proxy.debug_class_benchmarks
+            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)
+              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}"
+            end
+            if config_proxy.benchmarkable_for?(:debug_class_benchmarks)
               tms = Benchmark.measure do
                 method_return_value = original_method.call(*args, &block)
               end
-              debug_log("#{log_prefix} #{debug_benchmark_to_s(tms: tms)}#{invocation_id}", config_proxy)
+              config_proxy.log do
+                "#{log_prefix} #{debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+              end
             else
               method_return_value = original_method.call(*args, &block)
+              if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+                config_proxy.log do
+                  "#{log_prefix} completed#{invocation_id}"
+                end
+              end
             end
             method_return_value
           end

data/lib/debug_logging/configuration.rb

@@ -1,6 +1,7 @@
 module DebugLogging
   class Configuration
     DEFAULT_ELLIPSIS = " ✂️ …".freeze
+    # 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
@@ -13,6 +14,8 @@ module DebugLogging
     attr_accessor :colorized_chain_for_class
     attr_accessor :add_invocation_id
     attr_accessor :ellipsis
+    attr_accessor :mark_scope_exit
+    attr_reader :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`
     #
@@ -43,6 +46,7 @@ module DebugLogging
     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
     def initialize(**options)
       @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
       @log_level = options.key?(:log_level) ? options[:log_level] : :debug
@@ -56,6 +60,28 @@ module DebugLogging
       @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
+      @methods_to_log = []
+    end
+    def log(message = nil, &block)
+      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)
+    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
@@ -81,5 +107,8 @@ module DebugLogging
           ellipsis: ellipsis
       }
     end
+    def register(method_lo_log)
+      @methods_to_log << method_lo_log
+    end
   end
 end

data/lib/debug_logging/instance_logger_modulizer.rb

@@ -4,7 +4,6 @@ module DebugLogging
       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|
             method_return_value = nil
             config_proxy = if (proxy = instance_variable_get("@debug_config_proxy_for_#{method_to_log}".to_sym))
@@ -13,23 +12,32 @@ module DebugLogging
                              proxy = if config
                                        Configuration.new(**(self.class.debug_config.to_hash.merge(config))) 
                                      else
-                                       self.class
+                                       self.class.debug_config
                                      end
+                             proxy.register(method_to_log)
                              instance_variable_set("@debug_config_proxy_for_#{method_to_log}".to_sym, proxy)
                              proxy
                            end
-            # TODO: Put all the logic into a logger block, so it will never be computed at runtime if the log level is too high
             log_prefix = self.class.debug_invocation_to_s(klass: self.class.to_s, separator: "#", method_to_log: method_to_log, config_proxy: config_proxy)
-            signature = self.class.debug_signature_to_s(args: args, config_proxy: config_proxy)
             invocation_id = self.class.debug_invocation_id_to_s(args: args, config_proxy: config_proxy)
-            self.class.debug_log("#{log_prefix}#{signature}#{invocation_id}", config_proxy)
-            if config_proxy.debug_instance_benchmarks
+            config_proxy.log do
+              signature = self.class.debug_signature_to_s(args: args, config_proxy: config_proxy)
+              "#{log_prefix}#{signature}#{invocation_id}"
+            end
+            if config_proxy.benchmarkable_for?(:debug_instance_benchmarks)
               tms = Benchmark.measure do
                 method_return_value = super(*args, &block)
               end
-              self.class.debug_log("#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}", config_proxy)
+              config_proxy.log do
+                "#{log_prefix} #{self.class.debug_benchmark_to_s(tms: tms)}#{invocation_id}"
+              end
             else
               method_return_value = super(*args, &block)
+              if config_proxy.exit_scope_markable? && invocation_id && !invocation_id.empty?
+                config_proxy.log do
+                  "#{log_prefix} completed#{invocation_id}"
+                end
+              end
             end
             method_return_value
           end

data/lib/debug_logging/version.rb

@@ -1,3 +1,3 @@
 module DebugLogging
-  VERSION = "1.0.11"
+  VERSION = "1.0.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: debug_logging
 version: !ruby/object:Gem::Version
-  version: 1.0.11
+  version: 1.0.12
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-06 00:00:00.000000000 Z
+date: 2017-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
 description: |2
 
   Unobtrusive debug logging for Ruby.  NO LITTERING.