airbrake 10.0.2 → 13.0.4

data/lib/airbrake/rails/railtie.rb

@@ -6,34 +6,9 @@ module Airbrake
     # 3.2+ apps). It makes Airbrake Ruby work with Rails and report errors
     # occurring in the application automatically.
     class Railtie < ::Rails::Railtie
-      initializer('airbrake.middleware', after: :load_config_initializers) do |app|
-        # Since Rails 3.2 the ActionDispatch::DebugExceptions middleware is
-        # responsible for logging exceptions and showing a debugging page in
-        # case the request is local. We want to insert our middleware after
-        # DebugExceptions, so we don't notify Airbrake about local requests.
-
-        if ::Rails.version.to_i >= 5
-          # Avoid the warning about deprecated strings.
-          # Insert after DebugExceptions, since ConnectionManagement doesn't
-          # exist in Rails 5 anymore.
-          app.config.middleware.insert_after(
-            ActionDispatch::DebugExceptions,
-            Airbrake::Rack::Middleware,
-          )
-        elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionManagement)
-          # Insert after ConnectionManagement to avoid DB connection leakage:
-          # https://github.com/airbrake/airbrake/pull/568
-          app.config.middleware.insert_after(
-            ::ActiveRecord::ConnectionAdapters::ConnectionManagement,
-            'Airbrake::Rack::Middleware',
-          )
-        else
-          # Insert after DebugExceptions for apps without ActiveRecord.
-          app.config.middleware.insert_after(
-            ActionDispatch::DebugExceptions,
-            'Airbrake::Rack::Middleware',
-          )
-        end
+      initializer('airbrake.middleware') do |app|
+        require 'airbrake/rails/railties/middleware_tie'
+        Railties::MiddlewareTie.new(app).call
       end
 
       rake_tasks do
@@ -44,81 +19,14 @@ module Airbrake
         require 'airbrake/rake/tasks'
       end
 
-      # rubocop:disable Metrics/BlockLength
       initializer('airbrake.action_controller') do
-        ActiveSupport.on_load(:action_controller, run_once: true) do
-          # Patches ActionController with methods that allow us to retrieve
-          # interesting request data. Appends that information to notices.
-          require 'airbrake/rails/action_controller'
-          include Airbrake::Rails::ActionController
-
-          if Airbrake::Config.instance.performance_stats
-            # Cache route information for the duration of the request.
-            require 'airbrake/rails/action_controller_route_subscriber'
-            ActiveSupport::Notifications.subscribe(
-              'start_processing.action_controller',
-              Airbrake::Rails::ActionControllerRouteSubscriber.new,
-            )
-
-            # Send route stats.
-            require 'airbrake/rails/action_controller_notify_subscriber'
-            ActiveSupport::Notifications.subscribe(
-              'process_action.action_controller',
-              Airbrake::Rails::ActionControllerNotifySubscriber.new,
-            )
-
-            # Send performance breakdown: where a request spends its time.
-            require 'airbrake/rails/action_controller_performance_breakdown_subscriber'
-            ActiveSupport::Notifications.subscribe(
-              'process_action.action_controller',
-              Airbrake::Rails::ActionControllerPerformanceBreakdownSubscriber.new,
-            )
-
-            require 'airbrake/rails/net_http' if defined?(Net) && defined?(Net::HTTP)
-
-            if defined?(Curl) && defined?(Curl::CURB_VERSION)
-              require 'airbrake/rails/curb'
-            end
-
-            require 'airbrake/rails/http' if defined?(HTTP) && defined?(HTTP::Client)
-            require 'airbrake/rails/http_client' if defined?(HTTPClient)
-            require 'airbrake/rails/typhoeus' if defined?(Typhoeus)
-
-            if defined?(Excon)
-              require 'airbrake/rails/excon_subscriber'
-              ActiveSupport::Notifications.subscribe(/excon/, Airbrake::Rails::Excon.new)
-              ::Excon.defaults[:instrumentor] = ActiveSupport::Notifications
-            end
-          end
-        end
+        require 'airbrake/rails/railties/action_controller_tie'
+        Railties::ActionControllerTie.new.call
       end
