bugsnag 4.2.1 → 6.27.1

data/lib/bugsnag/integrations/mongo.rb

@@ -0,0 +1,133 @@
+require 'mongo'
+
+module Bugsnag
+  ##
+  # Subscribes to, and creates breadcrumbs from, mongo_ruby_driver events
+  #
+  # @api private
+  class MongoBreadcrumbSubscriber
+    MONGO_MESSAGE_PREFIX = "Mongo query "
+    MONGO_EVENT_PREFIX = "mongo."
+    MONGO_COMMAND_KEY = :bugsnag_mongo_commands
+    MAX_FILTER_DEPTH = 5
+
+    ##
+    # Listens to the 'started' event, storing the command for later usage
+    #
+    # @param event [Mongo::Event::Base] the mongo_ruby_driver generated event
+    def started(event)
+      leave_command(event)
+    end
+
+    ##
+    # Listens to the 'succeeded' event, leaving a breadcrumb
+    #
+    # @param event [Mongo::Event::Base] the mongo_ruby_driver generated event
+    def succeeded(event)
+      leave_mongo_breadcrumb("succeeded", event)
+    end
+
+    ##
+    # Listens to the 'failed' event, leaving a breadcrumb
+    #
+    # @param event [Mongo::Event::Base] the mongo_ruby_driver generated event
+    def failed(event)
+      leave_mongo_breadcrumb("failed", event)
+    end
+
+    private
+
+    ##
+    # Generates breadcrumb data from an event
+    #
+    # @param event_name [String] the type of event
+    # @param event [Mongo::Event::Base] the mongo_ruby_driver generated event
+    def leave_mongo_breadcrumb(event_name, event)
+      message = MONGO_MESSAGE_PREFIX + event_name
+      meta_data = {
+        :event_name => MONGO_EVENT_PREFIX + event_name,
+        :command_name => event.command_name,
+        :database_name => event.database_name,
+        :operation_id => event.operation_id,
+        :request_id => event.request_id,
+        :duration => event.duration
+      }
+      if (command = pop_command(event.request_id))
+        collection_key = event.command_name == "getMore" ? "collection" : event.command_name
+        meta_data[:collection] = command[collection_key]
+        unless command["filter"].nil?
+          filter = sanitize_filter_hash(command["filter"])
+          meta_data[:filter] = JSON.dump(filter)
+        end
+      end
+      meta_data[:message] = event.message if defined?(event.message)
+
+      Bugsnag.leave_breadcrumb(message, meta_data, Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE, :auto)
+    end
+
+    ##
+    # Removes values from filter hashes, replacing them with '?'
+    #
+    # @param filter_hash [Hash] the filter hash for the mongo transaction
+    # @param depth [Integer] the current filter depth
+    #
+    # @return [Hash] the filtered hash
+    def sanitize_filter_hash(filter_hash, depth = 0)
+      filter_hash.each_with_object({}) do |(key, value), output|
+        output[key] = sanitize_filter_value(value, depth)
+      end
+    end
+
+    ##
+    # Transforms a value element into a useful, redacted, version
+    #
+    # @param value [Object] the filter value
+    # @param depth [Integer] the current filter depth
+    #
+    # @return [Array, Hash, String] the sanitized value
+    def sanitize_filter_value(value, depth)
+      depth += 1
+      if depth >= MAX_FILTER_DEPTH
+        '[MAX_FILTER_DEPTH_REACHED]'
+      elsif value.is_a?(Array)
+        value.map { |array_value| sanitize_filter_value(array_value, depth) }
+      elsif value.is_a?(Hash)
+        sanitize_filter_hash(value, depth)
+      else
+        '?'
+      end
+    end
+
+    ##
+    # Stores the mongo command in the request data by the request_id
+    #
+    # @param event [Mongo::Event::Base] the mongo_ruby_driver generated event
+    def leave_command(event)
+      event_commands[event.request_id] = event.command
+    end
+
+    ##
+    # Removes and retrieves a stored command from the request data
+    #
+    # @param request_id [String] the id of the mongo_ruby_driver event
+    #
+    # @return [Hash, nil] the requested command, or nil if not found
+    def pop_command(request_id)
+      event_commands.delete(request_id)
+    end
+
+    ##
+    # Provides access to a thread-based mongo event command hash
+    #
+    # @return [Hash] the hash of mongo event commands
+    def event_commands
+      Bugsnag.configuration.request_data[MONGO_COMMAND_KEY] ||= {}
+    end
+  end
+end
+
+if defined?(Mongo::Monitoring)
+  ##
+  # Add the subscriber to the global Mongo monitoring object
+  Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, Bugsnag::MongoBreadcrumbSubscriber.new)
+end

