bugsnag 5.5.0 → 6.0.0

data/lib/bugsnag/{rake.rb → integrations/rake.rb}

@@ -4,25 +4,28 @@ Rake::TaskManager.record_task_metadata = true
 
 class Rake::Task
 
+  FRAMEWORK_ATTRIBUTES = {
+    :framework => "Rake"
+  }
+
   def execute_with_bugsnag(args=nil)
     Bugsnag.configuration.app_type ||= "rake"
     old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
-    Bugsnag.set_request_data :bugsnag_running_task, self
+    Bugsnag.configuration.set_request_data :bugsnag_running_task, self
 
     execute_without_bugsnag(args)
 
   rescue Exception => ex
-    Bugsnag.auto_notify(ex, {
-      :severity_reason => {
-        :type => Bugsnag::Notification::UNHANDLED_EXCEPTION_MIDDLEWARE,
-        :attributes => {
-          :framework => "Rake"
-        }
+    Bugsnag.notify(ex, true) do |report|
+      report.severity = "error"
+      report.severity_reason = {
+        :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+        :attributes => FRAMEWORK_ATTRIBUTES
       }
-    })
+    end
     raise
   ensure
-    Bugsnag.set_request_data :bugsnag_running_task, old_task
+    Bugsnag.configuration.set_request_data :bugsnag_running_task, old_task
   end
 
   alias_method :execute_without_bugsnag, :execute

data/lib/bugsnag/{resque.rb → integrations/resque.rb}

@@ -3,6 +3,11 @@ require "resque/failure/multiple"
 
 module Bugsnag
   class Resque < ::Resque::Failure::Base
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Resque"
+    }
+
     def self.configure(&block)
       add_failure_backend
       Bugsnag.configure(&block)
@@ -26,16 +31,14 @@ module Bugsnag
     end
 
     def save
-      Bugsnag.auto_notify(exception, {
-        :context => "#{payload['class']}@#{queue}",
-        :payload => payload,
-        :severity_reason => {
-          :type => Bugsnag::Notification::UNHANDLED_EXCEPTION_MIDDLEWARE,
-          :attributes => {
-            :framework => "Resque"
-          }
+      Bugsnag.notify(exception, true) do |report|
+        report.severity = "error"
+        report.severity_reason = {
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+          :attributes => FRAMEWORK_ATTRIBUTES
         }
-      })
+        report.meta_data.merge!({:context => "#{payload['class']}@#{queue}", :payload => payload})
+      end
     end
   end
 end

data/lib/bugsnag/integrations/shoryuken.rb

@@ -0,0 +1,49 @@
+require 'shoryuken'
+
+module Bugsnag
+  class Shoryuken
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Shoryuken"
+    }
+
+    def initialize
+      Bugsnag.configure do |config|
+        config.app_type ||= "shoryuken"
+        config.default_delivery_method = :synchronous
+      end
+    end
+
+    def call(_, queue, _, body)
+      begin
+        Bugsnag.before_notify_callbacks << lambda {|report|
+          report.add_tab(:shoryuken, {
+            queue: queue,
+            body: body
+          })
+        }
+
+        yield
+      rescue Exception => ex
+        unless [Interrupt, SystemExit, SignalException].include?(ex.class)
+          Bugsnag.auto_notify(ex, true) do |report|
+            report.severity = "error"
+            report.severity_reason = {
+              :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+              :attributes => Bugsnag::Shoryuken::FRAMEWORK_ATTRIBUTES
+            }
+          end
+        end
+        raise
+      ensure
+        Bugsnag.configuration.clear_request_data
+      end
+    end
+  end
+end
+
+::Shoryuken.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add ::Bugsnag::Shoryuken
+  end
+end

data/lib/bugsnag/{sidekiq.rb → integrations/sidekiq.rb}

@@ -2,6 +2,11 @@ require 'sidekiq'
 
 module Bugsnag
   class Sidekiq
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Sidekiq"
+    }
+
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
       Bugsnag.configuration.app_type = "sidekiq"
@@ -11,22 +16,21 @@ module Bugsnag
     def call(worker, msg, queue)
       begin
         # store msg/queue in thread local state to be read by Bugsnag::Middleware::Sidekiq