-      # rubocop:enable Metrics/BlockLength
 
       initializer('airbrake.active_record') do
-        ActiveSupport.on_load(:active_record, run_once: true) do
-          # Reports exceptions occurring in some bugged ActiveRecord callbacks.
-          # Applicable only to the versions of Rails lower than 4.2.
-          if defined?(::Rails) &&
-             Gem::Version.new(::Rails.version) <= Gem::Version.new('4.2')
-            require 'airbrake/rails/active_record'
-            include Airbrake::Rails::ActiveRecord
-          end
-
-          if defined?(ActiveRecord) && Airbrake::Config.instance.query_stats
-            # Send SQL queries.
-            require 'airbrake/rails/active_record_subscriber'
-            ActiveSupport::Notifications.subscribe(
-              'sql.active_record', Airbrake::Rails::ActiveRecordSubscriber.new
-            )
-
-            # Filter out parameters from SQL body.
-            Airbrake.add_performance_filter(
-              Airbrake::Filters::SqlFilter.new(
-                ::ActiveRecord::Base.connection_config[:adapter],
-              ),
-            )
-          end
-        end
+        require 'airbrake/rails/railties/active_record_tie'
+        Railties::ActiveRecordTie.new.call
       end
 
       initializer('airbrake.active_job') do

data/lib/airbrake/rails/railties/action_controller_tie.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/action_controller'
+require 'airbrake/rails/action_controller_route_subscriber'
+require 'airbrake/rails/action_controller_notify_subscriber'
+require 'airbrake/rails/action_controller_performance_breakdown_subscriber'
+
+module Airbrake
+  module Rails
+    module Railties
+      # Ties Airbrake APM (routes) and HTTP clients with Rails.
+      #
+      # @api private
+      # @since v13.0.1
+      class ActionControllerTie
+        def initialize
+          @route_subscriber = Airbrake::Rails::ActionControllerRouteSubscriber.new
+          @notify_subscriber = Airbrake::Rails::ActionControllerNotifySubscriber.new
+          @performance_breakdown_subscriber =
+            Airbrake::Rails::ActionControllerPerformanceBreakdownSubscriber.new
+        end
+
+        def call
+          ActiveSupport.on_load(:action_controller, run_once: true, yield: self) do
+            # Patches ActionController with methods that allow us to retrieve
+            # interesting request data. Appends that information to notices.
+            ::ActionController::Base.include(Airbrake::Rails::ActionController)
+
+            tie_routes_apm
+            tie_http_integrations
+          end
+        end
+
+        private
+
+        def tie_routes_apm
+          [
+            # Cache route information for the duration of the request.
+            ['start_processing.action_controller', @route_subscriber],
+
+            # Send route stats.
+            ['process_action.action_controller', @notify_subscriber],
+
+            # Send performance breakdown: where a request spends its time.
+            ['process_action.action_controller', @performance_breakdown_subscriber],
+          ].each do |(event, callback)|
+            ActiveSupport::Notifications.subscribe(event, callback)
+          end
+        end
+
+        def tie_http_integrations
+          tie_net_http
+          tie_curl
+          tie_http
+          tie_http_client
+          tie_typhoeus
+          tie_excon
+        end
+
+        def tie_net_http
+          require 'airbrake/rails/net_http' if defined?(Net) && defined?(Net::HTTP)
+        end
+
+        def tie_curl
+          require 'airbrake/rails/curb' if defined?(Curl) && defined?(Curl::CURB_VERSION)
+        end
+
+        def tie_http
+          require 'airbrake/rails/http' if defined?(HTTP) && defined?(HTTP::Client)
+        end
+
+        def tie_http_client
+          require 'airbrake/rails/http_client' if defined?(HTTPClient)
+        end
+
+        def tie_typhoeus
+          require 'airbrake/rails/typhoeus' if defined?(Typhoeus)
+        end
+
+        def tie_excon
+          return unless defined?(Excon)
+
+          require 'airbrake/rails/excon_subscriber'
+          ActiveSupport::Notifications.subscribe(/excon/, Airbrake::Rails::Excon.new)
+          ::Excon.defaults[:instrumentor] = ActiveSupport::Notifications
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/railties/active_record_tie.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/active_record'
+require 'airbrake/rails/active_record_subscriber'
+
+module Airbrake
+  module Rails
+    module Railties
+      # Ties Airbrake APM (queries) with Rails.
+      #
+      # @api private
+      # @since v13.0.1
+      class ActiveRecordTie
+        def initialize
+          @active_record_subscriber = Airbrake::Rails::ActiveRecordSubscriber.new
+        end
+
+        def call
+          ActiveSupport.on_load(:active_record, run_once: true, yield: self) do
+            tie_activerecord_callback_fix
+            tie_activerecord_apm
+          end
+        end
+
+        private
+
+        def tie_activerecord_callback_fix
+          # Reports exceptions occurring in some bugged ActiveRecord callbacks.
+          # Applicable only to the versions of Rails lower than 4.2.
+          return unless defined?(::Rails)
+          return if Gem::Version.new(::Rails.version) > Gem::Version.new('4.2')
+
+          ActiveRecord::Base.include(Airbrake::Rails::ActiveRecord)
+        end
+
+        def tie_activerecord_apm
+          # Some Rails apps don't use ActiveRecord.
+          return unless defined?(::ActiveRecord)
+
+          # However, some dependencies might still require it, so we need an
+          # extra check. Apps that don't need ActiveRecord will likely have no
+          # AR configurations defined. We will skip APM integration in that
+          # case. See: https://github.com/airbrake/airbrake/issues/1222
+          configurations = ::ActiveRecord::Base.configurations
+          return unless configurations.any?
+
+          # Send SQL queries.
+          ActiveSupport::Notifications.subscribe(
+            'sql.active_record',
+            @active_record_subscriber,
+          )
+
+          # Filter out parameters from SQL body.
+          sql_filter = Airbrake::Filters::SqlFilter.new(
+            detect_activerecord_adapter(configurations),
+          )
+          Airbrake.add_performance_filter(sql_filter)
+        end
+
+        # Rails 6+ introduces the `configs_for` API instead of the deprecated
+        # `#[]`, so we need an updated call.
+        def detect_activerecord_adapter(configurations)
+          unless configurations.respond_to?(:configs_for)
+            return configurations[::Rails.env]['adapter']
+          end
+
+          cfg = configurations.configs_for(env_name: ::Rails.env).first
+          # Rails 7+ API : Rails 6 API.
+          cfg.respond_to?(:adapter) ? cfg.adapter : cfg.config['adapter']
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/railties/middleware_tie.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    module Railties
+      # Ties Airbrake Rails Middleware with Rails (error sending).
+      #
+      # Since Rails 3.2 the ActionDispatch::DebugExceptions middleware is
+      # responsible for logging exceptions and showing a debugging page in case
+      # the request is local. We want to insert our middleware after
+      # DebugExceptions, so we don't notify Airbrake about local requests.
+      #
+      # @api private
+      # @since v13.0.1
+      class MiddlewareTie
+        def initialize(app)
+          @app = app
+          @middleware = app.config.middleware
+        end
+
+        def call
+          return tie_rails_5_or_above if ::Rails.version.to_i >= 5
+
+          if defined?(::ActiveRecord::ConnectionAdapters::ConnectionManagement)
+            return tie_rails_4_or_below_with_active_record
+          end
+
+          tie_rails_4_or_below_without_active_record
+        end
+
+        private
+
+        # Avoid the warning about deprecated strings.
+        # Insert after DebugExceptions, since ConnectionManagement doesn't
+        # exist in Rails 5 anymore.
+        def tie_rails_5_or_above
+          @middleware.insert_after(
+            ActionDispatch::DebugExceptions,
+            Airbrake::Rack::Middleware,
+          )
+        end
+
+        # Insert after ConnectionManagement to avoid DB connection leakage:
+        # https://github.com/airbrake/airbrake/pull/568
+        def tie_rails_4_or_below_with_active_record
+          @middleware.insert_after(
+            ::ActiveRecord::ConnectionAdapters::ConnectionManagement,
+            'Airbrake::Rack::Middleware',
+          )
+        end
+
+        # Insert after DebugExceptions for apps without ActiveRecord.
+        def tie_rails_4_or_below_without_active_record
+          @middleware.insert_after(
+            ActionDispatch::DebugExceptions,
+            'Airbrake::Rack::Middleware',
+          )
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/typhoeus.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-module Typhoeus
-  # Monkey-patch to measure request timing.
-  class Request
-    alias run_without_airbrake run
-
-    def run
-      Airbrake::Rack.capture_timing(:http) do
-        run_without_airbrake
+module Airbrake
+  module Rails
+    # Allow measuring request timing.
+    module TyphoeusRequest
+      def run
+        Airbrake::Rack.capture_timing(:http) do
+          super
+        end
       end
     end
   end
 end