data/lib/bugsnag/integrations/que.rb

@@ -0,0 +1,53 @@
+require 'que'
+if defined?(::Que)
+  handler = proc do |error, job|
+    begin
+      job &&= job.dup # Make sure the original job object is not mutated.
+
+      Bugsnag.notify(error, true) do |report|
+        if job
+          job[:error_count] += 1
+
+          # If the job was scheduled using ActiveJob then unwrap the job details for clarity:
+          if job[:job_class] == "ActiveJob::QueueAdapters::QueAdapter::JobWrapper"
+            wrapped_job = job[:args].last
+            wrapped_job = wrapped_job.each_with_object({}) { |(k, v), result| result[k.to_sym] = v } # Symbolize keys
+
+            # Align key names with keys in `job`
+            wrapped_job[:queue] = wrapped_job.delete(:queue_name)
+            wrapped_job[:args]  = wrapped_job.delete(:arguments)
+
+            job.merge!(wrapper_job_class: job[:job_class], wrapper_job_id: job[:job_id]).merge!(wrapped_job)
+          end
+        end
+
+        report.add_tab(:job, job)
+        report.severity = 'error'
+        report.severity_reason = {
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+          :attributes => {
+            :framework => 'Que'
+          }
+        }
+      end
+    rescue => e
+      # Que supresses errors raised by its error handler to avoid killing the worker. Log them somewhere:
+      Bugsnag.configuration.warn("Failed to notify Bugsnag of error in Que job (#{e.class}): #{e.message} \n#{e.backtrace[0..9].join("\n")}")
+      raise
+    end
+  end
+
+  Bugsnag.configuration.detected_app_type = "que"
+
+  if defined?(::Que::Version)
+    Bugsnag.configuration.runtime_versions["que"] = ::Que::Version
+  elsif defined?(::Que::VERSION)
+    Bugsnag.configuration.runtime_versions["que"] = ::Que::VERSION
+  end
+
+  if Que.respond_to?(:error_notifier=)
+    Que.error_notifier = handler
+  elsif Que.respond_to?(:error_handler=)
+    Que.error_handler = handler
+  end
+end

data/lib/bugsnag/integrations/rack.rb

