bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/integrations/rake.rb

@@ -0,0 +1,74 @@
+# this file can either be required manually by a user, in which case 'bugsnag'
+# needs to be required, or it can be required automatically in the railtie,
+# in which case 'bugsnag' has already been required
+require 'bugsnag' unless defined?(Bugsnag)
+
+Rake::TaskManager.record_task_metadata = true
+
+if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0')
+  module Bugsnag
+    module RakeTask
+      FRAMEWORK_ATTRIBUTES = {
+        framework: 'Rake'
+      }
+
+      # Executes the rake task with Bugsnag setup with contextual data.
+      def execute(args = nil)
+        Bugsnag.configuration.detected_app_type = "rake"
+
+        old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
+        Bugsnag.configuration.set_request_data :bugsnag_running_task, self
+        Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION
+
+        super
+      rescue Exception => ex
+        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.configuration.set_request_data :bugsnag_running_task, old_task
+      end
+    end
+  end
+
+  Rake::Task.send(:prepend, Bugsnag::RakeTask)
+else
+  class Rake::Task
+    FRAMEWORK_ATTRIBUTES = {
+      framework: 'Rake'
+    }
+
+    ##
+    # Executes the rake task with Bugsnag setup with contextual data.
+    def execute_with_bugsnag(args=nil)
+      Bugsnag.configuration.detected_app_type = "rake"
+
+      old_task = Bugsnag.configuration.request_data[:bugsnag_running_task]
+      Bugsnag.configuration.set_request_data :bugsnag_running_task, self
+      Bugsnag.configuration.runtime_versions["rake"] = ::Rake::VERSION
+
+      execute_without_bugsnag(args)
+    rescue Exception => ex
+      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.configuration.set_request_data :bugsnag_running_task, old_task
+    end
+
+    alias_method :execute_without_bugsnag, :execute
+    alias_method :execute, :execute_with_bugsnag
+  end
+end
+
+Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Rake)

data/lib/bugsnag/integrations/resque.rb

@@ -0,0 +1,94 @@
+require "resque"
+require "resque/failure/multiple"
+
+module Bugsnag
+  class Resque < ::Resque::Failure::Base
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Resque"
+    }
+
+    ##
+    # Callthrough to Bugsnag configuration.
+    def self.configure(&block)
+      add_failure_backend
+      Bugsnag.configure(&block)
+    end
+
+    ##
+    # Sets up the Resque failure backend.
+    def self.add_failure_backend
+      return if ::Resque::Failure.backend == self
+
+      # Ensure resque is using a "Multiple" failure backend
+      unless ::Resque::Failure.backend <= ::Resque::Failure::Multiple
+        original_backend = ::Resque::Failure.backend
+        ::Resque::Failure.backend = ::Resque::Failure::Multiple
+        ::Resque::Failure.backend.classes ||= []
+        ::Resque::Failure.backend.classes << original_backend
+      end
+
+      # Add Bugsnag failure backend
+      unless ::Resque::Failure.backend.classes.include?(self)
+        ::Resque::Failure.backend.classes << self
+      end
+    end
+
+    ##
+    # Notifies Bugsnag of a raised exception.
+    def save
+      Bugsnag.notify(exception, true) do |report|
+        report.severity = "error"
+        report.severity_reason = {
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+          :attributes => FRAMEWORK_ATTRIBUTES
+        }
+
+        metadata = payload
+        class_name = metadata['class']
+
+        # when using Active Job the payload "class" will always be the Resque
+        # "JobWrapper", so we need to unwrap the actual class name
+        if class_name == "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
+          unwrapped_class_name = metadata['args'][0]['job_class'] rescue nil
+
+          if unwrapped_class_name
+            class_name = unwrapped_class_name
+            metadata['wrapped'] ||= unwrapped_class_name
+          end
+        end
+
+        context = "#{class_name}@#{queue}"
+        report.meta_data.merge!({ context: context, payload: metadata })
+        report.automatic_context = context
+      end
+    end
+  end
+end
+
+# For backwards compatibility
+Resque::Failure::Bugsnag = Bugsnag::Resque
+
+# Auto-load the failure backend
+Bugsnag::Resque.add_failure_backend
+
+worker = Resque::Worker.new(:bugsnag_fork_check)
+
+# If at_exit hooks are not enabled then we can't use the thread queue delivery
+# method because it relies on an at_exit hook to ensure the queue is flushed
+can_use_thread_queue = worker.respond_to?(:run_at_exit_hooks) && worker.run_at_exit_hooks
+default_delivery_method = can_use_thread_queue ? :thread_queue : :synchronous
+
+if worker.fork_per_job?
+  Resque.after_fork do
+    Bugsnag.configuration.detected_app_type = "resque"
+    Bugsnag.configuration.default_delivery_method = default_delivery_method
+    Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
+  end
+else
+  Resque.before_first_fork do
+    Bugsnag.configuration.detected_app_type = "resque"
+    Bugsnag.configuration.default_delivery_method = default_delivery_method
+    Bugsnag.configuration.runtime_versions["resque"] = ::Resque::VERSION
+  end
+end