+
+Typhoeus::Request.prepend(Airbrake::Rails::TyphoeusRequest)

data/lib/airbrake/rails.rb

@@ -6,16 +6,14 @@ module Airbrake
   # Rails namespace holds all Rails-related functionality.
   module Rails
     def self.logger
+      # Rails.logger is not set in some Rake tasks such as
+      # 'airbrake:deploy'. In this case we use a sensible fallback.
+      level = (::Rails.logger ? ::Rails.logger.level : Logger::ERROR)
+
       if ENV['RAILS_LOG_TO_STDOUT'].present?
-        Logger.new(STDOUT, level: ::Rails.logger.level)
+        Logger.new($stdout, level: level)
       else
-        Logger.new(
-          ::Rails.root.join('log', 'airbrake.log'),
-
-          # Rails.logger is not set in some Rake tasks such as
-          # 'airbrake:deploy'. In this case we use a sensible fallback.
-          level: (::Rails.logger ? ::Rails.logger.level : Logger::ERROR),
-        )
+        Logger.new(::Rails.root.join('log', 'airbrake.log'), level: level)
       end
     end
   end

data/lib/airbrake/rake/tasks.rb

@@ -53,11 +53,11 @@ namespace :airbrake do
     raise Airbrake::Error, 'airbrake-ruby is not configured' unless Airbrake.configured?
 
     deploy_params = {
-      environment: ENV['ENVIRONMENT'],
-      username: ENV['USERNAME'],
-      revision: ENV['REVISION'],
-      repository: ENV['REPOSITORY'],
-      version: ENV['VERSION'],
+      environment: ENV.fetch('ENVIRONMENT', nil),
+      username: ENV.fetch('USERNAME', nil),
+      revision: ENV.fetch('REVISION', nil),
+      repository: ENV.fetch('REPOSITORY', nil),
+      version: ENV.fetch('VERSION', nil),
     }
     promise = Airbrake.notify_deploy(deploy_params)
     promise.then do
