airbrake 9.4.0 → 11.0.1

data/lib/airbrake/rails/action_cable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/action_cable/notify_callback'
 
 %i[subscribe unsubscribe].each do |callback_name|

data/lib/airbrake/rails/action_cable/notify_callback.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     module ActionCable

data/lib/airbrake/rails/action_controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # Contains helper methods that can be used inside Rails controllers to send
@@ -10,23 +12,26 @@ module Airbrake
       # A helper method for sending notices to Airbrake *asynchronously*.
       # Attaches information from the Rack env.
       # @see Airbrake#notify, #notify_airbrake_sync
-      def notify_airbrake(exception, params = {})
+      def notify_airbrake(exception, params = {}, &block)
         return unless (notice = build_notice(exception, params))
-        Airbrake.notify(notice, params)
+
+        Airbrake.notify(notice, params, &block)
       end
 
       # A helper method for sending notices to Airbrake *synchronously*.
       # Attaches information from the Rack env.
       # @see Airbrake#notify_sync, #notify_airbrake
-      def notify_airbrake_sync(exception, params = {})
+      def notify_airbrake_sync(exception, params = {}, &block)
         return unless (notice = build_notice(exception, params))
-        Airbrake.notify_sync(notice, params)
+
+        Airbrake.notify_sync(notice, params, &block)
       end
 
       # @param [Exception] exception
       # @return [Airbrake::Notice] the notice with information from the Rack env
       def build_notice(exception, params = {})
         return unless (notice = Airbrake.build_notice(exception, params))
+
         notice.stash[:rack_request] = request
         notice
       end

data/lib/airbrake/rails/action_controller_notify_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/event'
 
 module Airbrake
@@ -8,6 +10,8 @@ module Airbrake
     # @since v8.0.0
     class ActionControllerNotifySubscriber
       def call(*args)
+        return unless Airbrake::Config.instance.performance_stats
+
         routes = Airbrake::Rack::RequestStore[:routes]
         return if !routes || routes.none?
 
@@ -18,8 +22,8 @@ module Airbrake
             method: event.method,
             route: route,
             status_code: event.status_code,
-            start_time: event.time,
-            end_time: Time.new
+            timing: event.duration,
+            time: event.time,
           )
         end
       end

data/lib/airbrake/rails/action_controller_performance_breakdown_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/event'
 
 module Airbrake
@@ -5,6 +7,8 @@ module Airbrake
     # @since v8.3.0
     class ActionControllerPerformanceBreakdownSubscriber
       def call(*args)
+        return unless Airbrake::Config.instance.performance_stats
+
         routes = Airbrake::Rack::RequestStore[:routes]
         return if !routes || routes.none?
 
@@ -20,7 +24,8 @@ module Airbrake
             route: route,
             response_type: event.response_type,
             groups: groups,
-            start_time: event.time
+            timing: event.duration,
+            time: event.time,
           }
 
           Airbrake.notify_performance_breakdown(breakdown_info, stash)

data/lib/airbrake/rails/action_controller_route_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/event'
 require 'airbrake/rails/app'
 
@@ -8,33 +10,24 @@ module Airbrake
     #
     # @since v8.0.0
     class ActionControllerRouteSubscriber
-      def initialize
-        @app = Airbrake::Rails::App.new
-      end
-
       def call(*args)
+        return unless Airbrake::Config.instance.performance_stats
+
         # We don't track routeless events.
         return unless (routes = Airbrake::Rack::RequestStore[:routes])
 
         event = Airbrake::Rails::Event.new(*args)
-        route = find_route(event.params)
+        route = Airbrake::Rails::App.recognize_route(
+          Airbrake::Rack::RequestStore[:request],
+        )
         return unless route
 
         routes[route.path] = {
           method: event.method,
           response_type: event.response_type,
-          groups: {}
+          groups: {},
         }
       end
-
-      private
-
-      def find_route(params)
-        @app.routes.find do |route|
-          route.controller == params['controller'] &&
-            route.action == params['action']
-        end
-      end
     end
   end
 end

data/lib/airbrake/rails/active_job.rb

@@ -1,18 +1,12 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # Enables support for exceptions occurring in ActiveJob jobs.
     module ActiveJob
       extend ActiveSupport::Concern
 
-      # @return [Array<Regexp>] the list of known adapters
-      ADAPTERS = [/Resque/, /Sidekiq/, /DelayedJob/].freeze
-
       def self.notify_airbrake(exception, job)
-        queue_adapter = job.class.queue_adapter.to_s
-
-        # Do not notify twice if a queue_adapter is configured already.
-        raise exception if ADAPTERS.any? { |a| a =~ queue_adapter }
-
         notice = Airbrake.build_notice(exception)
         notice[:context][:component] = 'active_job'
         notice[:context][:action] = job.class.name
@@ -23,10 +17,33 @@ module Airbrake
         raise exception
       end
 
