airbrake 3.1.6 → 11.0.0

data/lib/airbrake/rails/action_controller_performance_breakdown_subscriber.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # @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?
+
+        event = Airbrake::Rails::Event.new(*args)
+        stash = build_stash
+
+        routes.each do |route, params|
+          groups = event.groups.merge(params[:groups])
+          next if groups.none?
+
+          breakdown_info = {
+            method: event.method,
+            route: route,
+            response_type: event.response_type,
+            groups: groups,
+            timing: event.duration,
+            time: event.time,
+          }
+
+          Airbrake.notify_performance_breakdown(breakdown_info, stash)
+        end
+      end
+
+      private
+
+      def build_stash
+        stash = {}
+        request = Airbrake::Rack::RequestStore[:request]
+        return stash unless request
+
+        stash[:request] = request
+        if (user = Airbrake::Rack::User.extract(request.env))
+          stash.merge!(user.as_json)
+        end
+
+        stash
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_controller_route_subscriber.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/event'
+require 'airbrake/rails/app'
+
+module Airbrake
+  module Rails
+    # ActionControllerRouteSubscriber sends route stat information, including
+    # performance data.
+    #
+    # @since v8.0.0
+    class ActionControllerRouteSubscriber
+      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 = Airbrake::Rails::App.recognize_route(
+          Airbrake::Rack::RequestStore[:request],
+        )
+        return unless route
+
+        routes[route.path] = {
+          method: event.method,
+          response_type: event.response_type,
+          groups: {},
+        }
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_job.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Enables support for exceptions occurring in ActiveJob jobs.
+    module ActiveJob
+      extend ActiveSupport::Concern
+
+      def self.notify_airbrake(exception, job)
+        notice = Airbrake.build_notice(exception)
+        notice[:context][:component] = 'active_job'
+        notice[:context][:action] = job.class.name
+        notice[:params].merge!(job.serialize)
+
+        Airbrake.notify(notice)
+
+        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
+end

data/lib/airbrake/rails/active_record.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Rails <4.2 has a bug with regard to swallowing exceptions in the
+    # +after_commit+ and the +after_rollback+ hooks: it doesn't bubble up
+    # exceptions from there.
+    #
+    # This module makes it possible to report exceptions occurring there.
+    #
+    # @see https://github.com/rails/rails/pull/14488 Detailed description of the
+    #   bug and the fix
+    # @see https://goo.gl/348lor Rails 4.2+ implementation (fixed)
+    # @see https://goo.gl/ddFNg7 Rails <4.2 implementation (bugged)
+    module ActiveRecord
+      # Patches default +run_callbacks+ with our version, which is capable of
+      # notifying about exceptions.
+      #
+      # rubocop:disable Lint/RescueException
+      def run_callbacks(kind, *args, &block)
+        # Let the post process handle the exception if it's not a bugged hook.
+        return super unless %i[commit rollback].include?(kind)
+
+        # Handle the exception ourselves. The 'ex' exception won't be
+        # propagated, therefore we must notify it here.
+        begin
+          super
+        rescue Exception => ex
+          Airbrake.notify(ex)
+          raise ex
+        end
+      end
+      # rubocop:enable Lint/RescueException
+    end
+  end
+end

data/lib/airbrake/rails/active_record_subscriber.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/event'
+require 'airbrake/rails/backtrace_cleaner'
+
+module Airbrake
+  module Rails
+    # ActiveRecordSubscriber sends SQL information, including performance data.
+    #
+    # @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?
+
+        event = Airbrake::Rails::Event.new(*args)
+        frame = last_caller
+
+        routes.each do |route, params|
+          Airbrake.notify_query(
+            route: route,
+            method: params[:method],
+            query: event.sql,
+            func: frame[:function],
+            file: frame[:file],
+            line: frame[:line],
+            timing: event.duration,
+            time: event.time,
+          )
+        end
+      end
+
+      private
+
+      def last_caller
+        exception = StandardError.new
+        exception.set_backtrace(
+          Airbrake::Rails::BacktraceCleaner.clean(Kernel.caller),
+        )
+        Airbrake::Backtrace.parse(exception).first || {}
+      end
+    end
+  end
+end

data/lib/airbrake/rails/app.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # App is a wrapper around Rails.application.
+    #
+    # @since v9.0.3
+    # @api private
+    class App
+      Route = Struct.new(:path)
+
+      # @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
+        # 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
+
+            # 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

@@ -0,0 +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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Allows measuring request timing.
+    module CurlEasy
+      def http(verb)
+        Airbrake::Rack.capture_timing(:http) do
+          super(verb)
+        end
+      end
+
+      def perform(&block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(&block)
+        end
+      end
+    end
+
+    # Allows measuring request timing.
+    module CurlMulti
+      def http(urls_with_config, multi_options = {}, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Event is a wrapper around ActiveSupport::Notifications::Event.
+    #
+    # @since v9.0.3
+    # @api private
+    class Event
+      # @see https://github.com/rails/rails/issues/8987
+      HTML_RESPONSE_WILDCARD = "*/*"
+
+      include Airbrake::Loggable
+
+      def initialize(*args)
+        @event = ActiveSupport::Notifications::Event.new(*args)
+      end
+
+      def method
+        @event.payload[:method]
+      end
+
+      def response_type
+        response_type = @event.payload[:format]
+        response_type == HTML_RESPONSE_WILDCARD ? :html : response_type
+      end
+
+      def params
+        @event.payload[:params]
+      end
+
+      def sql
+        @event.payload[:sql]
+      end
+
+      def db_runtime
+        @db_runtime ||= @event.payload[:db_runtime] || 0
+      end
+
+      def view_runtime
+        @view_runtime ||= @event.payload[:view_runtime] || 0
+      end
+
+      def time
+        @event.time
+      end
+
+      def groups
+        groups = {}
+        groups[:db] = db_runtime if db_runtime > 0
+        groups[:view] = view_runtime if view_runtime > 0
+        groups
+      end
+
+      def status_code
+        return @event.payload[:status] if @event.payload[:status]
+
+        if @event.payload[:exception]
+          status = ActionDispatch::ExceptionWrapper.status_code_for_exception(
+            @event.payload[:exception].first,
+          )
+          status = 500 if status == 0
+
+          return status
+        end
+
+        # 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
+        @event.duration
+      end
+    end
+  end
+end

data/lib/airbrake/rails/excon_subscriber.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # @api private
+    # @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?
+
+        event = Airbrake::Rails::Event.new(*args)
+
+        routes.each do |_route_path, params|
+          params[:groups][:http] ||= 0
+          params[:groups][:http] += event.duration
+        end
+      end
+    end
+  end
+end