@@ -68,10 +68,10 @@ namespace :airbrake do
 
   desc 'Install a Heroku deploy hook to notify Airbrake of deploys'
   task :install_heroku_deploy_hook do
-    app = ENV['HEROKU_APP']
+    app = ENV.fetch('HEROKU_APP', nil)
 
     config = Bundler.with_clean_env do
-      `heroku config --shell#{ " --app #{app}" if app }`
+      `heroku config --shell#{" --app #{app}" if app}`
     end
 
     heroku_env = config.each_line.with_object({}) do |line, h|
@@ -85,11 +85,11 @@ namespace :airbrake do
 
     unless (env = heroku_env['RAILS_ENV'])
       env = 'production'
-      puts "Airbrake couldn't identify your app's environment, so the '#{env}'" \
-           " environment will be used."
+      puts "Airbrake couldn't identify your app's environment, " \
+           "so the '#{env}' environment will be used."
     end
 
-    unless (repo = ENV['REPOSITORY_URL'])
+    unless (repo = ENV.fetch('REPOSITORY_URL', nil))
       repo = `git remote get-url origin 2>/dev/null`.chomp
       if repo.empty?
         puts "Airbrake couldn't identify your app's repository."

data/lib/airbrake/rake.rb

@@ -5,61 +5,62 @@
 # See: https://goo.gl/ksn6PE
 Rake::TaskManager.record_task_metadata = true
 
