bugsnag 6.19.0 → 6.26.0

data/lib/bugsnag/integrations/rails/active_job.rb

@@ -0,0 +1,102 @@
+require 'set'
+
+module Bugsnag::Rails
+  module ActiveJob
+    SEVERITY = 'error'
+    SEVERITY_REASON = {
+      type: Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      attributes: { framework: 'Active Job' }
+    }
+
+    EXISTING_INTEGRATIONS = Set[
+      'ActiveJob::QueueAdapters::DelayedJobAdapter',
+      'ActiveJob::QueueAdapters::QueAdapter',
+      'ActiveJob::QueueAdapters::ResqueAdapter',
+      'ActiveJob::QueueAdapters::ShoryukenAdapter',
+      'ActiveJob::QueueAdapters::SidekiqAdapter'
+    ]
+
+    INLINE_ADAPTER = 'ActiveJob::QueueAdapters::InlineAdapter'
+
+    # these methods were added after the first Active Job release so
+    # may not be present, depending on the Rails version
+    MAYBE_MISSING_METHODS = [
+      :provider_job_id,
+      :priority,
+      :executions,
+      :enqueued_at,
+      :timezone
+    ]
+
+    def self.included(base)
+      base.class_eval do
+        around_perform do |job, block|
+          adapter = _bugsnag_get_adapter_name(job)
+
+          # if we have an integration for this queue adapter already then we should
+          # leave this job alone or we'll end up with duplicate metadata
+          next block.call if EXISTING_INTEGRATIONS.include?(adapter)
+
+          Bugsnag.configuration.detected_app_type = 'active job'
+
+          begin
+            Bugsnag.configuration.set_request_data(:active_job, _bugsnag_extract_metadata(job))
+
+            block.call
+          rescue Exception => e
+            Bugsnag.notify(e, true) do |report|
+              report.severity = SEVERITY
+              report.severity_reason = SEVERITY_REASON
+            end
+
+            # when using the "inline" adapter the job is run immediately, which
+            # will result in our Rack integration catching the re-raised error
+            # and reporting it a second time if it's run in a web request
+            if adapter == INLINE_ADAPTER
+              e.instance_eval do
+                def skip_bugsnag
+                  true
+                end
+              end
+            end
+
+            raise
+          ensure
+            Bugsnag.configuration.clear_request_data
+          end
+        end
+      end
+    end
+
+    private
+
+    def _bugsnag_get_adapter_name(job)
+      adapter = job.class.queue_adapter
+
+      # in Rails 4 queue adapters were references to a class. In Rails 5+
+      # they are an instance of that class instead
+      return adapter.name if adapter.is_a?(Class)
+
+      adapter.class.name
+    end
+
+    def _bugsnag_extract_metadata(job)
+      metadata = {
+        job_id: job.job_id,
+        job_name: job.class.name,
+        queue: job.queue_name,
+        arguments: job.arguments,
+        locale: job.locale
+      }
+
+      MAYBE_MISSING_METHODS.each do |method_name|
+        next unless job.respond_to?(method_name)
+
+        metadata[method_name] = job.send(method_name)
+      end
+
+      metadata.compact!
+      metadata
+    end
+  end
+end

data/lib/bugsnag/integrations/rails/rails_breadcrumbs.rb

@@ -38,6 +38,8 @@ module Bugsnag::Rails
       :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
       :allowed_data => [
         :name,
+        # :connection_id is no longer provided in Rails 6.1+ but we can get it
+        # from the :connection key of the event instead
         :connection_id,
         :cached
       ]

data/lib/bugsnag/integrations/railtie.rb

@@ -9,11 +9,67 @@ require "bugsnag/integrations/rails/rails_breadcrumbs"
 
 module Bugsnag
   class Railtie < ::Rails::Railtie
-
     FRAMEWORK_ATTRIBUTES = {
       :framework => "Rails"
     }
 
