logging 2.2.1 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4be0dd542e3eac91b3ad7f7895e7a0dbfdadd66
-  data.tar.gz: 960c2a5e039c3f455f29dd6bf4fe3a700957194b
+  metadata.gz: bb433e2db44c13bc4956095561ad2ad34cd4fabf
+  data.tar.gz: 6d6a401267834a2b1dad3c5992bb4c4c28ea05a0
 SHA512:
-  metadata.gz: ab8acc6f8f984c8533c667c73fffb4b6e5286d1a401af2989ca1d1e0a4beac3b2147abf9c87dcf52339e32da1be8b3db41d770acb9c38c40e84c07e50b3e9776
-  data.tar.gz: 2bdab15e9bfb48a5b3a30214bdaf375b2536dac54a334ee27ca8fafbda1ba6068a6a0aff1a91524eadd10d22525a5607eb41eacf3fc8e8d69402b08fd5ec73df
+  metadata.gz: 44ad1070f56d8618f9e6c118876364f70442723424d055716928e422a6699a40e744c68a86619227ed8fd5eea26e6c1fd6850f50877c74769a5160d6133b5140
+  data.tar.gz: bf24fb750a15937f18d75b2acc738e323a8ea718661bb9877ea64b0d23eea12def864c3175e71cd1f9b7ccff69c44d661455ff3526e5c192cc0f67c026a77a7f

data/History.txt

