bugsnag 6.20.0 → 6.24.0

data/lib/bugsnag/integrations/railtie.rb

@@ -9,11 +9,44 @@ 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
+
     rake_tasks do
       require "bugsnag/integrations/rake"
       load "bugsnag/tasks/bugsnag.rake"
@@ -27,7 +60,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
 
@@ -41,6 +74,14 @@ module Bugsnag
         include Bugsnag::Rails::ActiveRecordRescue
       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) }
 
       # Make sure we don't overwrite the value set by another integration because
@@ -80,39 +121,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"
-          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
   end
 end

data/lib/bugsnag/integrations/resque.rb

@@ -44,9 +44,19 @@ module Bugsnag
           :attributes => FRAMEWORK_ATTRIBUTES
         }
 
-        context = "#{payload['class']}@#{queue}"
-        report.meta_data.merge!({:context => context, :payload => payload})
-        report.context = context
+        metadata = payload
+        class_name = payload['class']
+
+        # when using Active Job the payload "class" will always be the Resque
+        # "JobWrapper", not the actual job class so we need to fix this here
+        if metadata['args'] && metadata['args'][0] && metadata['args'][0]['job_class']
+          class_name = metadata['args'][0]['job_class']
+          metadata['wrapped'] ||= class_name
+        end
+
+        context = "#{class_name}@#{queue}"
+        report.meta_data.merge!({ context: context, payload: metadata })
+        report.automatic_context = context
       end
     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/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_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

data/lib/bugsnag/report.rb

@@ -1,8 +1,10 @@
 require "json"
 require "pathname"
+require "bugsnag/error"
 require "bugsnag/stacktrace"
 
 module Bugsnag
+  # rubocop:todo Metrics/ClassLength
   class Report
     NOTIFIER_NAME = "Ruby Bugsnag Notifier"
     NOTIFIER_VERSION = Bugsnag::VERSION
@@ -45,16 +47,13 @@ module Bugsnag
     # @return [Configuration]
     attr_accessor :configuration
 
-    # Additional context for this report
-    # @return [String, nil]
-    attr_accessor :context
-
     # The delivery method that will be used for this report
     # @see Configuration#delivery_method
     # @return [Symbol]
     attr_accessor :delivery_method
 
     # The list of exceptions in this report
+    # @deprecated Use {#errors} instead
     # @return [Array<Hash>]
     attr_accessor :exceptions
 
@@ -72,10 +71,12 @@ module Bugsnag
     attr_accessor :grouping_hash
 
     # Arbitrary metadata attached to this report
+    # @deprecated Use {#metadata} instead
     # @return [Hash]
     attr_accessor :meta_data
 
     # The raw Exception instances for this report
+    # @deprecated Use {#original_error} instead
     # @see #exceptions
     # @return [Array<Exception>]
     attr_accessor :raw_exceptions
@@ -102,31 +103,67 @@ module Bugsnag
     # @return [Hash]
     attr_accessor :user
 
+    # A list of errors in this report
+    # @return [Array<Error>]
+    attr_reader :errors
+
+    # The Exception instance this report was created for
+    # @return [Exception]
+    attr_reader :original_error
+
     ##
     # Initializes a new report from an exception.
     def initialize(exception, passed_configuration, auto_notify=false)
+      # store the creation time for use as device.time
+      @created_at = Time.now.utc.iso8601(3)
+
       @should_ignore = false
       @unhandled = auto_notify
+      @initial_unhandled = @unhandled
 
       self.configuration = passed_configuration
 
+      @original_error = exception
       self.raw_exceptions = generate_raw_exceptions(exception)
       self.exceptions = generate_exception_list
+      @errors = generate_error_list
 
       self.api_key = configuration.api_key
       self.app_type = configuration.app_type
       self.app_version = configuration.app_version
       self.breadcrumbs = []
+      self.context = configuration.context if configuration.context_set?
       self.delivery_method = configuration.delivery_method
       self.hostname = configuration.hostname
       self.runtime_versions = configuration.runtime_versions.dup
-      self.meta_data = {}
+      self.meta_data = Utility::Duplicator.duplicate(configuration.metadata)
       self.release_stage = configuration.release_stage
       self.severity = auto_notify ? "error" : "warning"
       self.severity_reason = auto_notify ? {:type => UNHANDLED_EXCEPTION} : {:type => HANDLED_EXCEPTION}
       self.user = {}
+
+      @metadata_delegate = Utility::MetadataDelegate.new
+    end
+
+    ##
+    # Additional context for this report
+    # @!attribute context
+    # @return [String, nil]
+    def context
+      return @context if defined?(@context)
+
+      @automatic_context
     end
 
