Added unhandled functionality, updated tests and integrations

lib/bugsnag.rb

@@ -34,7 +34,9 @@ def configure
 
     # Explicitly notify of an exception
     def notify(exception, auto_notify=false, &block)
-      if auto_notify && !configuration.auto_notify
+      report = Report.new(exception, configuration, auto_notify)
+
+      if !configuration.auto_notify && auto_notify
         configuration.debug("Not notifying because auto_notify is disabled")
         return
       end
@@ -49,8 +51,6 @@ def notify(exception, auto_notify=false, &block)
         return
       end
 
-      report = Report.new(exception, configuration)
-
       # If this is an auto_notify we yield the block before the any middleware is run
       yield(report) if block_given? && auto_notify
       if report.ignore?
@@ -65,13 +65,27 @@ def notify(exception, auto_notify=false, &block)
         return
       end
 
+      # Store before_middleware severity reason for future reference
+      before_middleware_severity = report.severity
+      before_middleware_reason = report.severity_reason
+
       # Run users middleware
       configuration.middleware.run(report) do
         if report.ignore?
           configuration.debug("Not notifying #{report.exceptions.last[:errorClass]} due to ignore being signified in user provided middleware")
           return
         end
 
+        # Update severity reason if necessary
+        if report.severity != before_middleware_severity
+          report.severity_reason = {
+            :type => "userSpecifiedSeverity"
+          }
+        end
+
+        # Store severity before user callbacks
+        before_callback_severity = report.severity
+
         # If this is not an auto_notify then the block was provided by the user. This should be the last
         # block that is run as it is the users "most specific" block.
         yield(report) if block_given? && !auto_notify
@@ -80,6 +94,16 @@ def notify(exception, auto_notify=false, &block)
           return
         end
 
+        # Test whether severity has been changed and ensure severity_reason is consistant in auto_notify case
+        if auto_notify
+          report.severity = before_middleware_severity
+          report.severity_reason = before_middleware_reason
+        elsif report.severity != before_callback_severity
+          report.severity_reason = {
+            :type => "userCallbackSeverity"
+          }
+        end
+
         # Deliver
         configuration.info("Notifying #{configuration.endpoint} of #{report.exceptions.last[:errorClass]}")
         payload_string = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(report.as_json))

lib/bugsnag/configuration.rb

@@ -5,6 +5,7 @@
 require "bugsnag/middleware/callbacks"
 require "bugsnag/middleware/exception_meta_data"
 require "bugsnag/middleware/ignore_error_class"
+require "bugsnag/middleware/classify_error"
 
 module Bugsnag
   class Configuration
@@ -73,6 +74,7 @@ def initialize
       self.internal_middleware = Bugsnag::MiddlewareStack.new
       self.internal_middleware.use Bugsnag::Middleware::ExceptionMetaData
       self.internal_middleware.use Bugsnag::Middleware::IgnoreErrorClass
+      self.internal_middleware.use Bugsnag::Middleware::ClassifyError
 
       self.middleware = Bugsnag::MiddlewareStack.new
       self.middleware.use Bugsnag::Middleware::Callbacks

lib/bugsnag/integrations/delayed_job.rb

@@ -36,6 +36,12 @@ def error(job, error)
 
             ::Bugsnag.notify(error, true) do |report|
               report.severity = "error"
+              report.set_handled_state({
+                :type => "unhandledExceptionMiddleware",
+                :attributes => {
+                  :framework => "DelayedJob"
+                }
+              })
               report.meta_data.merge! overrides
             end
 

lib/bugsnag/integrations/mailman.rb

@@ -15,6 +15,12 @@ def call(mail)
         raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
         Bugsnag.notify(ex, true) do |report|
           report.severity = "error"
+          report.set_handled_state({
+            :type => "unhandledExceptionMiddleware",
+            :attributes => {
+              :framework => "Mailman"
+            }
+          })
         end
         raise
       ensure

lib/bugsnag/integrations/rack.rb

@@ -35,6 +35,12 @@ def call(env)
         # Notify bugsnag of rack exceptions
         Bugsnag.notify(raised, true) do |report|
           report.severity = "error"
+          report.set_handled_state({
+            :type => "unhandledExceptionMiddleware",
+            :attirbutes => {
+              :framework => "Rack"
+            }
+          })
         end
 
         # Re-raise the exception
@@ -45,6 +51,12 @@ def call(env)
       if env["rack.exception"]
         Bugsnag.notify(env["rack.exception"], true) do |report|
           report.severity = "error"
+          report.set_handled_state({
+            :type => "middleware_handler",
+            :attributes => {
+              :name => "rack"
+            }
+          })
         end
       end
 

lib/bugsnag/integrations/rails/active_record_rescue.rb

@@ -10,6 +10,12 @@ def run_callbacks(kind, *args, &block)
           # This exception will NOT be escalated, so notify it here.
           Bugsnag.notify(exception, true) do |report|
             report.severity = "error"
+            report.set_handled_state({
+              :type => "unhandledExceptionMiddleware",
+              :attributes => {
+                :framework => "Rails"
+              }
+            })
           end
           raise
         end

lib/bugsnag/integrations/railtie.rb

@@ -19,6 +19,12 @@ class Railtie < Rails::Railtie
           if $!
             Bugsnag.notify($!, true) do |report|
               report.severity = "error"
+              report.set_handled_state({
+                :type => "unhandledExceptionMiddleware",
+                :attributes => {
+                  :framework => "Rails"
+                }
+              })
             end
           end
         end

lib/bugsnag/integrations/rake.rb

@@ -14,6 +14,12 @@ def execute_with_bugsnag(args=nil)
   rescue Exception => ex
     Bugsnag.notify(ex, true) do |report|
       report.severity = "error"
