bugsnag 6.13.1 → 6.18.0

data/lib/bugsnag/delivery/synchronous.rb

@@ -58,7 +58,7 @@ module Bugsnag
         def default_headers
           {
             "Content-Type" => "application/json",
-            "Bugsnag-Sent-At" =>  Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+            "Bugsnag-Sent-At" => Time.now.utc.iso8601(3)
           }
         end
       end

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
@@ -96,11 +94,11 @@ module Bugsnag
 
     ##
     # Wrapper for trimming stacktraces
-    def self.extract_exception(payload)
+    def self.extract_exception(payload, &block)
       valid_payload = payload.is_a?(Hash) && payload[:events].respond_to?(:map)
       return unless valid_payload && block_given?
       payload[:events].each do |event|
-        event[:exceptions].each { |exception| yield exception }
+        event[:exceptions].each(&block)
       end
     end
 

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
 

data/lib/bugsnag/integrations/rake.rb

@@ -11,7 +11,8 @@ if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.0')
 
       # Executes the rake task with Bugsnag setup with contextual data.
       def execute(args = nil)
-        Bugsnag.configuration.app_type ||= "rake"
+        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
@@ -42,7 +43,8 @@ else
     ##
     # Executes the rake task with Bugsnag setup with contextual data.
     def execute_with_bugsnag(args=nil)
-      Bugsnag.configuration.app_type ||= "rake"
+      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

data/lib/bugsnag/integrations/resque.rb

@@ -58,16 +58,23 @@ Resque::Failure::Bugsnag = Bugsnag::Resque
 # Auto-load the failure backend
 Bugsnag::Resque.add_failure_backend
 
-if Resque::Worker.new(:bugsnag_fork_check).fork_per_job?
+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.app_type = "resque"
-    Bugsnag.configuration.default_delivery_method = :synchronous
+    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.app_type = "resque"
-    Bugsnag.configuration.default_delivery_method = :synchronous
+    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

@@ -11,8 +11,9 @@ module Bugsnag
 
     def initialize
       Bugsnag.configure do |config|
-        config.app_type ||= "shoryuken"
+        config.detected_app_type = "shoryuken"
         config.default_delivery_method = :synchronous
+        config.runtime_versions["shoryuken"] = ::Shoryuken::VERSION
       end
     end
 

data/lib/bugsnag/integrations/sidekiq.rb

@@ -13,8 +13,7 @@ module Bugsnag
 
     def initialize
       Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
-      Bugsnag.configuration.app_type = "sidekiq"
-      Bugsnag.configuration.default_delivery_method = :synchronous
+      Bugsnag.configuration.detected_app_type = "sidekiq"
       Bugsnag.configuration.runtime_versions["sidekiq"] = ::Sidekiq::VERSION
     end
 

data/lib/bugsnag/middleware/delayed_job.rb

@@ -24,6 +24,7 @@ module Bugsnag::Middleware
           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)
           job_data[:payload] = payload_data
         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/ignore_error_class.rb

@@ -2,6 +2,8 @@ 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

data/lib/bugsnag/middleware/rack_request.rb

@@ -28,18 +28,16 @@ module Bugsnag::Middleware
         url = "#{request.scheme}://#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
 
-        cleaner = Bugsnag::Cleaner.new(report.configuration.meta_data_filters)
-
         # If app is passed a bad URL, this code will crash attempting to clean it
         begin
-          url << cleaner.clean_url(request.fullpath)
+          url << Bugsnag.cleaner.clean_url(request.fullpath)
         rescue StandardError => stde
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
         end
 
         referer = nil
         begin
-          referer = cleaner.clean_url(request.referer) if request.referer
+          referer = Bugsnag.cleaner.clean_url(request.referer) if request.referer
         rescue StandardError => stde
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.referer: #{stde}"
         end

data/lib/bugsnag/middleware_stack.rb

@@ -1,3 +1,5 @@
+require "bugsnag/on_error_callbacks"
+
 module Bugsnag
   class MiddlewareStack
     ##
@@ -65,11 +67,26 @@ module Bugsnag
       end
     end
 
