bugsnag 6.13.1 → 6.18.0

data/lib/bugsnag/breadcrumbs/breadcrumb.rb

@@ -69,7 +69,7 @@ module Bugsnag::Breadcrumbs
         :name => @name,
         :type => @type,
         :metaData => @meta_data,
-        :timestamp => @timestamp.iso8601
+        :timestamp => @timestamp.iso8601(3)
       }
     end
   end

data/lib/bugsnag/breadcrumbs/breadcrumbs.rb

@@ -1,6 +1,4 @@
 module Bugsnag::Breadcrumbs
-  MAX_NAME_LENGTH = 30
-
   VALID_BREADCRUMB_TYPES = [
     ERROR_BREADCRUMB_TYPE = "error",
     MANUAL_BREADCRUMB_TYPE = "manual",

data/lib/bugsnag/breadcrumbs/validator.rb

@@ -15,12 +15,6 @@ module Bugsnag::Breadcrumbs
     #
     # @param breadcrumb [Bugsnag::Breadcrumbs::Breadcrumb] the breadcrumb to be validated
     def validate(breadcrumb)
-      # Check name length
-      if breadcrumb.name.size > Bugsnag::Breadcrumbs::MAX_NAME_LENGTH
-        @configuration.debug("Breadcrumb name trimmed to length #{Bugsnag::Breadcrumbs::MAX_NAME_LENGTH}.  Original name: #{breadcrumb.name}")
-        breadcrumb.name = breadcrumb.name.slice(0...Bugsnag::Breadcrumbs::MAX_NAME_LENGTH)
-      end
-
       # Check meta_data hash doesn't contain complex values
       breadcrumb.meta_data = breadcrumb.meta_data.select do |k, v|
         if valid_meta_data_type?(v)

data/lib/bugsnag/cleaner.rb

@@ -1,19 +1,76 @@
 require 'uri'
 
 module Bugsnag
+  # @api private
   class Cleaner
     FILTERED = '[FILTERED]'.freeze
     RECURSION = '[RECURSION]'.freeze
     OBJECT = '[OBJECT]'.freeze
     RAISED = '[RAISED]'.freeze
+    OBJECT_WITH_ID_AND_CLASS = '[OBJECT]: [Class]: %<class_name>s [ID]: %<id>d'.freeze
 
-    def initialize(filters)
-      @filters = Array(filters)
-      @deep_filters = @filters.any? {|f| f.kind_of?(Regexp) && f.to_s.include?("\\.".freeze) }
+    ##
+    # @param configuration [Configuration]
+    def initialize(configuration)
+      @configuration = configuration
     end
 
-    def clean_object(obj)
-      traverse_object(obj, {}, nil)
+    def clean_object(object)
+      @deep_filters = deep_filters?
+
+      traverse_object(object, {}, nil)
+    end
+
+    ##
+    # @param url [String]
+    # @return [String]
+    def clean_url(url)
+      return url if @configuration.meta_data_filters.empty?
+
+      uri = URI(url)
+      return url unless uri.query
+
+      query_params = uri.query.split('&').map { |pair| pair.split('=') }
+      query_params.map! do |key, val|
+        if filters_match?(key)
+          "#{key}=#{FILTERED}"
+        else
+          "#{key}=#{val}"
+        end
+      end
+
+      uri.query = query_params.join('&')
+      uri.to_s
+    end
+
+    private
+
+    ##
+    # This method calculates whether we need to filter deeply or not; i.e. whether
+    # we should match both with and without 'request.params'
+    #
+    # This is cached on the instance variable '@deep_filters' for performance
+    # reasons
+    #
+    # @return [Boolean]
+    def deep_filters?
+      @configuration.meta_data_filters.any? do |filter|
+        filter.is_a?(Regexp) && filter.to_s.include?("\\.".freeze)
+      end
+    end
+
+    def clean_string(str)
+      if defined?(str.encoding) && defined?(Encoding::UTF_8)
+        if str.encoding == Encoding::UTF_8
+          str.valid_encoding? ? str : str.encode('utf-16', invalid: :replace, undef: :replace).encode('utf-8')
+        else
+          str.encode('utf-8', invalid: :replace, undef: :replace)
+        end
+      elsif defined?(Iconv)
+        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
+      else
+        str
+      end
     end
 
     def traverse_object(obj, seen, scope)
@@ -28,12 +85,14 @@ module Bugsnag
       value = case obj
       when Hash
         clean_hash = {}
-        obj.each do |k,v|
+        obj.each do |k, v|
           begin
-            if filters_match_deeply?(k, scope)
+            current_scope = [scope, k].compact.join('.')
+
+            if filters_match_deeply?(k, current_scope)
               clean_hash[k] = FILTERED
             else
-              clean_hash[k] = traverse_object(v, seen, [scope, k].compact.join('.'))
+              clean_hash[k] = traverse_object(v, seen, current_scope)
             end
           # If we get an error here, we assume the key needs to be filtered
           # to avoid leaking things we shouldn't. We also remove the key itself
@@ -63,7 +122,12 @@ module Bugsnag
 
         # avoid leaking potentially sensitive data from objects' #inspect output
         if str =~ /#<.*>/
-          OBJECT
+          # Use id of the object if available
+          if obj.respond_to?(:id)
+            format(OBJECT_WITH_ID_AND_CLASS, class_name: obj.class, id: obj.id)
+          else
+            OBJECT
+          end
         else
           clean_string(str)
         end
@@ -73,67 +137,56 @@ module Bugsnag
       value
     end
 
-    def clean_string(str)
-      if defined?(str.encoding) && defined?(Encoding::UTF_8)
-        if str.encoding == Encoding::UTF_8
-          str.valid_encoding? ? str : str.encode('utf-16', invalid: :replace, undef: :replace).encode('utf-8')
+    ##
+    # @param key [String, #to_s]
+    # @return [Boolean]
+    def filters_match?(key)
+      str = key.to_s
+
+      @configuration.meta_data_filters.any? do |filter|
+        case filter
+        when Regexp
+          str.match(filter)
         else
-          str.encode('utf-8', invalid: :replace, undef: :replace)
+          str.include?(filter.to_s)
         end
-      elsif defined?(Iconv)
-        Iconv.conv('UTF-8//IGNORE', 'UTF-8', str) || str
-      else
-        str
       end
     end
 
-    def self.clean_object_encoding(obj)
-      new(nil).clean_object(obj)
-    end
+    ##
+    # If someone has a Rails filter like /^stuff\.secret/, it won't match
+    # "request.params.stuff.secret", so we try it both with and without the
+    # "request.params." bit.
+    #
+    # @param key [String, #to_s]
+    # @param scope [String]
+    # @return [Boolean]
+    def filters_match_deeply?(key, scope)
+      return false unless scope_should_be_filtered?(scope)
 
-    def clean_url(url)
-      return url if @filters.empty?
+      return true if filters_match?(key)
+      return false unless @deep_filters
 
-      uri = URI(url)
-      return url unless uri.query
+      return true if filters_match?(scope)
 
-      query_params = uri.query.split('&').map { |pair| pair.split('=') }
-      query_params.map! do |key, val|
-        if filters_match?(key)
-          "#{key}=#{FILTERED}"
+      @configuration.scopes_to_filter.any? do |scope_to_filter|
+        if scope.start_with?("#{scope_to_filter}.request.params.")
+          filters_match?(scope.sub("#{scope_to_filter}.request.params.", ''))
         else
-          "#{key}=#{val}"
+          filters_match?(scope.sub("#{scope_to_filter}.", ''))
         end
       end
-
-      uri.query = query_params.join('&')
-      uri.to_s
     end
 
-    private
-
-    def filters_match?(key)
-      str = key.to_s
-
-      @filters.any? do |f|
-        case f
-        when Regexp
-          str.match(f)
-        else
-          str.include?(f.to_s)
-        end
+    ##
+    # Should the given scope be filtered?
+    #
+    # @param scope [String]
+    # @return [Boolean]
+    def scope_should_be_filtered?(scope)
+      @configuration.scopes_to_filter.any? do |scope_to_filter|
+        scope.start_with?("#{scope_to_filter}.")
       end
     end
-
-    # If someone has a Rails filter like /^stuff\.secret/, it won't match "request.params.stuff.secret",
-    # so we try it both with and without the "request.params." bit.
-    def filters_match_deeply?(key, scope)
-      return true if filters_match?(key)
-      return false unless @deep_filters
-
-      long = [scope, key].compact.join('.')
-      short = long.sub(/^request\.params\./, '')
-      filters_match?(long) || filters_match?(short)
-    end
   end
 end

data/lib/bugsnag/code_extractor.rb

@@ -0,0 +1,137 @@
+module Bugsnag
+  # @api private
+  class CodeExtractor
+    MAXIMUM_LINES_TO_KEEP = 7
+
+    ##
+    # @param configuration [Configuration]
+    def initialize(configuration)
+      @files = {}
+      @configuration = configuration
+    end
+
+    ##
+    # Add a file and its corresponding trace hash to be processed.
+    #
+    # @param path [String] The full path to the file
+    # @param trace [Hash]
+    # @return [void]
+    def add_file(path, trace)
+      # If the file doesn't exist we can't extract code from it, so we can skip
+      # this file entirely
+      unless File.exist?(path)
+        trace[:code] = nil
+
+        return
+      end
+
+      @files[path] ||= []
+      @files[path].push(trace)
+
+      # Record the line numbers we want to fetch for this trace
+      # We grab extra lines so that we can compensate if the error is on the
+      # first or last line of a file
+      first_line_number = trace[:lineNumber] - MAXIMUM_LINES_TO_KEEP
+
+      trace[:first_line_number] = first_line_number < 1 ? 1 : first_line_number
+      trace[:last_line_number] = trace[:lineNumber] + MAXIMUM_LINES_TO_KEEP
+    end
+
+    ##
+    # Add the code to the hashes that were given in {#add_file} by modifying
+    # them in-place. They will have a new ':code' key containing a hash of line
+    # number => string of code for that line
+    #
+    # @return [void]
+    def extract!
+      @files.each do |path, traces|
+        begin
+          line_numbers = Set.new
+
+          traces.each do |trace|
+            trace[:first_line_number].upto(trace[:last_line_number]) do |line_number|
+              line_numbers << line_number
+            end
+          end
+
+          extract_from(path, traces, line_numbers)
+        rescue StandardError => e
+          # Clean up after ourselves
+          traces.each do |trace|
+            trace[:code] ||= nil
+            trace.delete(:first_line_number)
+            trace.delete(:last_line_number)
+          end
+
+          @configuration.warn("Error extracting code: #{e.inspect}")
+        end
+      end
+    end
+
+    private
+
+    ##
+    # @param path [String]
+    # @param traces [Array<Hash>]
+    # @param line_numbers [Set<Integer>]
+    # @return [void]
+    def extract_from(path, traces, line_numbers)
+      code = {}
+
+      File.open(path) do |file|
+        current_line_number = 0
+
+        file.each_line do |line|
+          current_line_number += 1
+
+          next unless line_numbers.include?(current_line_number)
+
+          code[current_line_number] = line[0...200].rstrip
+        end
+      end
+
+      associate_code_with_trace(code, traces)
+    end
+
+    ##
+    # @param code [Hash{Integer => String}]
+    # @param traces [Array<Hash>]
+    # @return [void]
+    def associate_code_with_trace(code, traces)
+      traces.each do |trace|
+        trace[:code] = {}
+
+        code.each do |line_number, line|
+          # If we've gone past the last line we care about, we can stop iterating
+          break if line_number > trace[:last_line_number]
+
+          # Skip lines that aren't in the range we want
+          next unless line_number >= trace[:first_line_number]
+
+          trace[:code][line_number] = line
+        end
+
+        trim_excess_lines(trace[:code], trace[:lineNumber])
+        trace.delete(:first_line_number)
+        trace.delete(:last_line_number)
+      end
+    end
+
+    ##
+    # @param code [Hash{Integer => String}]
+    # @param line_number [Integer]
+    # @return [void]
+    def trim_excess_lines(code, line_number)
+      while code.length > MAXIMUM_LINES_TO_KEEP
+        last_line = code.keys.max
+        first_line = code.keys.min
+
+        if (last_line - line_number) > (line_number - first_line)
+          code.delete(last_line)
+        else
+          code.delete(first_line)
+        end
+      end
+    end
+  end
+end

data/lib/bugsnag/configuration.rb

@@ -3,6 +3,7 @@ require "socket"
 require "logger"
 require "bugsnag/middleware_stack"
 require "bugsnag/middleware/callbacks"
+require "bugsnag/middleware/discard_error_class"
 require "bugsnag/middleware/exception_meta_data"
 require "bugsnag/middleware/ignore_error_class"
 require "bugsnag/middleware/suggestion_data"
@@ -14,59 +15,136 @@ require "bugsnag/breadcrumbs/breadcrumbs"
 
 module Bugsnag
   class Configuration
+    # Your Integration API Key
+    # @return [String, nil]
     attr_accessor :api_key
+
+    # The current stage of the release process, e.g. 'development', production'
+    # @return [String, nil]
     attr_accessor :release_stage
+
+    # A list of which release stages should cause notifications to be sent
+    # @return [Array<String>, nil]
     attr_accessor :notify_release_stages
+
+    # Whether notifications should automatically be sent
+    # @return [Boolean]
     attr_accessor :auto_notify
+
+    # @return [String, nil]
     attr_accessor :ca_file
+
+    # Whether to automatically attach the Rack environment to notifications
+    # @return [Boolean]
     attr_accessor :send_environment
+
+    # Whether code snippets from the exception stacktrace should be sent with notifications
+    # @return [Boolean]
     attr_accessor :send_code
+
+    # Any stacktrace lines that match this path will be marked as 'in project'
+    # @return [String, nil]
     attr_accessor :project_root
+
+    # The current version of your application
+    # @return [String, nil]
     attr_accessor :app_version
-    attr_accessor :app_type
+
+    # A list of keys that should be filtered out from the report and breadcrumb
+    # metadata before sending them to Bugsnag
+    # @return [Set<String, Regexp>]
     attr_accessor :meta_data_filters
+
+    # The logger to use for Bugsnag log messages
+    # @return [Logger]
     attr_accessor :logger
+
+    # The middleware stack that will run on every notification
+    # @return [MiddlewareStack]
     attr_accessor :middleware
+
+    # @api private
+    # @return [MiddlewareStack]
     attr_accessor :internal_middleware
+
+    # The host address of the HTTP proxy that should be used when making requests
+    # @see parse_proxy
+    # @return [String, nil]
     attr_accessor :proxy_host
+
+    # The port number of the HTTP proxy that should be used when making requests
+    # @see parse_proxy
+    # @return [Integer, nil]
     attr_accessor :proxy_port
+
+    # The user that should be used when making requests via a HTTP proxy
+    # @see parse_proxy
+    # @return [String, nil]
     attr_accessor :proxy_user
+
+    # The password for the user that should be used when making requests via a HTTP proxy
+    # @see parse_proxy
+    # @return [String, nil]
     attr_accessor :proxy_password
+
+    # The HTTP request timeout, defaults to 15 seconds
+    # @return [Integer]
     attr_accessor :timeout
+
+    # The name or descriptor of the Ruby server host
+    # @return [String]
     attr_accessor :hostname
+
+    # @api private
+    # @return [Hash{String => String}]
     attr_accessor :runtime_versions
-    attr_accessor :ignore_classes
+
+    # Exception classes that will be discarded and not sent to Bugsnag
+    # @return [Set<String, Regexp>]
+    attr_accessor :discard_classes
+
+    # Whether Bugsnag should automatically record sessions
+    # @return [Boolean]
     attr_accessor :auto_capture_sessions
 
-    ##
-    # @return [String] URL error notifications will be delivered to
+    # @deprecated Use {#discard_classes} instead
+    # @return [Set<Class, Proc>]
+    attr_accessor :ignore_classes
+
+    # The URL error notifications will be delivered to
+    # @return [String]
     attr_reader :notify_endpoint
     alias :endpoint :notify_endpoint
 
-    ##
-    # @return [String] URL session notifications will be delivered to
+    # The URL session notifications will be delivered to
+    # @return [String]
     attr_reader :session_endpoint
 
-    ##
-    # @return [Boolean] whether any sessions types will be delivered
+    # Whether sessions will be delivered
+    # @return [Boolean]
     attr_reader :enable_sessions
 
-    ##
-    # @return [Array<String>] strings indicating allowable automatic breadcrumb types
+    # A list of strings indicating allowable automatic breadcrumb types
+    # @see Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES
+    # @return [Array<String>]
     attr_accessor :enabled_automatic_breadcrumb_types
 
-    ##
-    # @return [Array<#call>] callables to be run before a breadcrumb is logged
+    # Callables to be run before a breadcrumb is logged
+    # @return [Array<#call>]
     attr_accessor :before_breadcrumb_callbacks
 
-    ##
-    # @return [Integer] the maximum allowable amount of breadcrumbs per thread
+    # The maximum allowable amount of breadcrumbs per thread
+    # @return [Integer]
     attr_reader :max_breadcrumbs
 
-    ##
-    # @return [Regexp] matching file paths out of project
+    #
+    # @return [Regexp]
     attr_accessor :vendor_path
 
+    # @api private
+    # @return [Array<String>]
+    attr_reader :scopes_to_filter
+
     API_KEY_REGEX = /[0-9a-f]{32}/i
     THREAD_LOCAL_NAME = "bugsnag_req_data"
 
@@ -86,7 +164,10 @@ module Bugsnag
     DEFAULT_MAX_BREADCRUMBS = 25
 
     # Path to vendored code. Used to mark file paths as out of project.
-    DEFAULT_VENDOR_PATH = %r{^(vendor\/|\.bundle\/)}
+    DEFAULT_VENDOR_PATH = %r{^(vendor/|\.bundle/)}
+
+    # @api private
+    DEFAULT_SCOPES_TO_FILTER = ['events.metaData', 'events.breadcrumbs.metaData'].freeze
 
     alias :track_sessions :auto_capture_sessions
     alias :track_sessions= :auto_capture_sessions=
@@ -99,11 +180,13 @@ module Bugsnag
       self.send_environment = false
       self.send_code = true
       self.meta_data_filters = Set.new(DEFAULT_META_DATA_FILTERS)
+      self.scopes_to_filter = DEFAULT_SCOPES_TO_FILTER
       self.hostname = default_hostname
       self.runtime_versions = {}
       self.runtime_versions["ruby"] = RUBY_VERSION
       self.runtime_versions["jruby"] = JRUBY_VERSION if defined?(JRUBY_VERSION)
       self.timeout = 15
+      self.release_stage = ENV['BUGSNAG_RELEASE_STAGE']
       self.notify_release_stages = nil
       self.auto_capture_sessions = true
 
@@ -122,7 +205,10 @@ module Bugsnag
 
       # SystemExit and SignalException are common Exception types seen with
       # successful exits and are not automatically reported to Bugsnag
+      # TODO move these defaults into `discard_classes` when `ignore_classes`
+      #      is removed
       self.ignore_classes = Set.new([SystemExit, SignalException])
+      self.discard_classes = Set.new([])
 
       # Read the API key from the environment
       self.api_key = ENV["BUGSNAG_API_KEY"]
@@ -147,6 +233,7 @@ module Bugsnag
       # Configure the bugsnag middleware stack
       self.internal_middleware = Bugsnag::MiddlewareStack.new
       self.internal_middleware.use Bugsnag::Middleware::ExceptionMetaData
+      self.internal_middleware.use Bugsnag::Middleware::DiscardErrorClass
       self.internal_middleware.use Bugsnag::Middleware::IgnoreErrorClass
       self.internal_middleware.use Bugsnag::Middleware::SuggestionData
       self.internal_middleware.use Bugsnag::Middleware::ClassifyError
@@ -161,6 +248,7 @@ module Bugsnag
     # Gets the delivery_method that Bugsnag will use to communicate with the
     # notification endpoint.
     #
+    # @return [Symbol]
     def delivery_method
       @delivery_method || @default_delivery_method || :thread_queue
     end
@@ -169,6 +257,10 @@ module Bugsnag
     # Sets the delivery_method that Bugsnag will use to communicate with the
     # notification endpoint.
     #
+    # The default delivery methods are ':thread_queue' and ':synchronous'.
+    #
+    # @param delivery_method [Symbol]
+    # @return [void]
     def delivery_method=(delivery_method)
       @delivery_method = delivery_method
     end
@@ -177,19 +269,75 @@ module Bugsnag
     # Used to set a new default delivery method that will be used if one is not
     # set with #delivery_method.
     #
+    # @api private
+    #
+    # @param delivery_method [Symbol]
+    # @return [void]
     def default_delivery_method=(delivery_method)
       @default_delivery_method = delivery_method
     end
 
+    ##
+    # Get the type of application executing the current code
+    #
+    # This is usually used to represent if you are running in a Rails server,
+    # Sidekiq job, Rake task etc... Bugsnag will automatically detect most
+    # application types for you
+    #
+    # @return [String, nil]
+    def app_type
+      @app_type || @detected_app_type
+    end
+
+    ##
+    # Set the type of application executing the current code
+    #
+    # If an app_type is set, this will be used instead of the automatically
+    # detected app_type that Bugsnag would otherwise use
+    #
+    # @param app_type [String]
+    # @return [void]
+    def app_type=(app_type)
+      @app_type = app_type
+    end
+
+    ##
+    # Get the detected app_type, which is used when one isn't set explicitly
+    #
+    # @api private
+    #
+    # @return [String, nil]
+    def detected_app_type
+      @detected_app_type
+    end
+
+    ##
+    # Set the detected app_type, which is used when one isn't set explicitly
+    #
+    # This allows Bugsnag's integrations to say 'this is a Rails app' while
+    # allowing the user to overwrite this if they wish
+    #
+    # @api private
+    #
+    # @param app_type [String]
+    # @return [void]
+    def detected_app_type=(app_type)
+      @detected_app_type = app_type
+    end
+
     ##
     # Indicates whether the notifier should send a notification based on the
     # configured release stage.
+    #
+    # @return [Boolean]
     def should_notify_release_stage?
       @release_stage.nil? || @notify_release_stages.nil? || @notify_release_stages.include?(@release_stage)
     end
 
     ##
     # Tests whether the configured API key is valid.
+    #
+    # @return [Boolean]
     def valid_api_key?
       !api_key.nil? && api_key =~ API_KEY_REGEX
     end
@@ -197,48 +345,68 @@ module Bugsnag
     ##
     # Returns the array of data that will be automatically attached to every
     # error notification.
+    #
+    # @return [Hash]
     def request_data
       Thread.current[THREAD_LOCAL_NAME] ||= {}
     end
 
     ##
     # Sets an entry in the array of data attached to every error notification.
+    #
+    # @param key [String, #to_s]
+    # @param value [Object]
+    # @return [void]
     def set_request_data(key, value)
       self.request_data[key] = value
     end
 
     ##
     # Unsets an entry in the array of data attached to every error notification.
+    #
+    # @param (see set_request_data)
+    # @return [void]
     def unset_request_data(key, value)
       self.request_data.delete(key)
     end
 
     ##
     # Clears the array of data attached to every error notification.
+    #
+    # @return [void]
     def clear_request_data
       Thread.current[THREAD_LOCAL_NAME] = nil
     end
 
     ##
     # Logs an info level message
+    #
+    # @param message [String, #to_s] The message to log
     def info(message)
       logger.info(PROG_NAME) { message }
     end
 
     ##
     # Logs a warning level message
+    #
+    # @param (see info)
     def warn(message)
       logger.warn(PROG_NAME) { message }
     end
 
     ##
     # Logs a debug level message
+    #
+    # @param (see info)
     def debug(message)
       logger.debug(PROG_NAME) { message }
     end
 
     ##
     # Parses and sets proxy from a uri
+    #
+    # @param uri [String, #to_s] The URI to parse and extract proxy details from
+    # @return [void]
     def parse_proxy(uri)
       proxy = URI.parse(uri)
       self.proxy_host = proxy.host
@@ -250,7 +418,8 @@ module Bugsnag
     ##
     # Sets the maximum allowable amount of breadcrumbs
     #
-    # @param [Integer] the new maximum breadcrumb limit
+    # @param new_max_breadcrumbs [Integer] the new maximum breadcrumb limit
+    # @return [void]
     def max_breadcrumbs=(new_max_breadcrumbs)
       @max_breadcrumbs = new_max_breadcrumbs
       breadcrumbs.max_items = new_max_breadcrumbs
@@ -266,9 +435,10 @@ module Bugsnag
 
     # Sets the notification endpoint
     #
-    # @param new_notify_endpoint [String] The URL to deliver error notifications to
-    #
     # @deprecated Use {#set_endpoints} instead
+    #
+    # @param new_notify_endpoint [String] The URL to deliver error notifications to
+    # @return [void]
     def endpoint=(new_notify_endpoint)
       warn("The 'endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead")
       set_endpoints(new_notify_endpoint, session_endpoint) # Pass the existing session_endpoint through so it doesn't get overwritten
@@ -277,9 +447,10 @@ module Bugsnag
     ##
     # Sets the sessions endpoint
     #
-    # @param new_session_endpoint [String] The URL to deliver session notifications to
-    #
     # @deprecated Use {#set_endpoints} instead
+    #
+    # @param new_session_endpoint [String] The URL to deliver session notifications to
+    # @return [void]
     def session_endpoint=(new_session_endpoint)
       warn("The 'session_endpoint' configuration option is deprecated. The 'set_endpoints' method should be used instead")
       set_endpoints(notify_endpoint, new_session_endpoint) # Pass the existing notify_endpoint through so it doesn't get overwritten
@@ -290,20 +461,52 @@ module Bugsnag
     #
     # @param new_notify_endpoint [String] The URL to deliver error notifications to
     # @param new_session_endpoint [String] The URL to deliver session notifications to
+    # @return [void]
     def set_endpoints(new_notify_endpoint, new_session_endpoint)
       @notify_endpoint = new_notify_endpoint
       @session_endpoint = new_session_endpoint
     end
 
     ##
-    # Disables session tracking and delivery.  Cannot be undone
+    # Disables session tracking and delivery. Cannot be undone
+    #
+    # @return [void]
     def disable_sessions
       self.auto_capture_sessions = false
       @enable_sessions = false
     end
 
+    ##
+    # Add the given callback to the list of on_error callbacks
+    #
+    # The on_error callbacks will be called when an error is captured or reported
+    # and are passed a {Bugsnag::Report} object
+    #
+    # Returning false from an on_error callback will cause the error to be ignored
+    # and will prevent any remaining callbacks from being called
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def add_on_error(callback)
+      middleware.use(callback)
+    end
+
+    ##
+    # Remove the given callback from the list of on_error callbacks
+    #
+    # Note that this must be the same Proc instance that was passed to
+    # {#add_on_error}, otherwise it will not be removed
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def remove_on_error(callback)
+      middleware.remove(callback)
+    end
+
     private
 
+    attr_writer :scopes_to_filter
+
     PROG_NAME = "[Bugsnag]"
 
     def default_hostname