data/lib/bugsnag/integrations/shoryuken.rb

@@ -0,0 +1,50 @@
+require 'shoryuken'
+
+module Bugsnag
+  ##
+  # Extracts and attaches Shoryuken queue information to an error report
+  class Shoryuken
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Shoryuken"
+    }
+
+    def initialize
+      Bugsnag.configure do |config|
+        config.detected_app_type = "shoryuken"
+        config.default_delivery_method = :synchronous
+        config.runtime_versions["shoryuken"] = ::Shoryuken::VERSION
+      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
+        Bugsnag.notify(ex, true) do |report|
+          report.severity = "error"
+          report.severity_reason = {
+            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+            :attributes => Bugsnag::Shoryuken::FRAMEWORK_ATTRIBUTES
+          }
+        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/integrations/sidekiq.rb

@@ -0,0 +1,68 @@
+require 'sidekiq'
+
+module Bugsnag
+  ##
+  # Extracts and attaches Sidekiq job and queue information to an error report
+  class Sidekiq
+    include ::Sidekiq::ServerMiddleware if defined?(::Sidekiq::ServerMiddleware)
+
+    unless const_defined?(:FRAMEWORK_ATTRIBUTES)
+      FRAMEWORK_ATTRIBUTES = {
+        :framework => "Sidekiq"
+      }
+    end
+
+    def initialize
+      Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
+      Bugsnag.configuration.detected_app_type = "sidekiq"
+      Bugsnag.configuration.runtime_versions["sidekiq"] = ::Sidekiq::VERSION
+    end
+
+    def call(worker, msg, queue)
+      # store msg/queue in thread local state to be read by Bugsnag::Middleware::Sidekiq
+      Bugsnag.configuration.set_request_data(:sidekiq, { :msg => msg, :queue => queue })
+      error_raised = false
+      yield
+    rescue Exception => ex
+      error_raised = true
+      self.class.notify(ex) unless self.class.sidekiq_supports_error_handlers
+      raise
+    ensure
+      # if an error was raised and error handlers are installed, the data will be cleared after
+      # the notification is sent. Otherwise, the data must be cleared.
+      keep_data = error_raised && self.class.sidekiq_supports_error_handlers
+      Bugsnag.configuration.clear_request_data unless keep_data
+    end
+
+    def self.notify(exception)
+      Bugsnag.notify(exception, true) do |report|
+        report.severity = "error"
+        report.severity_reason = {
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+          :attributes => FRAMEWORK_ATTRIBUTES
+        }
+      end
+    end
+
+    def self.sidekiq_supports_error_handlers
+      Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new('3.0.0')
+    end
+
+    def self.configure_server(server)
+      if Bugsnag::Sidekiq.sidekiq_supports_error_handlers
+        server.error_handlers << proc do |ex, _context, _config = nil|
+          Bugsnag::Sidekiq.notify(ex)
+          Bugsnag.configuration.clear_request_data
+        end
+      end
+
+      server.server_middleware do |chain|
+        chain.add ::Bugsnag::Sidekiq
+      end
+    end
+  end
+end
+
+::Sidekiq.configure_server do |config|
+  Bugsnag::Sidekiq.configure_server(config)
+end

data/lib/bugsnag/meta_data.rb

