airbrake 10.0.0 → 13.0.3

data/lib/airbrake/rails/app.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # App is a wrapper around Rails.application.
@@ -9,12 +11,19 @@ module Airbrake
 
       # @param [] request
       # @return [Airbrake::Rails::App::Route, nil]
+      # rubocop:disable Metrics/AbcSize
       def self.recognize_route(request)
         # Duplicate `request` because `recognize` *can* strip the request's
         # `path_info`, which results in broken engine links (when the engine has
         # an isolated namespace).
         request_copy = request.dup
 
+        # Save original script name because `router.recognize(request)` mutates
+        # it. It's a Rails bug. More info in:
+        #   * https://github.com/airbrake/airbrake/issues/1072
+        #   * https://github.com/rails/rails/issues/31152
+        original_script_name = request.env['SCRIPT_NAME']
+
         # We must search every engine individually to find a concrete route. If
         # we rely only on the `Rails.application.routes.router`, then the
         # recognize call would return the root route, neglecting PATH_INFO
@@ -24,6 +33,20 @@ module Airbrake
         #   * `Marketing::Engine` recognizes it as `marketing#/pricing` (correct)
         engines.each do |engine|
           engine.routes.router.recognize(request_copy) do |route, _params|
+            # Restore original script name. Remove this code when/if the Rails
+            # bug is fixed: https://github.com/airbrake/airbrake/issues/1072
+            request.env['SCRIPT_NAME'] = original_script_name
+
+            # Skip "catch-all" routes such as:
+            #   get '*path => 'pages#about'
+            #
+            # Ideally, we should be using `route.glob?` but in Rails 7+ this
+            # call would fail with a `NoMethodError`. This is because in
+            # Rails 7+ the AST for the route is not kept in memory anymore.
+            #
+            # See: https://github.com/rails/rails/pull/43006#discussion_r783895766
+            next if route.path.spec.any?(ActionDispatch::Journey::Nodes::Star)
+
             path =
               if engine == ::Rails.application
                 route.path.spec.to_s
@@ -44,6 +67,7 @@ module Airbrake
 
         nil
       end
+      # rubocop:enable Metrics/AbcSize
 
       def self.engines
         @engines ||= [*::Rails::Engine.subclasses, ::Rails.application]

data/lib/airbrake/rails/backtrace_cleaner.rb

@@ -1,10 +1,23 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # BacktraceCleaner is a wrapper around Rails.backtrace_cleaner.
     class BacktraceCleaner
+      # @return [Regexp]
+      AIRBRAKE_FRAME_PATTERN = %r{/airbrake/lib/airbrake/}.freeze
+
       def self.clean(backtrace)
         ::Rails.backtrace_cleaner.clean(backtrace).first(1)
       end
     end
   end
 end
+
+if defined?(Rails)
+  # Silence own frames to let the cleaner proceed to the next line (and probably
+  # find the correct call-site coming from the app code rather this library).
+  Rails.backtrace_cleaner.add_silencer do |line|
+    line =~ Airbrake::Rails::BacktraceCleaner::AIRBRAKE_FRAME_PATTERN
+  end
+end

data/lib/airbrake/rails/curb.rb

@@ -1,35 +1,32 @@
-module Curl
-  # Monkey-patch to measure request timing.
-  class Easy
-    alias http_without_airbrake http
+# frozen_string_literal: true
 
-    def http(verb)
-      Airbrake::Rack.capture_timing(:http) do
-        http_without_airbrake(verb)
+module Airbrake
+  module Rails
+    # Allows measuring request timing.
+    module CurlEasy
+      def http(verb)
+        Airbrake::Rack.capture_timing(:http) do
+          super(verb)
+        end
       end
-    end
 
