bugsnag 6.12.2 → 6.16.0

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"
@@ -23,7 +24,6 @@ module Bugsnag
     attr_accessor :send_code
     attr_accessor :project_root
     attr_accessor :app_version
-    attr_accessor :app_type
     attr_accessor :meta_data_filters
     attr_accessor :logger
     attr_accessor :middleware
@@ -35,9 +35,13 @@ module Bugsnag
     attr_accessor :timeout
     attr_accessor :hostname
     attr_accessor :runtime_versions
-    attr_accessor :ignore_classes
+    attr_accessor :discard_classes
     attr_accessor :auto_capture_sessions
 
+    ##
+    # @deprecated Use {#discard_classes} instead
+    attr_accessor :ignore_classes
+
     ##
     # @return [String] URL error notifications will be delivered to
     attr_reader :notify_endpoint
@@ -63,6 +67,14 @@ module Bugsnag
     # @return [Integer] the maximum allowable amount of breadcrumbs per thread
     attr_reader :max_breadcrumbs
 
+    ##
+    # @return [Regexp] matching file paths out of project
+    attr_accessor :vendor_path
+
+    ##
+    # @return [Array]
+    attr_reader :scopes_to_filter
+
     API_KEY_REGEX = /[0-9a-f]{32}/i
     THREAD_LOCAL_NAME = "bugsnag_req_data"
 
@@ -81,6 +93,11 @@ 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_SCOPES_TO_FILTER = ['events.metaData', 'events.breadcrumbs.metaData'].freeze
+
     alias :track_sessions :auto_capture_sessions
     alias :track_sessions= :auto_capture_sessions=
 
@@ -92,11 +109,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
 
@@ -115,7 +134,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"]
@@ -125,6 +147,11 @@ module Bugsnag
         parse_proxy(proxy_uri)
       end
 
+      # Set up vendor_path regex to mark stacktrace file paths as out of project.
+      # Stacktrace lines that matches regex will be marked as "out of project"
+      # will only appear in the full trace.
+      self.vendor_path = DEFAULT_VENDOR_PATH
+
       # Set up logging
       self.logger = Logger.new(STDOUT)
       self.logger.level = Logger::INFO
@@ -135,6 +162,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
@@ -169,6 +197,54 @@ module Bugsnag
       @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.
@@ -290,8 +366,37 @@ module Bugsnag
       @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

data/lib/bugsnag/delivery/thread_queue.rb

@@ -9,8 +9,14 @@ module Bugsnag
 
       class << self
         ##
-        # Queues a given payload to be delivered asynchronously.
-        def deliver(url, body, configuration, options={})
+        # Queues a given payload to be delivered asynchronously
+        #
+        # @param url [String]
+        # @param get_payload [Proc] A Proc that will return the payload.
+        # @param configuration [Bugsnag::Configuration]
+        # @param options [Hash]
+        # @return [void]
+        def serialize_and_deliver(url, get_payload, configuration, options={})
           @configuration = configuration
 
           start_once!
@@ -21,7 +27,16 @@ module Bugsnag
           end
 
           # Add delivery to the worker thread
-          @queue.push proc { super(url, body, configuration, options) }
+          @queue.push(proc do
+            begin
+              payload = get_payload.call
+            rescue StandardError => e
+              configuration.warn("Notification to #{url} failed, #{e.inspect}")
+              configuration.warn(e.backtrace)
+            end
+
+            Synchronous.deliver(url, payload, configuration, options) unless payload.nil?
+          end)
         end
 
         private

data/lib/bugsnag/helpers.rb

@@ -17,12 +17,10 @@ module Bugsnag
     def self.trim_if_needed(value)
       value = "" if value.nil?
 
-      # Sanitize object
-      sanitized_value = Bugsnag::Cleaner.clean_object_encoding(value)
-      return sanitized_value unless payload_too_long?(sanitized_value)
+      return value unless payload_too_long?(value)
 
       # Trim metadata
-      reduced_value = trim_metadata(sanitized_value)
+      reduced_value = trim_metadata(value)
       return reduced_value unless payload_too_long?(reduced_value)
 
       # Trim code from stacktrace

data/lib/bugsnag/integrations/delayed_job.rb

@@ -10,11 +10,23 @@ end
 module Delayed
   module Plugins
     class Bugsnag < ::Delayed::Plugin