@@ -3,5 +3,6 @@ module Bugsnag
     attr_accessor :bugsnag_meta_data
     attr_accessor :bugsnag_user_id
     attr_accessor :bugsnag_context
+    attr_accessor :bugsnag_grouping_hash
   end
 end

data/lib/bugsnag/middleware/active_job.rb

@@ -0,0 +1,18 @@
+module Bugsnag::Middleware
+  class ActiveJob
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      data = report.request_data[:active_job]
+
+      if data
+        report.add_tab(:active_job, data)
+        report.automatic_context = "#{data[:job_name]}@#{data[:queue]}"
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/breadcrumbs.rb

@@ -0,0 +1,21 @@
+module Bugsnag::Middleware
+  ##
+  # Adds breadcrumbs to the report
+  class Breadcrumbs
+    ##
+    # @param next_callable [#call] the next callable middleware
+    def initialize(next_callable)
+      @next = next_callable
+    end
+
+    ##
+    # Execute this middleware
+    #
+    # @param report [Bugsnag::Report] the report being iterated over
+    def call(report)
+      breadcrumbs = report.configuration.breadcrumbs.to_a
+      report.breadcrumbs = breadcrumbs unless breadcrumbs.empty?
+      @next.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/callbacks.rb

@@ -1,19 +1,17 @@
 module Bugsnag::Middleware
+  ##
+  # Calls all configured callbacks passing an error report
   class Callbacks
     def initialize(bugsnag)
       @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

@@ -0,0 +1,50 @@
+module Bugsnag::Middleware
+  ##
+  # Sets the severity to info for low-importance errors
+  class ClassifyError
+    INFO_CLASSES = [
+        "AbstractController::ActionNotFound",
+        "ActionController::InvalidAuthenticityToken",
+        "ActionController::ParameterMissing",
+        "ActionController::UnknownAction",
+        "ActionController::UnknownFormat",
+        "ActionController::UnknownHttpMethod",
+        "ActionDispatch::Http::MimeNegotiation::InvalidType",
+        "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.severity_reason = {
+              :type => Bugsnag::Report::ERROR_CLASS,
+              :attributes => {
+                :errorClass => info_class
+              }
+            }
+            report.severity = 'info'
+            break
+          end
+        end
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/clearance_user.rb

@@ -0,0 +1,33 @@
+module Bugsnag::Middleware
+  ##
+  # Extracts and appends clearance user information
+  class ClearanceUser
+    COMMON_USER_FIELDS = [:email, :name, :first_name, :last_name, :created_at, :id]
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    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 = 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|
+            user[field] = user_object.send(field) if user_object.respond_to?(field)
+          end
+        end
+
+        report.user = user unless user.empty?
+      end
+
+      @bugsnag.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/delayed_job.rb