+    ##
+    # Disable the given middleware. This removes them from the list of
+    # middleware and ensures they cannot be added again
+    #
+    # See also {#remove}
     def disable(*middlewares)
       @mutex.synchronize do
         @disabled_middleware += middlewares
 
-        @middlewares.delete_if {|m| @disabled_middleware.include?(m)}
+        @middlewares.delete_if {|m| @disabled_middleware.include?(m) }
+      end
+    end
+
+    ##
+    # Remove the given middleware from the list of middleware
+    #
+    # This is like {#disable} but allows the middleware to be added again
+    def remove(*middlewares)
+      @mutex.synchronize do
+        @middlewares.delete_if {|m| middlewares.include?(m) }
       end
     end
 
@@ -91,7 +108,7 @@ module Bugsnag
 
       begin
         # We reverse them, so we can call "call" on the first middleware
-        middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(report)
+        middleware_procs.reverse.inject(notify_lambda) {|n, e| e.call(n) }.call(report)
       rescue StandardError => e
         # KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
         raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
@@ -107,10 +124,28 @@ module Bugsnag
     end
 
     private
+
+    ##
     # Generates a list of middleware procs that are ready to be run
     # Pass each one a reference to the next in the queue
+    #
+    # @return [Array<Proc>]
     def middleware_procs
-      @middlewares.map{|middleware| proc { |next_middleware| middleware.new(next_middleware) } }
+      # Split the middleware into separate lists of Procs and Classes
+      procs, classes = @middlewares.partition {|middleware| middleware.is_a?(Proc) }
+
+      # Wrap the classes in a proc that, when called, news up the middleware and
+      # passes the next middleware in the queue
+      middleware_instances = classes.map do |middleware|
+        proc {|next_middleware| middleware.new(next_middleware) }
+      end
+
+      # Wrap the list of procs 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) }
+
+      # Return the combined middleware and wrapped procs
+      middleware_instances.push(wrapped_procs)
     end
   end
 end

data/lib/bugsnag/on_error_callbacks.rb

@@ -0,0 +1,33 @@
+module Bugsnag
+  # @api private
+  class OnErrorCallbacks
+    def initialize(next_middleware, callbacks)
+      @next_middleware = next_middleware
+      @callbacks = callbacks
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      @callbacks.each do |callback|
+        begin
+          should_continue = callback.call(report)
+        rescue StandardError => e
+          Bugsnag.configuration.warn("Error occurred in on_error callback: '#{e}'")
+          Bugsnag.configuration.warn("on_error callback stacktrace: #{e.backtrace.inspect}")
+        end
+
+        # If a callback returns false, we ignore the report and stop running callbacks
+        # Note that we explicitly check for 'false' so that callbacks don't need
+        # to return anything (i.e. can return 'nil') and we still continue
+        next unless should_continue == false
+
+        report.ignore!
+
+        break
+      end
+
+      @next_middleware.call(report)
+    end
+  end
+end

data/lib/bugsnag/report.rb

@@ -19,24 +19,87 @@ module Bugsnag
 
     CURRENT_PAYLOAD_VERSION = "4.0"
 
-    attr_reader   :unhandled
+    # Whether this report is for a handled or unhandled error
+    # @return [Boolean]
+    attr_reader :unhandled
+
+    # Your Integration API Key
+    # @see Configuration#api_key
+    # @return [String, nil]
     attr_accessor :api_key
+
+    # The type of application executing the current code
+    # @see Configuration#app_type
+    # @return [String, nil]
     attr_accessor :app_type
+
+    # The current version of your application
+    # @return [String, nil]
     attr_accessor :app_version
+
+    # The list of breadcrumbs attached to this report
+    # @return [Array<Breadcrumb>]
     attr_accessor :breadcrumbs
+
+    # @api private
+    # @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
+    # @return [Array<Hash>]
     attr_accessor :exceptions
+
+    # @see Configuration#hostname
+    # @return [String]
     attr_accessor :hostname
+
+    # @api private
+    # @see Configuration#runtime_versions
+    # @return [Hash{String => String}]
     attr_accessor :runtime_versions
+
+    # All errors with the same grouping hash will be grouped in the Bugsnag app
+    # @return [String]
     attr_accessor :grouping_hash