-module Rake
-  # Redefine +Rake::Task#execute+, so it can report errors to Airbrake.
-  class Task
-    # Store the original method to use it later.
-    alias execute_without_airbrake execute
-
-    # A wrapper around the original +#execute+, that catches all errors and
-    # notifies Airbrake.
-    #
-    # rubocop:disable Lint/RescueException
-    def execute(args = nil)
-      execute_without_airbrake(args)
-    rescue Exception => ex
-      notify_airbrake(ex, args)
-      raise ex
-    end
-    # rubocop:enable Lint/RescueException
+module Airbrake
+  module Rake
+    # Redefine +Rake::Task#execute+, so it can report errors to Airbrake.
+    module Task
+      # A wrapper around the original +#execute+, that catches all errors and
+      # notifies Airbrake.
+      #
+      # rubocop:disable Lint/RescueException
+      def execute(args = nil)
+        super(args)
+      rescue Exception => ex
+        notify_airbrake(ex, args)
+        raise ex
+      end
+      # rubocop:enable Lint/RescueException
 
-    private
+      private
 
-    def notify_airbrake(exception, args)
-      notice = Airbrake.build_notice(exception)
-      notice[:context][:component] = 'rake'
-      notice[:context][:action] = name
-      notice[:params].merge!(
-        rake_task: task_info,
-        execute_args: args,
-        argv: ARGV.join(' '),
-      )
+      def notify_airbrake(exception, args)
+        notice = Airbrake.build_notice(exception)
+        notice[:context][:component] = 'rake'
+        notice[:context][:action] = name
+        notice[:params].merge!(
+          rake_task: task_info,
+          execute_args: args,
+          argv: ARGV.join(' '),
+        )
 
-      Airbrake.notify_sync(notice)
-    end
+        Airbrake.notify_sync(notice)
+      end
 
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
-    def task_info
-      info = {}
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+      def task_info
+        info = {}
 
-      info[:name] = name
-      info[:timestamp] = timestamp.to_s
-      info[:investigation] = investigation
+        info[:name] = name
+        info[:timestamp] = timestamp.to_s
+        info[:investigation] = investigation
 
-      info[:full_comment] = full_comment if full_comment
-      info[:arg_names] = arg_names if arg_names.any?
-      info[:arg_description] = arg_description if arg_description
-      info[:locations] = locations if locations.any?
-      info[:sources] = sources if sources.any?
+        info[:full_comment] = full_comment if full_comment
+        info[:arg_names] = arg_names if arg_names.any?
+        info[:arg_description] = arg_description if arg_description
+        info[:locations] = locations if locations.any?
+        info[:sources] = sources if sources.any?
 
-      if prerequisite_tasks.any?
-        info[:prerequisite_tasks] = prerequisite_tasks.map do |p|
-          p.__send__(:task_info)
+        if prerequisite_tasks.any?
+          info[:prerequisite_tasks] = prerequisite_tasks.map do |p|
+            p.__send__(:task_info)
+          end
         end
-      end
 
-      info
+        info
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
   end
 end
+
+Rake::Task.prepend(Airbrake::Rake::Task)

data/lib/airbrake/resque.rb