@@ -0,0 +1,83 @@
+module Bugsnag
+  ##
+  # Automatically captures and adds Rack request information to error reports
+  class Rack
+
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Rack"
+    }
+
+    def initialize(app)
+      @app = app
+
+      # Configure bugsnag rack defaults
+      Bugsnag.configure do |config|
+        # Try to set the release_stage automatically if it hasn't already been set
+        config.release_stage ||= ENV["RACK_ENV"] if ENV["RACK_ENV"]
+
+        # Try to set the project_root if it hasn't already been set, or show a warning if we can't
+        unless config.project_root && !config.project_root.to_s.empty?
+          if defined?(settings)
+            config.project_root = settings.root
+          else
+            config.warn("You should set your app's project_root (see https://docs.bugsnag.com/platforms/ruby/rails/configuration-options/#project_root).")
+          end
+        end
+
+        # Hook up rack-based notification middlewares
+        config.internal_middleware.insert_before(Bugsnag::Middleware::Rails3Request, Bugsnag::Middleware::RackRequest) if defined?(::Rack)
+        config.internal_middleware.use(Bugsnag::Middleware::WardenUser) if defined?(Warden)
+        config.internal_middleware.use(Bugsnag::Middleware::ClearanceUser) if defined?(Clearance)
+
+        # Set environment data for payload
+        # 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
+    end
+
+    ##
+    # Wraps a call to the application with error capturing
+    def call(env)
+      # Set the request data for bugsnag middleware to use
+      Bugsnag.configuration.set_request_data(:rack_env, env)
+      if Bugsnag.configuration.auto_capture_sessions
+        Bugsnag.start_session
+      end
+
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        # Notify bugsnag of rack exceptions
+        Bugsnag.notify(raised, true) do |report|
+          report.severity = "error"
+          report.severity_reason = {
+            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+            :attributes => Bugsnag::Rack::FRAMEWORK_ATTRIBUTES
+          }
+        end
+
+        # Re-raise the exception
+        raise
+      end
+
+      # Notify bugsnag of rack exceptions
+      if env["rack.exception"]
+        Bugsnag.notify(env["rack.exception"], true) do |report|
+          report.severity = "error"
+          report.severity_reason = {
+            :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+            :attributes => FRAMEWORK_ATTRIBUTES
+          }
+        end
+      end
+
+      response
+    ensure
+      # Clear per-request data after processing the each request
+      Bugsnag.configuration.clear_request_data
+    end
+  end
+end

data/lib/bugsnag/integrations/rails/active_job.rb

@@ -0,0 +1,100 @@
+module Bugsnag::Rails
+  module ActiveJob
+    SEVERITY = 'error'
+    SEVERITY_REASON = {
+      type: Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+      attributes: { framework: 'Active Job' }
+    }
+
+    EXISTING_INTEGRATIONS = Set[
+      'ActiveJob::QueueAdapters::DelayedJobAdapter',
+      'ActiveJob::QueueAdapters::QueAdapter',
+      'ActiveJob::QueueAdapters::ResqueAdapter',
+      'ActiveJob::QueueAdapters::ShoryukenAdapter',
+      'ActiveJob::QueueAdapters::SidekiqAdapter'
+    ]
+
+    INLINE_ADAPTER = 'ActiveJob::QueueAdapters::InlineAdapter'
+
+    # these methods were added after the first Active Job release so
+    # may not be present, depending on the Rails version
+    MAYBE_MISSING_METHODS = [
+      :provider_job_id,
+      :priority,
+      :executions,
+      :enqueued_at,
+      :timezone
+    ]
+
+    def self.included(base)
+      base.class_eval do
+        around_perform do |job, block|
+          adapter = _bugsnag_get_adapter_name(job)
+
+          # if we have an integration for this queue adapter already then we should
+          # leave this job alone or we'll end up with duplicate metadata
+          next block.call if EXISTING_INTEGRATIONS.include?(adapter)
+
+          Bugsnag.configuration.detected_app_type = 'active job'
+
+          begin
+            Bugsnag.configuration.set_request_data(:active_job, _bugsnag_extract_metadata(job))
+
+            block.call
+          rescue Exception => e
+            Bugsnag.notify(e, true) do |report|
+              report.severity = SEVERITY
+              report.severity_reason = SEVERITY_REASON
+            end
+
+            # when using the "inline" adapter the job is run immediately, which
+            # will result in our Rack integration catching the re-raised error
+            # and reporting it a second time if it's run in a web request
+            if adapter == INLINE_ADAPTER
+              e.instance_eval do
+                def skip_bugsnag
+                  true
+                end
+              end
+            end
+
+            raise
+          ensure
+            Bugsnag.configuration.clear_request_data
+          end
+        end
+      end
+    end
+
+    private
+
+    def _bugsnag_get_adapter_name(job)
+      adapter = job.class.queue_adapter
+
+      # in Rails 4 queue adapters were references to a class. In Rails 5+
+      # they are an instance of that class instead
+      return adapter.name if adapter.is_a?(Class)
+
+      adapter.class.name
+    end
+
+    def _bugsnag_extract_metadata(job)
+      metadata = {
+        job_id: job.job_id,
+        job_name: job.class.name,
+        queue: job.queue_name,
+        arguments: job.arguments,
+        locale: job.locale
+      }
+
+      MAYBE_MISSING_METHODS.each do |method_name|
+        next unless job.respond_to?(method_name)
+
+        metadata[method_name] = job.send(method_name)
+      end
+
+      metadata.compact!
+      metadata
+    end
+  end
+end

