Add configuration option to inspect nested exceptions for exclusion (#872)

* add configuration option to inspect nested exceptions for exclusion, implement checking nested exceptions for exclusion

* make specs compatible with ruby versions that do not support `Exception#cause`

Author: effron

lib/raven/base.rb

@@ -23,6 +23,7 @@
 require 'raven/transports/http'
 require 'raven/utils/deep_merge'
 require 'raven/utils/real_ip'
+require 'raven/utils/exception_cause_chain'
 require 'raven/instance'
 
 require 'forwardable'

lib/raven/configuration.rb

@@ -1,7 +1,7 @@
 require 'uri'
 
 module Raven
-  class Configuration
+  class Configuration # rubocop:disable Metrics/ClassLength
     # Directories to be recognized as part of your app. e.g. if you
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
@@ -31,6 +31,10 @@ class Configuration
     # You should probably append to this rather than overwrite it.
     attr_accessor :excluded_exceptions
 
+    # Boolean to check nested exceptions when deciding if to exclude. Defaults to false
+    attr_accessor :inspect_exception_causes_for_exclusion
+    alias inspect_exception_causes_for_exclusion? inspect_exception_causes_for_exclusion
+
     # DSN component - set automatically if DSN provided
     attr_accessor :host
 
@@ -205,6 +209,7 @@ def initialize
       self.environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
+      self.inspect_exception_causes_for_exclusion = false
       self.linecache = ::Raven::LineCache.new
       self.logger = ::Raven::Logger.new(STDOUT)
       self.open_timeout = 1
@@ -349,14 +354,24 @@ def detect_release
       logger.error "Error detecting release: #{ex.message}"
     end
 
-    def excluded_exception?(exc)
-      excluded_exceptions.any? { |x| get_exception_class(x) === exc }
+    def excluded_exception?(incoming_exception)
+      excluded_exceptions.any? do |excluded_exception|
+        matches_exception?(get_exception_class(excluded_exception), incoming_exception)
+      end
     end
 
     def get_exception_class(x)
       x.is_a?(Module) ? x : qualified_const_get(x)
     end
 
+    def matches_exception?(excluded_exception_class, incoming_exception)
+      if inspect_exception_causes_for_exclusion?
+        Raven::Utils::ExceptionCauseChain.exception_to_array(incoming_exception).any? { |cause| excluded_exception_class === cause }
+      else
+        excluded_exception_class === incoming_exception
+      end
+    end
+
     # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
     def qualified_const_get(x)
       x = x.to_s

lib/raven/event.rb

@@ -139,7 +139,7 @@ def to_json_compatible
 
     def add_exception_interface(exc)
       interface(:exception) do |exc_int|
-        exceptions = exception_chain_to_array(exc)
+        exceptions = Raven::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
         backtraces = Set.new
         exc_int.values = exceptions.map do |e|
           SingleExceptionInterface.new do |int|
@@ -237,20 +237,6 @@ def async_json_processors
       ].map { |v| v.new(self) }
     end
 
-    def exception_chain_to_array(exc)
-      if exc.respond_to?(:cause) && exc.cause
-        exceptions = [exc]
-        while exc.cause
-          exc = exc.cause
-          break if exceptions.any? { |e| e.object_id == exc.object_id }
-          exceptions << exc
-        end
-        exceptions.reverse!
-      else
-        [exc]
-      end
-    end
-
     def list_gem_specs
       # Older versions of Rubygems don't support iterating over all specs
       Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)

lib/raven/utils/exception_cause_chain.rb

@@ -0,0 +1,19 @@
+module Raven
+  module Utils
+    module ExceptionCauseChain
+      def self.exception_to_array(exception)
+        if exception.respond_to?(:cause) && exception.cause
+          exceptions = [exception]
+          while exception.cause
+            exception = exception.cause
+            break if exceptions.any? { |e| e.object_id == exception.object_id }
+            exceptions << exception
+          end
+          exceptions
+        else
+          [exception]
+        end
+      end
+    end
+  end
+end

spec/raven/configuration_spec.rb

@@ -185,4 +185,66 @@
       expect(subject.capture_allowed?).to eq(true)
     end
   end
+
+  describe '#exception_class_allowed?' do
+    class MyTestException < RuntimeError; end
+
+    context 'with custom excluded_exceptions' do
+      before do
+        subject.excluded_exceptions = ['MyTestException']
+      end
+
+      context 'when the raised exception is a Raven::Error' do
+        let(:incoming_exception) { Raven::Error.new }
+        it 'returns false' do
+          expect(subject.exception_class_allowed?(incoming_exception)).to eq false
+        end
+      end
+
+      context 'when the raised exception is not in excluded_exceptions' do
+        let(:incoming_exception) { RuntimeError.new }
+        it 'returns true' do
+          expect(subject.exception_class_allowed?(incoming_exception)).to eq true
+        end
+      end
+
+      context 'when the raised exception has a cause that is in excluded_exceptions' do
+        let(:incoming_exception) { build_exception_with_cause(MyTestException.new) }
+        context 'when inspect_exception_causes_for_exclusion is false' do
+          it 'returns true' do
+            expect(subject.exception_class_allowed?(incoming_exception)).to eq true
+          end
+        end
+
+        # Only check causes when they're supported by the ruby version
+        context 'when inspect_exception_causes_for_exclusion is true' do
+          before do
+            subject.inspect_exception_causes_for_exclusion = true
+          end
+
+          if Exception.new.respond_to? :cause
+            context 'when the language version supports exception causes' do
+              it 'returns false' do
+                expect(subject.exception_class_allowed?(incoming_exception)).to eq false
+              end
+            end
+          else
+            context 'when the language version does not support exception causes' do
+              it 'returns true' do
+                expect(subject.exception_class_allowed?(incoming_exception)).to eq true
+              end
+            end
+          end
+        end
+      end
+
+      context 'when the raised exception is in excluded_exceptions' do
+        let(:incoming_exception) { MyTestException.new }
+
+        it 'returns false' do
+          expect(subject.exception_class_allowed?(incoming_exception)).to eq false
+        end
+      end
+    end
+  end
 end

spec/raven/utils/exception_cause_chain_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe Raven::Utils::ExceptionCauseChain do
+  describe '.exception_to_array' do
+    # Only check causes when they're supported
+    if Exception.new.respond_to? :cause
+      context 'when the ruby version supports exception causes' do
+        context 'when the exception has a cause' do
+          let(:exception) { build_exception_with_cause }
+
+          it 'captures the cause' do
+            expect(described_class.exception_to_array(exception).length).to eq(2)
+          end
+        end
+
+        context 'when the exception has nested causes' do
+          let(:exception) { build_exception_with_two_causes }
+
+          it 'captures nested causes' do
+            expect(described_class.exception_to_array(exception).length).to eq(3)
+          end
+        end
+
+        context 'when the exception has a recursive cause' do
+          let(:exception) { build_exception_with_recursive_cause }
+
+          it 'should handle it gracefully' do
+            expect(described_class.exception_to_array(exception).length).to eq(1)
+          end
+        end
+      end
+    else
+      context 'when the ruby version does not support exception causes' do
+        let(:exception) { build_exception_with_two_causes }
+
+        it 'returns the passed in exception' do
+          expect(described_class.exception_to_array(exception)).to eq [exception]
+        end
+      end
+    end
+  end
+end

spec/spec_helper.rb

@@ -42,9 +42,9 @@ def build_exception
   return exception
 end
 
-def build_exception_with_cause
+def build_exception_with_cause(cause = "exception a")
   begin
-    raise "exception a"
+    raise cause
   rescue
     raise "exception b"
   end