+    ##
+    # Subscribes to an ActiveSupport event, leaving a breadcrumb when it triggers
+    #
+    # @api private
+    # @param event [Hash] details of the event to subscribe to
+    def event_subscription(event)
+      ActiveSupport::Notifications.subscribe(event[:id]) do |*, event_id, data|
+        filtered_data = data.slice(*event[:allowed_data])
+        filtered_data[:event_name] = event[:id]
+        filtered_data[:event_id] = event_id
+
+        if event[:id] == "sql.active_record"
+          if data.key?(:binds)
+            binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
+            filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
+          end
+
+          # Rails < 6.1 included connection_id in the event data, but now
+          # includes the connection object instead
+          if data.key?(:connection) && !data.key?(:connection_id)
+            # the connection ID is the object_id of the connection object
+            filtered_data[:connection_id] = data[:connection].object_id
+          end
+        end
+
+        Bugsnag.leave_breadcrumb(
+          event[:message],
+          filtered_data,
+          event[:type],
+          :auto
+        )
+      end
+    end
+
+    ##
+    # Do we need to rescue (& notify) in Active Record callbacks?
+    #
+    # On Rails versions < 4.2, Rails did not raise errors in AR callbacks
+    # On Rails version 4.2, a config option was added to control this
+    # On Rails version 5.0, the config option was removed and errors in callbacks
+    # always bubble up
+    #
+    # @api private
+    def self.rescue_in_active_record_callbacks?
+      # Rails 5+ will re-raise errors in callbacks, so we don't need to rescue them
+      return false if ::Rails::VERSION::MAJOR > 4
+
+      # before 4.2, errors were always swallowed, so we need to rescue them
+      return true if ::Rails::VERSION::MAJOR < 4
+
+      # a config option was added in 4.2 to control this, but won't exist in 4.0 & 4.1
+      return true unless ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks)
+
+      # if the config option is false, we need to rescue and notify
+      ActiveRecord::Base.raise_in_transactional_callbacks == false
+    end
+
     rake_tasks do
       require "bugsnag/integrations/rake"
       load "bugsnag/tasks/bugsnag.rake"
@@ -27,7 +83,7 @@ module Bugsnag
         config.logger = ::Rails.logger
         config.release_stage ||= ::Rails.env.to_s
         config.project_root = ::Rails.root.to_s
-        config.middleware.insert_before Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::Rails3Request
+        config.internal_middleware.use(Bugsnag::Middleware::Rails3Request)
         config.runtime_versions["rails"] = ::Rails::VERSION::STRING
       end
 
@@ -37,8 +93,18 @@ module Bugsnag
       end
 
       ActiveSupport.on_load(:active_record) do
-        require "bugsnag/integrations/rails/active_record_rescue"
-        include Bugsnag::Rails::ActiveRecordRescue
+        if Bugsnag::Railtie.rescue_in_active_record_callbacks?
+          require "bugsnag/integrations/rails/active_record_rescue"
+          include Bugsnag::Rails::ActiveRecordRescue
+        end
+      end
+
+      ActiveSupport.on_load(:active_job) do
+        require "bugsnag/middleware/active_job"
+        Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::ActiveJob)
+
+        require "bugsnag/integrations/rails/active_job"
+        include Bugsnag::Rails::ActiveJob
       end
 
       Bugsnag::Rails::DEFAULT_RAILS_BREADCRUMBS.each { |event| event_subscription(event) }
@@ -80,28 +146,5 @@ module Bugsnag
         Bugsnag.configuration.warn("Unable to add Bugsnag::Rack middleware as the middleware stack is frozen")
       end
     end
-
-    ##
-    # Subscribes to an ActiveSupport event, leaving a breadcrumb when it triggers
-    #
-    # @api private
-    # @param event [Hash] details of the event to subscribe to
-    def event_subscription(event)
-      ActiveSupport::Notifications.subscribe(event[:id]) do |*, event_id, data|
-        filtered_data = data.slice(*event[:allowed_data])
-        filtered_data[:event_name] = event[:id]
-        filtered_data[:event_id] = event_id
-        if event[:id] == "sql.active_record" && data.key?(:binds)
-          binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
-          filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
-        end
-        Bugsnag.leave_breadcrumb(
-          event[:message],
-          filtered_data,
-          event[:type],
-          :auto
-        )
-      end
-    end
   end
 end

data/lib/bugsnag/integrations/resque.rb

@@ -44,9 +44,23 @@ module Bugsnag
           :attributes => FRAMEWORK_ATTRIBUTES
         }
 
-        context = "#{payload['class']}@#{queue}"
-        report.meta_data.merge!({:context => context, :payload => payload})
-        report.context = context
+        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

data/lib/bugsnag/integrations/sidekiq.rb