data/lib/bugsnag/{rails → integrations/rails}/active_record_rescue.rb

@@ -1,6 +1,9 @@
 module Bugsnag::Rails
   module ActiveRecordRescue
     KINDS = [:commit, :rollback].freeze
+    FRAMEWORK_ATTRIBUTES = {
+      :framework => "Rails"
+    }
 
     def run_callbacks(kind, *args, &block)
       if KINDS.include?(kind)
@@ -8,7 +11,13 @@ module Bugsnag::Rails
           super
         rescue StandardError => exception
           # This exception will NOT be escalated, so notify it here.
-          Bugsnag.auto_notify(exception)
+          Bugsnag.notify(exception, true) do |report|
+            report.severity = "error"
+            report.severity_reason = {
+              :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
+              :attributes => FRAMEWORK_ATTRIBUTES
+            }
+          end
           raise
         end
       else

data/lib/bugsnag/{rails → integrations/rails}/controller_methods.rb

@@ -5,15 +5,12 @@ module Bugsnag::Rails
     end
 
     module ClassMethods
+
       private
       def before_bugsnag_notify(*methods, &block)
         _add_bugsnag_notify_callback(:before_callbacks, *methods, &block)
       end
 
-      def after_bugsnag_notify(*methods, &block)
-        _add_bugsnag_notify_callback(:after_callbacks, *methods, &block)
-      end
-
       def _add_bugsnag_notify_callback(callback_key, *methods, &block)
         options = methods.last.is_a?(Hash) ? methods.pop : {}
 
@@ -40,10 +37,5 @@ module Bugsnag::Rails
         end
       end
     end
-
-    private
-    def notify_bugsnag(exception, custom_data=nil)
-      Bugsnag.notify(exception, custom_data)
-    end
   end
 end

data/lib/bugsnag/integrations/rails/rails_breadcrumbs.rb

@@ -0,0 +1,115 @@
+module Bugsnag::Rails
+  DEFAULT_RAILS_BREADCRUMBS = [
+    {
+      :id => "perform_action.action_cable",
+      :message => "Perform ActionCable",
+      :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :channel_class,
+        :action
+      ]
+    },
+    {
+      :id => "perform_start.active_job",
+      :message => "Start perform ActiveJob",
+      :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
+      :allowed_data => []
+    },
+    {
+      :id => "cache_read.active_support",
+      :message => "Read cache",
+      :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :hit,
+        :super_operation
+      ]
+    },
+    {
+      :id => "cache_fetch_hit.active_support",
+      :message => "Fetch cache hit",
+      :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
+      :allowed_data => []
+    },
+    {
+      :id => "sql.active_record",
+      :message => "ActiveRecord SQL query",
+      :type => Bugsnag::Breadcrumbs::PROCESS_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :name,
+        # :connection_id is no longer provided in Rails 6.1+ but we can get it
+        # from the :connection key of the event instead
+        :connection_id,
+        :cached
+      ]
+    },
+    {
+      :id => "start_processing.action_controller",
+      :message => "Controller started processing",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :controller,
+        :action,
+        :method,
+        :path
+      ]
+    },
+    {
+      :id => "process_action.action_controller",
+      :message => "Controller action processed",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :controller,
+        :action,
+        :method,
+        :status,
+        :db_runtime
+      ]
+    },
+    {
+      :id => "redirect_to.action_controller",
+      :message => "Controller redirect",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :status,
+        :location
+      ]
+    },
+    {
+      :id => "halted_callback.action_controller",
+      :message => "Controller halted via callback",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :filter
+      ]
+    },
+    {
+      :id => "render_template.action_view",
+      :message => "ActionView template rendered",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :identifier,
+        :layout
+      ]
+    },
+    {
+      :id => "render_partial.action_view",
+      :message => "ActionView partial rendered",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :identifier
+      ]
+    },
+    {
+      :id => "deliver.action_mailer",
+      :message => "ActionMail delivered",
+      :type => Bugsnag::Breadcrumbs::REQUEST_BREADCRUMB_TYPE,
+      :allowed_data => [
+        :mailer,
+        :message_id,
+        :from,
+        :date,
+        :perform_deliveries
+      ]
+    }
+  ]
+end