@@ -30,32 +30,33 @@ module Resque
   end
 end
 
-module Resque
-  # Measures elapsed time of a job and notifies Airbrake of the execution
-  # status.
-  #
-  # @since v9.6.0
-  class Job
-    # Store the original method to use it later.
-    alias perform_without_airbrake perform
-
-    def perform
-      timing = Airbrake::Benchmark.measure do
-        perform_without_airbrake
+module Airbrake
+  module Resque
+    # Measures elapsed time of a job and notifies Airbrake of the execution
+    # status.
+    #
+    # @since v9.6.0
+    module Job
+      def perform
+        timing = Airbrake::Benchmark.measure do
+          super
+        end
+      rescue StandardError => exception
+        Airbrake.notify_queue_sync(
+          queue: payload['class'],
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Airbrake.notify_queue_sync(
+          queue: payload['class'],
+          error_count: 0,
+          timing: timing,
+        )
       end
-    rescue StandardError => exception
-      Airbrake.notify_queue_sync(
-        queue: payload['class'],
-        error_count: 1,
-        timing: 0.01,
-      )
-      raise exception
-    else
-      Airbrake.notify_queue_sync(
-        queue: payload['class'],
-        error_count: 0,
-        timing: timing,
-      )
     end
   end
 end
+
+Resque::Job.prepend(Airbrake::Resque::Job)

data/lib/airbrake/shoryuken.rb

@@ -5,10 +5,8 @@ module Airbrake
     # Provides integration with Shoryuken.
     class ErrorHandler
       # rubocop:disable Lint/RescueException
-      def call(worker, queue, _sqs_msg, body)
-        timing = Airbrake::Benchmark.measure do
-          yield
-        end
+      def call(worker, queue, _sqs_msg, body, &block)
+        timing = Airbrake::Benchmark.measure(&block)
       rescue Exception => exception
         notify_airbrake(exception, worker, queue, body)
         Airbrake.notify_queue(

data/lib/airbrake/sidekiq/retryable_jobs_filter.rb

@@ -6,17 +6,20 @@ module Airbrake
     # by Sidekiq
     # @since v7.3.0
     class RetryableJobsFilter
-      if Gem::Version.new(::Sidekiq::VERSION) < Gem::Version.new('5.0.0')
+      SIDEKIQ_GTE_5_0_0 = Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new('5.0.0')
+      SIDEKIQ_GTE_7_0_0 = Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new('7.0.0')
+
+      if SIDEKIQ_GTE_5_0_0
+        require 'sidekiq/job_retry'
+        DEFAULT_MAX_RETRY_ATTEMPTS = ::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS
+      else
         require 'sidekiq/middleware/server/retry_jobs'
         DEFAULT_MAX_RETRY_ATTEMPTS = \
           ::Sidekiq::Middleware::Server::RetryJobs::DEFAULT_MAX_RETRY_ATTEMPTS
-      else
-        require 'sidekiq/job_retry'
-        DEFAULT_MAX_RETRY_ATTEMPTS = ::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS
       end
 
       def initialize(max_retries: nil)
-        @max_retries = max_retries
+        @retries_before_notify = max_retries
       end
 
       def call(notice)
@@ -36,8 +39,8 @@ module Airbrake
       end
 
       def max_attempts_for(job)
-        if @max_retries
-          @max_retries
+        if @retries_before_notify
+          @retries_before_notify
         elsif job['retry'].is_a?(Integer)
           job['retry']
         else
@@ -46,7 +49,10 @@ module Airbrake
       end
 
       def max_retries
-        @max_retries ||= ::Sidekiq.options[:max_retries] || DEFAULT_MAX_RETRY_ATTEMPTS
+        @max_retries ||= begin
+          config = SIDEKIQ_GTE_7_0_0 ? ::Sidekiq.default_configuration : ::Sidekiq.options
+          config[:max_retries] || DEFAULT_MAX_RETRY_ATTEMPTS
+        end
       end
     end
   end