bugsnag 6.14.0 → 6.19.0

data/lib/bugsnag/helpers.rb

@@ -4,7 +4,7 @@ require 'json'
 
 
 module Bugsnag
-  module Helpers
+  module Helpers # rubocop:todo Metrics/ModuleLength
     MAX_STRING_LENGTH = 3072
     MAX_PAYLOAD_LENGTH = 512000
     MAX_ARRAY_LENGTH = 80
@@ -19,8 +19,12 @@ module Bugsnag
 
       return value unless payload_too_long?(value)
 
+      # Truncate exception messages
+      reduced_value = truncate_exception_messages(value)
+      return reduced_value unless payload_too_long?(reduced_value)
+
       # Trim metadata
-      reduced_value = trim_metadata(value)
+      reduced_value = trim_metadata(reduced_value)
       return reduced_value unless payload_too_long?(reduced_value)
 
       # Trim code from stacktrace
@@ -71,6 +75,15 @@ module Bugsnag
 
     TRUNCATION_INFO = '[TRUNCATED]'
 
+    ##
+    # Truncate exception messages
+    def self.truncate_exception_messages(payload)
+      extract_exception(payload) do |exception|
+        exception[:message] = trim_as_string(exception[:message])
+      end
+      payload
+    end
+
     ##
     # Remove all code from stacktraces
     def self.trim_stacktrace_code(payload)
@@ -94,11 +107,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_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 = {
@@ -129,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
@@ -182,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