-        Bugsnag.set_request_data :sidekiq, { :msg => msg, :queue => queue }
+        Bugsnag.configuration.set_request_data :sidekiq, { :msg => msg, :queue => queue }
 
         yield
       rescue Exception => ex
         raise ex if [Interrupt, SystemExit, SignalException].include? ex.class
-        Bugsnag.auto_notify(ex, {
-          :severity_reason => {
-            :type => Bugsnag::Notification::UNHANDLED_EXCEPTION_MIDDLEWARE,
-            :attributes => {
-              :framework => "Sidekiq"
-            }
+        Bugsnag.notify(ex, true) do |report|
+          report.severity = "error"
+          report.severity_reason = {
+            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+            :attributes => FRAMEWORK_ATTRIBUTES
           }
-        })
+        end
         raise
       ensure
-        Bugsnag.clear_request_data
+        Bugsnag.configuration.clear_request_data
       end
     end
   end

data/lib/bugsnag/middleware/callbacks.rb

@@ -4,16 +4,12 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:before_callbacks]
-        notification.request_data[:before_callbacks].each {|c| c.call(*[notification][0...c.arity]) }
+    def call(report)
+      if report.request_data[:before_callbacks]
+        report.request_data[:before_callbacks].each {|c| c.call(*[report][0...c.arity]) }
       end
 
-      @bugsnag.call(notification)
-
-      if notification.request_data[:after_callbacks]
-        notification.request_data[:after_callbacks].each {|c| c.call(*[notification][0...c.arity]) }
-      end
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/classify_error.rb

@@ -18,36 +18,30 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      notification.exceptions.each do |ex|
-
-        outer_break = false
+    def call(report)
+      report.raw_exceptions.each do |ex|
 
         ancestor_chain = ex.class.ancestors.select {
-          |ancestor| ancestor.is_a?(Class) 
+          |ancestor| ancestor.is_a?(Class)
         }.map {
           |ancestor| ancestor.to_s
         }
 
         INFO_CLASSES.each do |info_class|
           if ancestor_chain.include?(info_class)
-            notification.severity_reason = {
-              :type => Bugsnag::Notification::ERROR_CLASS,
+            report.severity_reason = {
+              :type => Bugsnag::Report::ERROR_CLASS,
               :attributes => {
                 :errorClass => info_class
               }
             }
-            notification.severity = 'info'
-            outer_break = true
+            report.severity = 'info'
             break
           end
         end
-
-        break if outer_break
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end
-    

data/lib/bugsnag/middleware/clearance_user.rb

@@ -6,15 +6,15 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env] &&
-            notification.request_data[:rack_env][:clearance] &&
-            notification.request_data[:rack_env][:clearance].signed_in? &&
-            notification.request_data[:rack_env][:clearance].current_user
+    def call(report)
+      if report.request_data[:rack_env] &&
+        report.request_data[:rack_env]["clearance"] &&
+        report.request_data[:rack_env]["clearance"].signed_in? &&
+        report.request_data[:rack_env]["clearance"].current_user
 
         # Extract useful user information
         user = {}
-        user_object = notification.request_data[:rack_env][:clearance].current_user
+        user_object = report.request_data[:rack_env]["clearance"].current_user
         if user_object
           # Build the bugsnag user info from the current user record
           COMMON_USER_FIELDS.each do |field|
@@ -22,10 +22,10 @@ module Bugsnag::Middleware
           end
         end
 
-        notification.user = user unless user.empty?
+        report.user = user unless user.empty?
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/exception_meta_data.rb

@@ -0,0 +1,34 @@
+module Bugsnag::Middleware
+  class ExceptionMetaData
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      # Apply the user's information attached to the exceptions
+      report.raw_exceptions.each do |exception|
+        if exception.class.include?(Bugsnag::MetaData)
+          if exception.bugsnag_user_id.is_a?(String)
+            report.user = {id: exception.bugsnag_user_id}
+          end
+
+          if exception.bugsnag_context.is_a?(String)
+            report.context = exception.bugsnag_context
+          end
+
+          if exception.bugsnag_grouping_hash.is_a?(String)
+            report.grouping_hash = exception.bugsnag_grouping_hash
+          end
+
+          if exception.respond_to?(:bugsnag_meta_data) && exception.bugsnag_meta_data
+            exception.bugsnag_meta_data.each do |key, value|
+              report.add_tab key, value
+            end
+          end
+        end
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/ignore_error_class.rb