+
+    # Arbitrary metadata attached to this report
+    # @return [Hash]
     attr_accessor :meta_data
+
+    # The raw Exception instances for this report
+    # @see #exceptions
+    # @return [Array<Exception>]
     attr_accessor :raw_exceptions
+
+    # The current stage of the release process, e.g. 'development', production'
+    # @see Configuration#release_stage
+    # @return [String, nil]
     attr_accessor :release_stage
+
+    # The session that active when this report was generated
+    # @see SessionTracker#get_current_session
+    # @return [Hash]
     attr_accessor :session
+
+    # The severity of this report, e.g. 'error', 'warning'
+    # @return [String]
     attr_accessor :severity
+
+    # @api private
+    # @return [Hash]
     attr_accessor :severity_reason
+
+    # The current user when this report was generated
+    # @return [Hash]
     attr_accessor :user
 
     ##
@@ -66,6 +129,12 @@ module Bugsnag
 
     ##
     # Add a new metadata tab to this notification.
+    #
+    # @param name [String, #to_s] The name of the tab to add
+    # @param value [Hash, Object] The value to add to the tab. If the tab already
+    #   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]
     def add_tab(name, value)
       return if name.nil?
 
@@ -81,6 +150,9 @@ module Bugsnag
 
     ##
     # Removes a metadata tab from this notification.
+    #
+    # @param name [String]
+    # @return [void]
     def remove_tab(name)
       return if name.nil?
 
@@ -89,6 +161,8 @@ module Bugsnag
 
     ##
     # Builds and returns the exception payload for this notification.
+    #
+    # @return [Hash]
     def as_json
       # Build the payload's exception event
       payload_event = {
@@ -97,6 +171,7 @@ module Bugsnag
           releaseStage: release_stage,
           type: app_type
         },
+        breadcrumbs: breadcrumbs.map(&:to_h),
         context: context,
         device: {
           hostname: hostname,
@@ -104,6 +179,7 @@ module Bugsnag
         },
         exceptions: exceptions,
         groupingHash: grouping_hash,
+        metaData: meta_data,
         session: session,
         severity: severity,
         severityReason: severity_reason,
@@ -111,19 +187,7 @@ module Bugsnag
         user: user
       }
 
-      # cleanup character encodings
-      payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
-
-      # filter out sensitive values in (and cleanup encodings) metaData
-      filter_cleaner = Bugsnag::Cleaner.new(configuration.meta_data_filters)
-      payload_event[:metaData] = filter_cleaner.clean_object(meta_data)
-      payload_event[:breadcrumbs] = breadcrumbs.map do |breadcrumb|
-        breadcrumb_hash = breadcrumb.to_h
-        breadcrumb_hash[:metaData] = filter_cleaner.clean_object(breadcrumb_hash[:metaData])
-        breadcrumb_hash
-      end
-
-      payload_event.reject! {|k,v| v.nil? }
+      payload_event.reject! {|k, v| v.nil? }
 
       # return the payload hash
       {
@@ -139,28 +203,36 @@ module Bugsnag
 
     ##
     # Returns the headers required for the notification.
+    #
+    # @return [Hash{String => String}]
     def headers
       {
         "Bugsnag-Api-Key" => api_key,
         "Bugsnag-Payload-Version" => CURRENT_PAYLOAD_VERSION,
-        "Bugsnag-Sent-At" => Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+        "Bugsnag-Sent-At" => Time.now.utc.iso8601(3)
       }
     end
 
     ##
     # Whether this report should be ignored and not sent.
+    #
+    # @return [Boolean]
     def ignore?
       @should_ignore
     end
 
     ##
     # Data set on the configuration to be attached to every error notification.
+    #
+    # @return [Hash]
     def request_data
       configuration.request_data
     end
 
     ##
     # Tells the client this report should not be sent.
+    #
+    # @return [void]
     def ignore!
       @should_ignore = true
     end
@@ -192,7 +264,7 @@ module Bugsnag
         {
           errorClass: error_class(exception),
           message: exception.message,
-          stacktrace: Stacktrace.new(exception.backtrace, configuration).to_a
+          stacktrace: Stacktrace.process(exception.backtrace, configuration)
         }
       end
     end