@@ -4,6 +4,7 @@ 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 = {

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/classify_error.rb

@@ -9,6 +9,7 @@ module Bugsnag::Middleware
         "ActionController::UnknownAction",
         "ActionController::UnknownFormat",
         "ActionController::UnknownHttpMethod",
+        "ActionDispatch::Http::MimeNegotiation::InvalidType",
         "ActiveRecord::RecordNotFound",
         "CGI::Session::CookieStore::TamperedWithCookie",
         "Mongoid::Errors::DocumentNotFound",

data/lib/bugsnag/middleware/delayed_job.rb

@@ -2,6 +2,11 @@ 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
@@ -23,8 +28,10 @@ module Bugsnag::Middleware
         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)
-          report.context = payload_data[:display_name] if payload_data.include?(:display_name)
-          report.context ||= payload_data[:class] if payload_data.include?(:class)
+
+          context = get_context(payload_data, job_data[:active_job])
+          report.automatic_context = context unless context.nil?
+
           job_data[:payload] = payload_data
         end
 
@@ -70,5 +77,17 @@ module Bugsnag::Middleware
       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/exception_meta_data.rb

@@ -16,6 +16,8 @@ module Bugsnag::Middleware
 
         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
 

data/lib/bugsnag/middleware/rack_request.rb

@@ -1,8 +1,11 @@
+require "json"
+
 module Bugsnag::Middleware
   ##
   # Extracts and attaches rack data to an error report
   class RackRequest
     SPOOF = "[SPOOF]".freeze
+    COOKIE_HEADER = "Cookie".freeze
 
     def initialize(bugsnag)
       @bugsnag = bugsnag
@@ -18,8 +21,8 @@ module Bugsnag::Middleware
         client_ip = request.ip.to_s rescue SPOOF
         session = env["rack.session"]
 
-        # Set the context
-        report.context = "#{request.request_method} #{request.path}"
+        # Set the automatic context
+        report.automatic_context = "#{request.request_method} #{request.path}"
 
         # Set a sensible default for user_id
         report.user["id"] = request.ip
@@ -42,22 +45,6 @@ module Bugsnag::Middleware
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.referer: #{stde}"
         end
 
-        headers = {}
-
-        env.each_pair do |key, value|
-          if key.to_s.start_with?("HTTP_")
-            header_key = key[5..-1]
-          elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
-            header_key = key
-          else
-            next
-          end
-
-          headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
-        end
-
-        headers["Referer"] = referer if headers["Referer"]
-
         # Add a request tab
         report.add_tab(:request, {
           :url => url,
@@ -65,9 +52,17 @@ module Bugsnag::Middleware
           :params => params.to_hash,
           :referer => referer,
           :clientIp => client_ip,
-          :headers => headers
+          :headers => format_headers(env, referer)
         })
 
+        # add the HTTP version if present
+        if env["SERVER_PROTOCOL"]
+          report.add_metadata(:request, :httpVersion, env["SERVER_PROTOCOL"])
+        end
+
+        add_request_body(report, request, env)
+        add_cookies(report, request)
+
         # Add an environment tab
         if report.configuration.send_environment
           report.add_tab(:environment, env)
@@ -87,5 +82,75 @@ module Bugsnag::Middleware
 
       @bugsnag.call(report)
     end
+
+    private
+
+    def format_headers(env, referer)
+      headers = {}
+
+      env.each_pair do |key, value|
+        if key.to_s.start_with?("HTTP_")
+          header_key = key[5..-1]
+        elsif ["CONTENT_TYPE", "CONTENT_LENGTH"].include?(key)
+          header_key = key
+        else
+          next
+        end
+
+        headers[header_key.split("_").map {|s| s.capitalize}.join("-")] = value
+      end
+
+      headers["Referer"] = referer if headers["Referer"]
+
+      headers
+    end
+
+    def add_request_body(report, request, env)
+      body = parsed_request_body(request, env)
+
+      # this request may not have a body
+      return unless body.is_a?(Hash) && !body.empty?
+
+      report.add_metadata(:request, :body, body)
+    end
+
+    def parsed_request_body(request, env)
+      return request.POST rescue nil if request.form_data?
+
+      content_type = env["CONTENT_TYPE"]
+
+      return nil if content_type.nil?
+
+      if content_type.include?('/json') || content_type.include?('+json')
+        begin
+          body = request.body
+
+          return JSON.parse(body.read)
+        rescue StandardError
+          return nil
+        ensure
+          # the body must be rewound so other things can read it after we do
+          body.rewind
+        end
+      end
+
+      nil
+    end
+
+    def add_cookies(report, request)
+      return unless record_cookies?
+
+      cookies = request.cookies rescue nil
+
+      return unless cookies.is_a?(Hash) && !cookies.empty?
+
+      report.add_metadata(:request, :cookies, cookies)
+    end
+
+    def record_cookies?
+      # only record cookies in the request if none of the filters match "Cookie"
+      # the "Cookie" header will be filtered as normal
+      !Bugsnag.cleaner.filters_match?(COOKIE_HEADER)
+    end
   end
 end