+      ##
+      # DelayedJob doesn't have an easy way to fetch its version, but we can use
+      # Gem.loaded_specs to get the version instead
+      def self.delayed_job_version
+        ::Gem.loaded_specs['delayed_job'].version.to_s
+      rescue StandardError
+        # Explicitly return nil to prevent Rubocop complaining of a suppressed exception
+        nil
+      end
+
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, *args, &block|
           begin
-            ::Bugsnag.configuration.app_type = 'delayed_job'
+            ::Bugsnag.configuration.detected_app_type = 'delayed_job'
+            ::Bugsnag.configuration.runtime_versions['delayed_job'] = delayed_job_version if defined?(::Gem)
             ::Bugsnag.configuration.set_request_data(:delayed_job, job)
+
             block.call(job, *args)
           rescue Exception => exception
             ::Bugsnag.notify(exception, true) do |report|

data/lib/bugsnag/integrations/mailman.rb

@@ -11,7 +11,8 @@ module Bugsnag
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Mailman)
-      Bugsnag.configuration.app_type = "mailman"
+      Bugsnag.configuration.detected_app_type = "mailman"
+      Bugsnag.configuration.runtime_versions["mailman"] = ::Mailman::VERSION
     end
 
     ##

data/lib/bugsnag/integrations/que.rb

@@ -37,7 +37,8 @@ if defined?(::Que)
     end
   end
 
-  Bugsnag.configuration.app_type ||= "que"
+  Bugsnag.configuration.detected_app_type = "que"
+
   if defined?(::Que::Version)
     Bugsnag.configuration.runtime_versions["que"] = ::Que::Version
   elsif defined?(::Que::VERSION)

data/lib/bugsnag/integrations/rack.rb

@@ -30,7 +30,9 @@ module Bugsnag
         config.middleware.insert_before(Bugsnag::Middleware::Callbacks, Bugsnag::Middleware::ClearanceUser) if defined?(Clearance)
 
         # Set environment data for payload
-        config.app_type ||= "rack"
+        # Note we only set the detected app_type if it's not already set. This
+        # ensures we don't overwrite the value set by the Railtie
+        config.detected_app_type ||= "rack"
         config.runtime_versions["rack"] = ::Rack.release if defined?(::Rack)
         config.runtime_versions["sinatra"] = ::Sinatra::VERSION if defined?(::Sinatra)
       end

data/lib/bugsnag/integrations/railtie.rb

@@ -25,7 +25,7 @@ module Bugsnag
       # initializer. If not, the key will be validated in after_initialize.
       Bugsnag.configure(false) do |config|
         config.logger = ::Rails.logger
-        config.release_stage = ENV["BUGSNAG_RELEASE_STAGE"] || ::Rails.env.to_s
+        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.runtime_versions["rails"] = ::Rails::VERSION::STRING
@@ -43,7 +43,9 @@ module Bugsnag
 
       Bugsnag::Rails::DEFAULT_RAILS_BREADCRUMBS.each { |event| event_subscription(event) }
 
-      Bugsnag.configuration.app_type = "rails"
+      # Make sure we don't overwrite the value set by another integration because
+      # Rails is a less specific app_type (e.g. Que sets this earlier than us)
+      Bugsnag.configuration.detected_app_type ||= "rails"
     end
 
     # Configure meta_data_filters after initialization, so that rails initializers
@@ -63,9 +65,19 @@ module Bugsnag
 
     initializer "bugsnag.use_rack_middleware" do |app|
       begin
-        app.config.middleware.insert_after ActionDispatch::DebugExceptions, Bugsnag::Rack
-      rescue
-        app.config.middleware.use Bugsnag::Rack
+        begin
+          app.config.middleware.insert_after ActionDispatch::DebugExceptions, Bugsnag::Rack
+        rescue
+          app.config.middleware.use Bugsnag::Rack
+        end
+      rescue FrozenError
+        # This can happen when running RSpec if there is a crash after Rails has
+        # started booting but before we've added our middleware. If we don't ignore
+        # this error then the stacktrace blames Bugsnag, which isn't accurate as
+        # the middleware will only be frozen if an earlier error occurs
+        # See this comment for more info:
+        # https://github.com/thoughtbot/factory_bot_rails/issues/303#issuecomment-434560625
+        Bugsnag.configuration.warn("Unable to add Bugsnag::Rack middleware as the middleware stack is frozen")
       end
     end