@@ -0,0 +1,93 @@
+module Bugsnag::Middleware
+  ##
+  # Attaches delayed_job information to an error report
+  class DelayedJob
+    # Active Job's queue adapter sets the "display_name" to this format. This
+    # breaks the event context as the ID and arguments are included, which will
+    # differ between executions of the same job
+    ACTIVE_JOB_DISPLAY_NAME = /^.* \[[0-9a-f-]+\] from DelayedJob\(.*\) with arguments: \[.*\]$/
+
+    def initialize(bugsnag)
+      @bugsnag = bugsnag
+    end
+
+    def call(report)
+      job = report.request_data[:delayed_job]
+      if job
+        job_data = {
+          :class => job.class.name,
+          :id => job.id
+        }
+        job_data[:priority] = job.priority if job.respond_to?(:priority)
+        job_data[:run_at] = job.run_at if job.respond_to?(:run_at)
+        job_data[:locked_at] = job.locked_at if job.respond_to?(:locked_at)
+        job_data[:locked_by] = job.locked_by if job.respond_to?(:locked_by)
+        job_data[:created_at] = job.created_at if job.respond_to?(:created_at)
+        job_data[:queue] = job.queue if job.respond_to?(:queue)
+
+        if job.respond_to?(:payload_object)
+          job_data[:active_job] = job.payload_object.job_data if job.payload_object.respond_to?(:job_data)
+          payload_data = construct_job_payload(job.payload_object)
+
+          context = get_context(payload_data, job_data[:active_job])
+          report.automatic_context = context unless context.nil?
+
+          job_data[:payload] = payload_data
+        end
+
+        if job.respond_to?(:attempts)
+          # +1 as "attempts" is zero-based and does not include the current failed attempt
+          job_data[:attempt] = job.attempts + 1
+          job_data[:max_attempts] = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
+        end
+
+        report.add_tab(:job, job_data)
+      end
+      @bugsnag.call(report)
+    end
+
+    def construct_job_payload(payload)
+      data = {
+        :class => payload.class.name
+      }
+      data[:id]           = payload.id           if payload.respond_to?(:id)
+      data[:display_name] = payload.display_name if payload.respond_to?(:display_name)
+      data[:method_name]  = payload.method_name  if payload.respond_to?(:method_name)
+
+      if payload.respond_to?(:args)
+        data[:args] = payload.args
+      elsif payload.respond_to?(:to_h)
+        data[:args] = payload.to_h
+      elsif payload.respond_to?(:instance_values)
+        data[:args] = payload.instance_values
+      end
+
+      if payload.is_a?(::Delayed::PerformableMethod) && (object = payload.object)
+        data[:object] = {
+          :class => object.class.name
+        }
+        data[:object][:id] = object.id if object.respond_to?(:id)
+      end
+      if payload.respond_to?(:job_data) && payload.job_data.respond_to?(:[])
+        [:job_class, :arguments, :queue_name, :job_id].each do |key|
+          if (value = payload.job_data[key.to_s])
+            data[key] = value
+          end
+        end
+      end
+      data
+    end
+
+    private
+
+    def get_context(payload_data, active_job_data)
+      if payload_data.include?(:display_name) && !ACTIVE_JOB_DISPLAY_NAME.match?(payload_data[:display_name])
+        payload_data[:display_name]
+      elsif active_job_data && active_job_data['job_class'] && active_job_data['queue_name']
+        "#{active_job_data['job_class']}@#{active_job_data['queue_name']}"
+      elsif payload_data.include?(:class)
+        payload_data[:class]
+      end
+    end
+  end
+end

data/lib/bugsnag/middleware/discard_error_class.rb

@@ -0,0 +1,30 @@
+module Bugsnag::Middleware
+  ##
+  # Determines if the exception should be ignored based on the configured
+  # `discard_classes`
+  class DiscardErrorClass
+    ##
+    # @param middleware [#call] The next middleware to call
+    def initialize(middleware)
+      @middleware = middleware
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      should_discard = report.raw_exceptions.any? do |ex|
+        report.configuration.discard_classes.any? do |to_ignore|
+          case to_ignore
+          when String then to_ignore == ex.class.name
+          when Regexp then to_ignore =~ ex.class.name
+          else false
+          end
+        end
+      end
+
+      report.ignore! if should_discard
+
+      @middleware.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/exception_meta_data.rb

@@ -0,0 +1,42 @@
+module Bugsnag::Middleware
+  ##
+  # Extracts data from the exception.
+  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.respond_to?(:bugsnag_user_id)
+          user_id = exception.bugsnag_user_id
+          report.user = {id: user_id} if user_id.is_a?(String)
+        end
+
+        if exception.respond_to?(:bugsnag_context)
+          context = exception.bugsnag_context
+          # note: this should set 'context' not 'automatic_context' as it's a
+          #       user-supplied value
+          report.context = context if context.is_a?(String)
+        end
+
+        if exception.respond_to?(:bugsnag_grouping_hash)
+          group_hash = exception.bugsnag_grouping_hash
+          report.grouping_hash = group_hash if group_hash.is_a?(String)
+        end
+
+        if exception.respond_to?(:bugsnag_meta_data)
+          meta_data = exception.bugsnag_meta_data
+          if meta_data.is_a?(Hash)
+            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,26 @@
+module Bugsnag::Middleware
+  ##
+  # Determines if the exception should be ignored based on the configured
+  # `ignore_classes`
+  #
+  # @deprecated Use {DiscardErrorClass} instead
+  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

@@ -1,13 +1,15 @@
 module Bugsnag::Middleware
+  ##
+  # Extracts and attaches mailman data to an error report
   class Mailman
     def initialize(bugsnag)
       @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