+      def self.perform(job, block)
+        timing = Airbrake::Benchmark.measure do
+          block.call
+        end
+      rescue StandardError => exception
+        Airbrake.notify_queue(
+          queue: job.class.name,
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Airbrake.notify_queue(
+          queue: job.class.name,
+          error_count: 0,
+          timing: timing,
+        )
+      end
+
       included do
         rescue_from(Exception) do |exception|
           Airbrake::Rails::ActiveJob.notify_airbrake(exception, self)
         end
+
+        around_perform do |job, block|
+          Airbrake::Rails::ActiveJob.perform(job, block)
+        end
       end
     end
   end

data/lib/airbrake/rails/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
     # Rails <4.2 has a bug with regard to swallowing exceptions in the

data/lib/airbrake/rails/active_record_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/event'
 require 'airbrake/rails/backtrace_cleaner'
 
@@ -8,6 +10,8 @@ module Airbrake
     # @since v8.1.0
     class ActiveRecordSubscriber
       def call(*args)
+        return unless Airbrake::Config.instance.query_stats
+
         routes = Airbrake::Rack::RequestStore[:routes]
         return if !routes || routes.none?
 
@@ -22,8 +26,8 @@ module Airbrake
             func: frame[:function],
             file: frame[:file],
             line: frame[:line],
-            start_time: event.time,
-            end_time: event.end
+            timing: event.duration,
+            time: event.time,
           )
         end
       end
@@ -33,7 +37,7 @@ module Airbrake
       def last_caller
         exception = StandardError.new
         exception.set_backtrace(
-          Airbrake::Rails::BacktraceCleaner.clean(Kernel.caller)
+          Airbrake::Rails::BacktraceCleaner.clean(Kernel.caller),
         )
         Airbrake::Backtrace.parse(exception).first || {}
       end

data/lib/airbrake/rails/app.rb

@@ -1,33 +1,78 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rails
-    # App is a wrapper around Rails.application and Rails::Engine.
+    # App is a wrapper around Rails.application.
     #
     # @since v9.0.3
     # @api private
     class App
-      Route = Struct.new(:path, :controller, :action)
-
-      def routes
-        @routes ||= [*app_routes, *engine_routes].map do |route|
-          Route.new(
-            route.path.spec.to_s,
-            route.defaults[:controller],
-            route.defaults[:action]
-          )
-        end
-      end
+      Route = Struct.new(:path)
 
-      private
+      # @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
 
-      def app_routes
-        ::Rails.application.routes.routes.routes
-      end
+        # 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
+        # completely. For example:
+        #   * a request is made to `marketing#pricing`
+        #   * `Rails.application` recognizes it as `marketing#/` (incorrect)
+        #   * `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
 
-      def engine_routes
-        ::Rails::Engine.subclasses.flat_map do |engine|
-          engine.routes.routes.routes
+            # Skip "catch-all" routes such as:
+            #   get '*path => 'pages#about'
+            #
+            # @todo The `glob?` method was added in Rails v4.2.0.beta1. We
+            # should remove the `respond_to?` check once we drop old Rails
+            # versions support.
+            #
+            # https://github.com/rails/rails/commit/5460591f0226a9d248b7b4f89186bd5553e7768f
+            next if route.respond_to?(:glob?) && route.glob?
+
+            path =
+              if engine == ::Rails.application
+                route.path.spec.to_s
+              else
+                "#{engine.engine_name}##{route.path.spec}"
+              end
+
+            # Rails can recognize multiple routes for the given request. For
+            # example, if we visit /users/2/edit, then Rails sees these routes:
+            #   * "/users/:id/edit(.:format)"
+            #   *  "/"
+            #
+            # We return the first route as, what it seems, the most optimal
+            # approach.
+            return Route.new(path)
+          end
         end
+
+        nil
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def self.engines
+        @engines ||= [*::Rails::Engine.subclasses, ::Rails.application]
       end
+      private_class_method :engines
     end
   end
 end

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,7 +8,9 @@ module Airbrake
     # @api private
     class Event
       # @see https://github.com/rails/rails/issues/8987
-      HTML_RESPONSE_WILDCARD = "*/*".freeze
+      HTML_RESPONSE_WILDCARD = "*/*"
+
+      include Airbrake::Loggable
 
       def initialize(*args)
         @event = ActiveSupport::Notifications::Event.new(*args)
@@ -41,10 +45,6 @@ module Airbrake
         @event.time
       end
 
-      def end
-        @event.end
-      end
-
       def groups
         groups = {}
         groups[:db] = db_runtime if db_runtime > 0
@@ -57,14 +57,20 @@ module Airbrake
 
         if @event.payload[:exception]
           status = ActionDispatch::ExceptionWrapper.status_code_for_exception(
-            @event.payload[:exception].first
+            @event.payload[:exception].first,
           )
           status = 500 if status == 0
 
           return status
         end
 
-        0
+        # The ActiveSupport event doesn't have status only in two cases:
+        #   - an exception was thrown
+        #   - unauthorized access
+        # We have already handled the exception so what's left is unauthorized
+        # access. There's no way to know for sure it's unauthorized access, so
+        # we are rather optimistic here.
+        401
       end
 
       def duration