data/lib/bugsnag/middleware/rails3_request.rb

@@ -15,8 +15,8 @@ module Bugsnag::Middleware
         client_ip = env["action_dispatch.remote_ip"].to_s rescue SPOOF
 
         if params
-          # Set the context
-          report.context = "#{params[:controller]}##{params[:action]}"
+          # Set the automatic context
+          report.automatic_context = "#{params[:controller]}##{params[:action]}"
 
           # Augment the request tab
           report.add_tab(:request, {

data/lib/bugsnag/middleware/rake.rb

@@ -16,7 +16,7 @@ module Bugsnag::Middleware
           :arguments => task.arg_description
         })
 
-        report.context ||= task.name
+        report.automatic_context ||= task.name
       end
 
       @bugsnag.call(report)

data/lib/bugsnag/middleware/session_data.rb

@@ -8,12 +8,14 @@ module Bugsnag::Middleware
 
     def call(report)
       session = Bugsnag::SessionTracker.get_current_session
-      unless session.nil?
+
+      if session && !session[:paused?]
         if report.unhandled
           session[:events][:unhandled] += 1
         else
           session[:events][:handled] += 1
         end
+
         report.session = session
       end
 

data/lib/bugsnag/middleware/sidekiq.rb

@@ -10,7 +10,7 @@ module Bugsnag::Middleware
       sidekiq = report.request_data[:sidekiq]
       if sidekiq
         report.add_tab(:sidekiq, sidekiq)
-        report.context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
+        report.automatic_context ||= "#{sidekiq[:msg]['wrapped'] || sidekiq[:msg]['class']}@#{sidekiq[:msg]['queue']}"
       end
       @bugsnag.call(report)
     end

data/lib/bugsnag/middleware/suggestion_data.rb

@@ -10,23 +10,25 @@ module Bugsnag::Middleware
       @bugsnag = bugsnag
     end
 
-    def call(report)
+    def call(event)
       matches = []
-      report.raw_exceptions.each do |exception|
-        match = CAPTURE_REGEX.match(exception.message)
+
+      event.errors.each do |error|
+        match = CAPTURE_REGEX.match(error.error_message)
+
         next unless match
 
         suggestions = match.captures[0].split(DELIMITER)
-        matches.concat suggestions.map{ |suggestion| suggestion.strip }
+        matches.concat(suggestions.map(&:strip))
       end
 
       if matches.size == 1
-        report.add_tab(:error, {:suggestion => matches.first})
+        event.add_metadata(:error, { suggestion: matches.first })
       elsif matches.size > 1
-        report.add_tab(:error, {:suggestions => matches})
+        event.add_metadata(:error, { suggestions: matches })
       end
 
-      @bugsnag.call(report)
+      @bugsnag.call(event)
     end
   end
 end

data/lib/bugsnag/middleware_stack.rb

@@ -131,8 +131,8 @@ module Bugsnag
     #
     # @return [Array<Proc>]
     def middleware_procs
-      # Split the middleware into separate lists of Procs and Classes
-      procs, classes = @middlewares.partition {|middleware| middleware.is_a?(Proc) }
+      # Split the middleware into separate lists of callables (e.g. Proc, Lambda, Method) and Classes
+      callables, classes = @middlewares.partition {|middleware| middleware.respond_to?(:call) }
 
       # Wrap the classes in a proc that, when called, news up the middleware and
       # passes the next middleware in the queue
@@ -140,12 +140,12 @@ module Bugsnag
         proc {|next_middleware| middleware.new(next_middleware) }
       end
 
-      # Wrap the list of procs in a proc that, when called, wraps them in an
+      # Wrap the list of callables in a proc that, when called, wraps them in an
       # 'OnErrorCallbacks' instance that also has a reference to the next middleware
-      wrapped_procs = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, procs) }
+      wrapped_callables = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, callables) }
 
-      # Return the combined middleware and wrapped procs
-      middleware_instances.push(wrapped_procs)
+      # Return the combined middleware and wrapped callables
+      middleware_instances.push(wrapped_callables)
     end
   end
 end