@@ -1,3 +1,8 @@
+== 2.2.2 / 2017-04-11
+
+Enhancements
+- limit the depth of nested exceptions [PR #167]
+
 == 2.2.1 / 2017-04-09
 
 Enhancements

data/lib/logging.rb

@@ -23,6 +23,8 @@ module Logging
   PATH = ::File.expand_path('../..', __FILE__) + ::File::SEPARATOR
   LEVELS = {}
   LNAMES = []
+  DEFAULT_CAUSE_DEPTH = 8
+
   module Plugins; end
   # :startdoc:
 
@@ -255,6 +257,8 @@ module Logging
       longest = 'off' if longest.length < 3
       module_eval "MAX_LEVEL_LENGTH = #{longest.length}", __FILE__, __LINE__
 
+      self.cause_depth = nil unless defined? @cause_depth
+
       initialize_plugins
       levels.keys
     end
@@ -336,6 +340,27 @@ module Logging
 
     attr_reader :utc_offset
 
+    # Set the default Exception#cause depth used when formatting Exceptions.
+    # This sets the maximum number of nested errors that will be formatted by
+    # the layouts before giving up. This is used to avoid extremely large
+    # outputs.
+    #
+    #   Logging.cause_depth = nil    # set to the DEFAULT_CAUSE_DEPTH
+    #   Logging.cause_depth = 0      # do not show any exception causes
+    #   Logging.cause_depth = 1024   # show up to 1024 causes
+    #   Logging.cause_depth = -1     # results in the DEFAULT_CAUSE_DEPTH
+    #
+    def cause_depth=( value )
+      if value.nil?
+        @cause_depth = DEFAULT_CAUSE_DEPTH
+      else
+        value = Integer(value)
+        @cause_depth = value < 0 ? DEFAULT_CAUSE_DEPTH : value
+      end
+    end
+
+    attr_reader :cause_depth
+
     # Used to define a `basepath` that will be removed from filenames when
     # reporting tracing information for log events. Normally you would set this
     # to the root of your project:
@@ -516,7 +541,8 @@ module Logging
       remove_instance_variable :@basepath  if defined? @basepath
       remove_const :MAX_LEVEL_LENGTH if const_defined? :MAX_LEVEL_LENGTH
       remove_const :OBJ_FORMAT if const_defined? :OBJ_FORMAT
-      self.utc_offset = nil
+      self.utc_offset  = nil
+      self.cause_depth = nil
       self
     end
 

data/lib/logging/layout.rb

@@ -41,8 +41,9 @@ class Layout
                   when :inspect, :yaml, :json; f
                   else :string end
 
-    self.backtrace  = opts.fetch(:backtrace,  ::Logging.backtrace)
-    self.utc_offset = opts.fetch(:utc_offset, ::Logging.utc_offset)
+    self.backtrace   = opts.fetch(:backtrace,   ::Logging.backtrace)
+    self.utc_offset  = opts.fetch(:utc_offset,  ::Logging.utc_offset)
+    self.cause_depth = opts.fetch(:cause_depth, ::Logging.cause_depth)
   end
 
   # call-seq:
@@ -89,6 +90,20 @@ class Layout
   # Returns the UTC offset.
   attr_reader :utc_offset
 
+  #
+  #
+  def cause_depth=( value )
+    if value.nil?
+      @cause_depth = ::Logging::DEFAULT_CAUSE_DEPTH
+    else
+      value = Integer(value)
+      @cause_depth = value < 0 ? ::Logging::DEFAULT_CAUSE_DEPTH : value
+    end
+  end
+
+  # Returns the exception cause depth formatting limit.
+  attr_reader :cause_depth
+
   # Internal: Helper method that applies the UTC offset to the given `time`
   # instance. A new Time is returned that is equivalent to the original `time`
   # but pinned to the timezone given by the UTC offset.
@@ -142,15 +157,10 @@ class Layout
     case obj
     when String; obj
     when Exception
-      ary = ["<#{obj.class.name}> #{obj.message}"]
-      if backtrace? && !obj.backtrace.nil?
-        ary.concat(obj.backtrace)
-      end
-      if defined?(obj.cause) && !obj.cause.nil?
-        ary << "--- Caused by ---"
-        ary << format_obj(obj.cause)
-      end
-      ary.join("\n\t")
+      lines = ["<#{obj.class.name}> #{obj.message}"]
+      lines.concat(obj.backtrace) if backtrace? && obj.backtrace
+      format_cause(obj, lines)
+      lines.join("\n\t")
     when nil; "<#{obj.class.name}> nil"
     else
       str = "<#{obj.class.name}> "
@@ -163,6 +173,64 @@ class Layout
     end
   end
 
+  # Internal: Format any nested exceptions found in the given exception `e`
+  # while respecting the maximum `cause_depth`. The lines array is used to
+  # capture all the output lines form the nested exceptions; the array is later
+  # joined by the `format_obj` method.
+  #
+  # e     - Exception to format
+  # lines - Array of output lines
+  #
+  # Returns the input `lines` Array
+  def format_cause(e, lines)
+    return lines if cause_depth == 0
+
+    cause_depth.times do
+      break unless e.respond_to?(:cause) && e.cause
+
+      cause = e.cause
+      lines << "--- Caused by ---"
+      lines << "<#{cause.class.name}> #{cause.message}"
+      lines.concat(format_cause_backtrace(e, cause)) if backtrace? && cause.backtrace
+
+      e = cause
+    end
+
+    if e.respond_to?(:cause) && e.cause
+      lines << "--- Further #cause backtraces were omitted ---"
+    end
+
+    lines
+  end
+
+  # Internal: Format the backtrace of the nested `cause` but remove the common
+  # exception lines from the parent exception. This helps keep the backtraces a
+  # wee bit shorter and more comprehensible.
+  #
+  # e     - parent exception
+  # cause - the nested exception generating the returned backtrace
+  #
+  # Returns an Array of backtracke lines.
+  def format_cause_backtrace(e, cause)
+    # Find where the cause's backtrace differs from the parent exception's.
+    backtrace       = Array(e.backtrace)
+    cause_backtrace = Array(cause.backtrace)
+    index = -1
+    min_index = [backtrace.size, cause_backtrace.size].min * -1
+    just_in_case = -5000
+
+    while index > min_index && backtrace[index] == cause_backtrace[index] && index >= just_in_case
+      index -= 1
+    end
+
+    # Add on a few common frames to make it clear where the backtraces line up.
+    index += 3
+    index = -1 if index >= 0
+
+    cause_backtrace[0..index]
+  end
+
+
   # Attempt to format the _obj_ using yaml, but fall back to inspect style
   # formatting if yaml fails.
   #
@@ -188,7 +256,5 @@ class Layout
   rescue StandardError
     obj.inspect
   end
-
-end  # class Layout
-end  # module Logging
-
+end
+end

data/lib/logging/layouts/parseable.rb

@@ -219,11 +219,15 @@ module Logging::Layouts
     def format_obj( obj )
       case obj
       when Exception
-        h = { :class   => obj.class.name,
-              :message => obj.message }
-        h[:backtrace] = obj.backtrace if backtrace? && !obj.backtrace.nil?
-        h[:cause] = format_obj(obj.cause) if defined?(obj.cause) && !obj.cause.nil?
-        h
+        hash = {
+          :class   => obj.class.name,
+          :message => obj.message
+        }
+        hash[:backtrace] = obj.backtrace if backtrace? && obj.backtrace
+
+        cause = format_cause(obj)
+        hash[:cause] = cause unless cause.empty?
+        hash
       when Time
         iso8601_format(obj)
       else
@@ -231,6 +235,37 @@ module Logging::Layouts
       end
     end
 
+    # Internal: Format any nested exceptions found in the given exception `e`
+    # while respecting the maximum `cause_depth`.
+    #
+    # e - Exception to format
+    #
+    # Returns the cause formatted as a Hash
+    def format_cause(e)
+      rv = curr = {}
+      prev = nil
+
+      cause_depth.times do
+        break unless e.respond_to?(:cause) && e.cause
+
+        cause = e.cause
+        curr[:class]     = cause.class.name
+        curr[:message]   = cause.message
+        curr[:backtrace] = format_cause_backtrace(e, cause) if backtrace? && cause.backtrace
+
+        prev[:cause] = curr unless prev.nil?
+        prev, curr = curr, {}
+
+        e = cause
+      end
+
+      if e.respond_to?(:cause) && e.cause
+        prev[:cause] = {message: "Further #cause backtraces were omitted"}
+      end
+
+      rv
+    end
+
   private
 
     # Call the appropriate class level create format method based on the
@@ -258,6 +293,5 @@ module Logging::Layouts
       return str << (value.gmt_offset < 0 ? '-' : '+') << offset
     end
 
-  end  # Parseable
-end  # Logging::Layouts
-
+  end
+end

data/lib/logging/version.rb

@@ -1,5 +1,5 @@
 module Logging
-  VERSION = "2.2.1".freeze
+  VERSION = "2.2.2".freeze
 
   # Returns the version string for the library.
   def self.version

data/test/layouts/test_nested_exceptions.rb

@@ -7,46 +7,118 @@ module TestLogging
       include LoggingTestCase
 
       def test_basic_format_obj
+        err = nil
         begin
-          raise StandardError, 'nested exception'
-        rescue
-          raise Exception, 'root exception'
+          begin
+            raise ArgumentError, 'nested exception'
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
         end
-      rescue Exception => e
+
         layout = Logging.layouts.basic({})
         log = layout.format_obj(e)
-        assert_not_nil log.index('<Exception> root exception')
+        assert_not_nil log.index('<StandardError> root exception')
+
+        if err.respond_to?(:cause)
+          assert_not_nil log.index('<ArgumentError> nested exception')
+          assert(log.index('<StandardError> root exception') < log.index('<ArgumentError> nested exception'))
+        end
+      end
+
+      def test_cause_depth_limiting
+        err = nil
+        begin
+          begin
+            begin
+              raise TypeError, 'nested exception 2'
+            rescue
+              raise ArgumentError, 'nested exception 1'
+            end
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.basic(cause_depth: 1)
+        log = layout.format_obj(e)
+        assert_not_nil log.index('<StandardError> root exception')
 
-        if defined? e.cause
-          assert_not_nil log.index('<StandardError> nested exception')
-          assert_operator log.index('<Exception> root exception'), :<, log.index('<StandardError> nested exception')
+        if err.respond_to?(:cause)
+          assert_not_nil log.index('<ArgumentError> nested exception 1')
+          assert_nil log.index('<TypeError> nested exception 2')
+          assert_equal '--- Further #cause backtraces were omitted ---', log.split("\n\t").last
         end
       end
 
       def test_parseable_format_obj
+        err = nil
         begin
-          raise StandardError, 'nested exception'
-        rescue
-          raise Exception, 'root exception'
+          begin
+            raise ArgumentError, 'nested exception'
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
         end
-      rescue Exception => e
+
         layout = Logging.layouts.parseable.new
         log = layout.format_obj(e)
-        assert_equal Exception.name, log[:class]
+        assert_equal 'StandardError', log[:class]
         assert_equal 'root exception', log[:message]
-        assert_operator log[:backtrace].size, :>, 0
+        assert log[:backtrace].size > 0
 
-        if defined? e.cause
+        if e.respond_to?(:cause)
           assert_not_nil log[:cause]
 
           log = log[:cause]
-          assert_equal StandardError.name, log[:class]
+          assert_equal 'ArgumentError', log[:class]
           assert_equal 'nested exception', log[:message]
           assert_nil log[:cause]
-          assert_operator log[:backtrace].size, :>, 0
+          assert log[:backtrace].size > 0
+        end
+      end
+
+      def test_parseable_cause_depth_limiting
+        err = nil
+        begin
+          begin
+            begin
+              raise TypeError, 'nested exception 2'
+            rescue
+              raise ArgumentError, 'nested exception 1'
+            end
+          rescue
+            raise StandardError, 'root exception'
+          end
+        rescue => e
+          err = e
+        end
+
+        layout = Logging.layouts.parseable.new(cause_depth: 1)
+        log = layout.format_obj(e)
+
+        assert_equal 'StandardError', log[:class]
+        assert_equal 'root exception', log[:message]
+        assert log[:backtrace].size > 0
+
+        if e.respond_to?(:cause)
+          assert_not_nil log[:cause]
+
+          log = log[:cause]
+          assert_equal 'ArgumentError', log[:class]
+          assert_equal 'nested exception 1', log[:message]
+          assert_equal({message: "Further #cause backtraces were omitted"}, log[:cause])
+          assert log[:backtrace].size > 0
         end
       end
     end
   end
 end
 
+require 'pp'

data/test/test_logging.rb

@@ -54,6 +54,24 @@ module TestLogging
       assert_raise(ArgumentError) {::Logging.utc_offset = "06:00"}
     end
 
+    def test_cause_depth
+      assert_equal ::Logging::DEFAULT_CAUSE_DEPTH, ::Logging.cause_depth
+
+      ::Logging.cause_depth = 0
+      assert_equal 0, ::Logging.cause_depth
+
+      ::Logging.cause_depth = nil
+      assert_equal ::Logging::DEFAULT_CAUSE_DEPTH, ::Logging.cause_depth
+
+      ::Logging.cause_depth = "1024"
+      assert_equal 1024, ::Logging.cause_depth
+
+      ::Logging.cause_depth = -1
+      assert_equal ::Logging::DEFAULT_CAUSE_DEPTH, ::Logging.cause_depth
+
+      assert_raise(ArgumentError) {::Logging.cause_depth = "foo"}
+    end
+
     def test_basepath
       assert_nil ::Logging.basepath
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logging
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.2.2
 platform: ruby
 authors:
 - Tim Pease
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: little-plugger