@@ -0,0 +1,21 @@
+module Bugsnag::Middleware
+  class IgnoreErrorClass
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      ignore_error_class = report.raw_exceptions.any? do |ex|
+        ancestor_chain = ex.class.ancestors.select { |ancestor| ancestor.is_a?(Class) }.to_set
+
+        report.configuration.ignore_classes.any? do |to_ignore|
+          to_ignore.is_a?(Proc) ? to_ignore.call(ex) : ancestor_chain.include?(to_ignore)
+        end
+      end
+
+      report.ignore! if ignore_error_class
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/mailman.rb

@@ -4,10 +4,10 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      mailman_msg = notification.request_data[:mailman_msg]
-      notification.add_tab(:mailman, {"message" => mailman_msg}) if mailman_msg
-      @bugsnag.call(notification)
+    def call(report)
+      mailman_msg = report.request_data[:mailman_msg]
+      report.add_tab(:mailman, {"message" => mailman_msg}) if mailman_msg
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/rack_request.rb

@@ -6,9 +6,9 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env]
+        env = report.request_data[:rack_env]
 
         request = ::Rack::Request.new(env)
 
@@ -17,10 +17,10 @@ module Bugsnag::Middleware
         session = env["rack.session"]
 
         # Set the context
-        notification.context = "#{request.request_method} #{request.path}"
+        report.context = "#{request.request_method} #{request.path}"
 
         # Set a sensible default for user_id
-        notification.user_id = request.ip
+        report.user["id"] = request.ip
 
         # Build the clean url (hide the port if it is obvious)
         url = "#{request.scheme}://#{request.host}"
@@ -28,9 +28,9 @@ module Bugsnag::Middleware
 
         # If app is passed a bad URL, this code will crash attempting to clean it
         begin
-          url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
+          url << Bugsnag::Cleaner.new(report.configuration.meta_data_filters).clean_url(request.fullpath)
         rescue StandardError => stde
-          Bugsnag.log "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
+          Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
         end
 
         headers = {}
@@ -48,7 +48,7 @@ module Bugsnag::Middleware
         end
 
         # Add a request tab
-        notification.add_tab(:request, {
+        report.add_tab(:request, {
           :url => url,
           :httpMethod => request.request_method,
           :params => params.to_hash,
@@ -58,23 +58,23 @@ module Bugsnag::Middleware
         })
 
         # Add an environment tab
-        if notification.configuration.send_environment
-          notification.add_tab(:environment, env)
+        if report.configuration.send_environment
+          report.add_tab(:environment, env)
         end
 
         # Add a session tab
         if session
           if session.is_a?(Hash)
             # Rails 3
-            notification.add_tab(:session, session)
+            report.add_tab(:session, session)
           elsif session.respond_to?(:to_hash)
             # Rails 4
-            notification.add_tab(:session, session.to_hash)
+            report.add_tab(:session, session.to_hash)
           end
         end
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end

data/lib/bugsnag/middleware/rails3_request.rb

@@ -6,40 +6,40 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(notification)
-      if notification.request_data[:rack_env]
-        env = notification.request_data[:rack_env]
+    def call(report)
+      if report.request_data[:rack_env]
+        env = report.request_data[:rack_env]
         params = env["action_dispatch.request.parameters"]
         client_ip = env["action_dispatch.remote_ip"].to_s rescue SPOOF
 
         if params
           # Set the context
-          notification.context = "#{params[:controller]}##{params[:action]}"
+          report.context = "#{params[:controller]}##{params[:action]}"
 
           # Augment the request tab
-          notification.add_tab(:request, {
+          report.add_tab(:request, {
             :railsAction => "#{params[:controller]}##{params[:action]}",
             :params => params
           })
         end
 
         # Use action_dispatch.remote_ip for IP address fields and send request id
-        notification.add_tab(:request, {
+        report.add_tab(:request, {
           :clientIp => client_ip,
           :requestId => env["action_dispatch.request_id"]
         })
 
-        notification.user_id = client_ip
+        report.user["id"] = client_ip
 
         # Add the rails version
-        if notification.configuration.send_environment
-          notification.add_tab(:environment, {
+        if report.configuration.send_environment
+          report.add_tab(:environment, {
             :railsVersion => Rails::VERSION::STRING
           })
         end
       end
 
-      @bugsnag.call(notification)
+      @bugsnag.call(report)
     end
   end
 end