+    attr_writer :context
+
+    ##
+    # Context set automatically by Bugsnag uses this attribute, which prevents
+    # it from overwriting the user-supplied context
+    # @api private
+    # @return [String, nil]
+    attr_accessor :automatic_context
+
     ##
     # Add a new metadata tab to this notification.
     #
@@ -135,6 +172,8 @@ module Bugsnag
     #   exists, this will be merged with the existing values. If a Hash is not
     #   given, the value will be placed into the 'custom' tab
     # @return [void]
+    #
+    # @deprecated Use {#add_metadata} instead
     def add_tab(name, value)
       return if name.nil?
 
@@ -153,6 +192,8 @@ module Bugsnag
     #
     # @param name [String]
     # @return [void]
+    #
+    # @deprecated Use {#clear_metadata} instead
     def remove_tab(name)
       return if name.nil?
 
@@ -175,7 +216,8 @@ module Bugsnag
         context: context,
         device: {
           hostname: hostname,
-          runtimeVersions: runtime_versions
+          runtimeVersions: runtime_versions,
+          time: @created_at
         },
         exceptions: exceptions,
         groupingHash: grouping_hash,
@@ -257,8 +299,119 @@ module Bugsnag
       end
     end
 
+    # A Hash containing arbitrary metadata
+    # @!attribute metadata
+    # @return [Hash]
+    def metadata
+      @meta_data
+    end
+
+    # @param metadata [Hash]
+    # @return [void]
+    def metadata=(metadata)
+      @meta_data = metadata
+    end
+
+    ##
+    # Data from the current HTTP request. May be nil if no data has been recorded
+    #
+    # @return [Hash, nil]
+    def request
+      @meta_data[:request]
+    end
+
+    ##
+    # Add values to metadata
+    #
+    # @overload add_metadata(section, data)
+    #   Merges data into the given section of metadata
+    #   @param section [String, Symbol]
+    #   @param data [Hash]
+    #
+    # @overload add_metadata(section, key, value)
+    #   Sets key to value in the given section of metadata. If the value is nil
+    #   the key will be deleted
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #   @param value
+    #
+    # @return [void]
+    def add_metadata(section, key_or_data, *args)
+      @metadata_delegate.add_metadata(@meta_data, section, key_or_data, *args)
+    end
+
+    ##
+    # Clear values from metadata
+    #
+    # @overload clear_metadata(section)
+    #   Clears the given section of metadata
+    #   @param section [String, Symbol]
+    #
+    # @overload clear_metadata(section, key)
+    #   Clears the key in the given section of metadata
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #
+    # @return [void]
+    def clear_metadata(section, *args)
+      @metadata_delegate.clear_metadata(@meta_data, section, *args)
+    end
+
+    ##
+    # Set information about the current user
+    #
+    # Additional user fields can be added as metadata in a "user" section
+    #
+    # Setting a field to 'nil' will remove it from the user data
+    #
+    # @param id [String, nil]
+    # @param email [String, nil]
+    # @param name [String, nil]
+    # @return [void]
+    def set_user(id = nil, email = nil, name = nil)
+      new_user = { id: id, email: email, name: name }
+      new_user.reject! { |key, value| value.nil? }
+
+      @user = new_user
+    end
+
+    def unhandled=(new_unhandled)
+      # fix the handled/unhandled counts in the current session
+      update_handled_counts(new_unhandled, @unhandled)
+
+      @unhandled = new_unhandled
+    end
+
+    ##
+    # Returns true if the unhandled flag has been changed from its initial value
+    #
+    # @api private
+    # @return [Boolean]
+    def unhandled_overridden?
+      @unhandled != @initial_unhandled
+    end
+
     private
 
+    def update_handled_counts(is_unhandled, was_unhandled)
+      # do nothing if there is no session to update
+      return if @session.nil?
+
+      # increment the counts for the current unhandled value
+      if is_unhandled
+        @session[:events][:unhandled] += 1
+      else
+        @session[:events][:handled] += 1
+      end
+
+      # decrement the counts for the previous unhandled value
+      if was_unhandled
+        @session[:events][:unhandled] -= 1
+      else
+        @session[:events][:handled] -= 1
+      end
+    end
+
     def generate_exception_list
       raw_exceptions.map do |exception|
         {
@@ -269,6 +422,12 @@ module Bugsnag
       end
     end
 
+    def generate_error_list
+      exceptions.map do |exception|
+        Error.new(exception[:errorClass], exception[:message], exception[:stacktrace])
+      end
+    end
+
     def error_class(exception)
       # The "Class" check is for some strange exceptions like Timeout::Error
       # which throw the error class instead of an instance
@@ -311,4 +470,5 @@ module Bugsnag
       exceptions
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end