+      report.set_handled_state({
+        :type => "unhandledExceptionMiddleware",
+        :attributes => {
+          :framework => "Rake"
+        }
+      })
     end
     raise
   ensure

lib/bugsnag/integrations/resque.rb

@@ -28,6 +28,12 @@ def self.add_failure_backend
     def save
       Bugsnag.notify(exception, true) do |report|
         report.severity = "error"
+        report.set_handled_state({
+          :type => "unhandledExceptionMiddleware",
+          :attributes => {
+            :framework => "Resque"
+          }
+        })
         report.meta_data.merge!({:context => "#{payload['class']}@#{queue}", :payload => payload, :delivery_method => :synchronous})
       end
     end

lib/bugsnag/integrations/sidekiq.rb

@@ -18,6 +18,12 @@ def call(worker, msg, queue)
         raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
         Bugsnag.notify(ex, true) do |report|
           report.severity = "error"
+          report.set_handled_states({
+            :type => 'unhandledExceptionMiddleware',
+            :attributes => {
+              :framework => "Sidekiq"
+            }
+          })
         end
         raise
       ensure

lib/bugsnag/middleware/classify_error.rb

@@ -0,0 +1,45 @@
+module Bugsnag::Middleware
+  class ClassifyError
+    INFO_CLASSES = [
+        "AbstractController::ActionNotFound",
+        "ActionController::InvalidAuthenticityToken",
+        "ActionController::ParameterMissing",
+        "ActionController::UnknownAction",
+        "ActionController::UnknownFormat",
+        "ActionController::UnknownHttpMethod",
+        "ActiveRecord::RecordNotFound",
+        "CGI::Session::CookieStore::TamperedWithCookie",
+        "Mongoid::Errors::DocumentNotFound",
+        "SignalException",
+        "SystemExit"
+    ]
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      report.raw_exceptions.each do |ex|
+        ancestor_chain = ex.class.ancestors.select { |ancestor| ancestor.is_a?(Class) }.map { |ancestor| ancestor.to_s }
+
+        INFO_CLASSES.each do |info_class|
+          if ancestor_chain.include?(info_class) 
+            report.set_handled_state(
+              {
+                :type => "error_class",
+                :attributes => {
+                  :errorClass => info_class
+                }
+              }
+            )
+            report.severity = 'info'
+            break;
+          end
+        end
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end
+

lib/bugsnag/report.rb

@@ -25,10 +25,12 @@ class Report
     attr_accessor :raw_exceptions
     attr_accessor :release_stage
     attr_accessor :severity
+    attr_accessor :severity_reason
     attr_accessor :user
 
-    def initialize(exception, passed_configuration)
+    def initialize(exception, passed_configuration, auto_notify=false)
       @should_ignore = false
+      @unhandled = auto_notify
 
       self.configuration = passed_configuration
 
@@ -43,6 +45,9 @@ def initialize(exception, passed_configuration)
       self.meta_data = {}
       self.release_stage = configuration.release_stage
       self.severity = "warning"
+      self.severity_reason = {
+        :type => "handledException"
+      }
       self.user = {}
     end
 
@@ -84,6 +89,8 @@ def as_json
         groupingHash: grouping_hash,
         payloadVersion: CURRENT_PAYLOAD_VERSION,
         severity: severity,
+        severityReason: severity_reason,
+        unhandled: @unhandled,
         user: user
       }
 

lib/bugsnag/tasks/bugsnag.rake

@@ -6,7 +6,9 @@ namespace :bugsnag do
     begin
       raise RuntimeError.new("Bugsnag test exception")
     rescue => e
-      Bugsnag.notify(e, {:context => "rake#test_exception"})
+      Bugsnag.notify(e) do |report|
+        report.context = "rake#test_exception"
+      end
     end
   end
 end

spec/middleware_spec.rb

@@ -178,4 +178,68 @@ def call(report)
     }
   end
 
+  it "doesn't allow handledState properties to be changed in middleware" do
+    HandledStateChanger = Class.new do
+      def initialize(bugsnag)
+        @bugsnag = bugsnag
+      end
+
+      def call(report)
+        report.set_handled_state({
+          :test => "test"
+        })
+        @bugsnag.call(report)
+      end
+    end
+
+    Bugsnag.configure do |c|
+      c.middleware.use HandledStateChanger
+    end
+
+    Bugsnag.notify(BugsnagTestException.new("It crashed"), true) do |report|
+      report.set_handled_state({
+        :type => "middleware_handler",
+        :attributes => {
+          :name => "middleware_test"
+        }
+      })
+    end
+
+    expect(Bugsnag).to have_sent_notification{ |payload|
+      event = get_event_from_payload(payload)
+      expect(event["unhandled"]).to be true
+      expect(event["severityReason"]).to eq({
+        "type" => "middleware_handler",
+        "attributes" => {
+          "name" => "middleware_test"
+        }
+      })
+    }
+  end
+
+  it "sets defaultSeverity to false if changed in middleware" do
+    SeverityChanger = Class.new do
+      def initialize(bugsnag)
+        @bugsnag = bugsnag
+      end
+
+      def call(report)
+        report.severity = "info"
+        @bugsnag.call(report)
+      end
+    end
+
+    Bugsnag.configure do |c|
+      c.middleware.use SeverityChanger
+    end
+
+    Bugsnag.notify(BugsnagTestException.new("It crashed"))
+
+    expect(Bugsnag).to have_sent_notification{ |payload|
+      event = get_event_from_payload(payload)
+      expect(event["severity"]).to eq("info")
+      expect(event["defaultSeverity"]).to be false
+    }
+  end
+
 end