-    alias perform_without_airbrake perform
-
-    def perform(&block)
-      Airbrake::Rack.capture_timing(:http) do
-        perform_without_airbrake(&block)
+      def perform(&block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(&block)
+        end
       end
     end
-  end
-end
-
-module Curl
-  # Monkey-patch to measure request timing.
-  class Multi
-    class << self
-      alias http_without_airbrake http
 
+    # Allows measuring request timing.
+    module CurlMulti
       def http(urls_with_config, multi_options = {}, &block)
         Airbrake::Rack.capture_timing(:http) do
-          http_without_airbrake(urls_with_config, multi_options, &block)
+          super(urls_with_config, multi_options, &block)
         end
       end
     end
   end
 end
+
+Curl::Easy.prepend(Airbrake::Rails::CurlEasy)
+Curl::Multi.singleton_class.prepend(Airbrake::Rails::CurlMulti)

data/lib/airbrake/rails/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # Event is a wrapper around ActiveSupport::Notifications::Event.
@@ -6,12 +8,16 @@ module Airbrake
     # @api private
     class Event
       # @see https://github.com/rails/rails/issues/8987
-      HTML_RESPONSE_WILDCARD = "*/*".freeze
+      HTML_RESPONSE_WILDCARD = "*/*"
+
+      # @return [Integer]
+      MILLISECOND = 1000
 
       include Airbrake::Loggable
 
       def initialize(*args)
         @event = ActiveSupport::Notifications::Event.new(*args)
+        @rails_7_or_greater = ::Rails::VERSION::MAJOR >= 7
       end
 
       def method
@@ -40,7 +46,15 @@ module Airbrake
       end
 
       def time
-        @event.time
+        # On Rails 7+ `ActiveSupport::Notifications::Event#time` returns an
+        # instance of Float. It represents monotonic time in milliseconds.
+        # Airbrake Ruby expects that the provided time is in seconds. Hence,
+        # we need to convert it from milliseconds to seconds. In the
+        # versions below Rails 7, time is an instance of Time.
+        #
+        # Relevant commit:
+        # https://github.com/rails/rails/commit/81d0dc90becfe0b8e7f7f26beb66c25d84b8ec7f
+        @rails_7_or_greater ? @event.time / MILLISECOND : @event.time
       end
 
       def groups

data/lib/airbrake/rails/excon_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/event'
 
 module Airbrake
@@ -6,6 +8,8 @@ module Airbrake
     # @since v9.2.0
     class Excon
       def call(*args)
+        return unless Airbrake::Config.instance.performance_stats
+
         routes = Airbrake::Rack::RequestStore[:routes]
         return if !routes || routes.none?
 

data/lib/airbrake/rails/http.rb

@@ -1,12 +1,18 @@
-module HTTP
-  # Monkey-patch to measure request timing.
-  class Client
-    alias perform_without_airbrake perform
+# frozen_string_literal: true
 
-    def perform(request, options)
-      Airbrake::Rack.capture_timing(:http) do
-        perform_without_airbrake(request, options)
+module Airbrake
+  module Rails
+    # Monkey-patch to measure request timing.
+    # @api private
+    # @since v11.0.2
+    module HTTP
+      def perform(request, options)
+        Airbrake::Rack.capture_timing(:http) do
+          super(request, options)
+        end
       end
     end
   end
 end
+
+HTTP::Client.prepend(Airbrake::Rails::HTTP)

data/lib/airbrake/rails/http_client.rb

@@ -1,10 +1,16 @@
-# Monkey-patch to measure request timing.
-class HTTPClient
-  alias do_get_without_airbrake do_get_block
+# frozen_string_literal: true
 
-  def do_get_block(request, proxy, connection, &block)
-    Airbrake::Rack.capture_timing(:http) do
-      do_get_without_airbrake(request, proxy, connection, &block)
+module Airbrake
+  module Rails
+    # Allows measuring request timing.
+    module HTTPClient
+      def do_get_block(request, proxy, connection, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(request, proxy, connection, &block)
+        end
+      end
     end
   end
 end
+
+HTTPClient.prepend(Airbrake::Rails::HTTPClient)

data/lib/airbrake/rails/net_http.rb

@@ -1,10 +1,18 @@
-# Monkey-patch Net::HTTP to benchmark it.
-Net::HTTP.class_eval do
-  alias_method :request_without_airbrake, :request
+# frozen_string_literal: true
 
-  def request(request, *args, &block)
-    Airbrake::Rack.capture_timing(:http) do
-      request_without_airbrake(request, *args, &block)
+module Airbrake
+  module Rails
+    # Monkey-patch Net::HTTP to benchmark it.
+    # @api private
+    # @since v10.0.2
+    module NetHttp
+      def request(request, *args, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(request, *args, &block)
+        end
+      end
     end
   end
 end
+
+Net::HTTP.prepend(Airbrake::Rails::NetHttp)

data/lib/airbrake/rails/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # This railtie works for any Rails application that supports railties (Rails
@@ -5,33 +7,8 @@ module Airbrake
     # occurring in the application automatically.
     class Railtie < ::Rails::Railtie
       initializer('airbrake.middleware') 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
+        require 'airbrake/rails/railties/middleware_tie'
+        Railties::MiddlewareTie.new(app).call
       end
 
       rake_tasks do
@@ -42,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,12 +1,16 @@
-module Typhoeus
-  # Monkey-patch to measure request timing.
-  class Request
-    alias run_without_airbrake run
+# frozen_string_literal: true
 
-    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

@@ -1,19 +1,19 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/railtie'
 
 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