data/lib/bugsnag/integrations/railtie.rb

@@ -0,0 +1,153 @@
+# Rails 3.x hooks
+
+require "rails"
+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
+
+        case event[:id]
+        when "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
+
+        when "start_processing.action_controller"
+          filtered_data[:path] = Bugsnag.cleaner.clean_url(data[:path]) if data.key?(:path)
+
+        when "redirect_to.action_controller"
+          filtered_data[:location] = Bugsnag.cleaner.clean_url(data[:location]) if data.key?(:location)
+        end
+
+        Bugsnag.leave_breadcrumb(
+          event[:message],
+          filtered_data,
+          event[:type],
+          :auto
+        )
+      end
+    end
+
+    ##
+    # Do we need to rescue (& notify) in Active Record callbacks?
+    #
+    # On Rails versions < 4.2, Rails did not raise errors in AR callbacks
+    # On Rails version 4.2, a config option was added to control this
+    # On Rails version 5.0, the config option was removed and errors in callbacks
+    # always bubble up
+    #
+    # @api private
+    def self.rescue_in_active_record_callbacks?
+      # Rails 5+ will re-raise errors in callbacks, so we don't need to rescue them
+      return false if ::Rails::VERSION::MAJOR > 4
+
+      # before 4.2, errors were always swallowed, so we need to rescue them
+      return true if ::Rails::VERSION::MAJOR < 4
+
+      # a config option was added in 4.2 to control this, but won't exist in 4.0 & 4.1
+      return true unless ActiveRecord::Base.respond_to?(:raise_in_transactional_callbacks)
+
+      # if the config option is false, we need to rescue and notify
+      ActiveRecord::Base.raise_in_transactional_callbacks == false
+    end
+
+    rake_tasks do
+      require "bugsnag/integrations/rake"
+      load "bugsnag/tasks/bugsnag.rake"
+    end
+
+    config.before_initialize do
+      # Configure bugsnag rails defaults
+      # Skipping API key validation as the key may be set later in an
+      # initializer. If not, the key will be validated in after_initialize.
+      Bugsnag.configure(false) do |config|
+        config.logger = ::Rails.logger
+        config.release_stage ||= ::Rails.env.to_s
+        config.project_root = ::Rails.root.to_s
+        config.internal_middleware.use(Bugsnag::Middleware::Rails3Request)
+        config.runtime_versions["rails"] = ::Rails::VERSION::STRING
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        require "bugsnag/integrations/rails/controller_methods"
+        include Bugsnag::Rails::ControllerMethods
+      end
+
+      ActiveSupport.on_load(:active_record) do
+        if Bugsnag::Railtie.rescue_in_active_record_callbacks?
+          require "bugsnag/integrations/rails/active_record_rescue"
+          include Bugsnag::Rails::ActiveRecordRescue
+        end
+      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
+      # 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
+    # may set filter_parameters which will be picked up by Bugsnag.
+    config.after_initialize do
+      Bugsnag.configure do |config|
+        config.meta_data_filters += ::Rails.configuration.filter_parameters.map do |filter|
+          case filter
+          when String, Symbol
+            /\A#{filter}\z/
+          else
+            filter
+          end
+        end
+      end
+    end
+
+    initializer "bugsnag.use_rack_middleware" do |app|
+      begin
+        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
+  end
+end