airbrake 9.5.0

data/lib/airbrake/rails/action_controller_notify_subscriber.rb

@@ -0,0 +1,28 @@
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # ActionControllerNotifySubscriber sends route stat information, including
+    # performance data.
+    #
+    # @since v8.0.0
+    class ActionControllerNotifySubscriber
+      def call(*args)
+        routes = Airbrake::Rack::RequestStore[:routes]
+        return if !routes || routes.none?
+
+        event = Airbrake::Rails::Event.new(*args)
+
+        routes.each do |route, _params|
+          Airbrake.notify_request(
+            method: event.method,
+            route: route,
+            status_code: event.status_code,
+            start_time: event.time,
+            end_time: Time.new
+          )
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_controller_performance_breakdown_subscriber.rb

@@ -0,0 +1,46 @@
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # @since v8.3.0
+    class ActionControllerPerformanceBreakdownSubscriber
+      def call(*args)
+        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,
+            start_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,46 @@
+require 'airbrake/rails/event'
+require 'airbrake/rails/app'
+
+module Airbrake
+  module Rails
+    # @return [String]
+    CONTROLLER_KEY = 'controller'.freeze
+
+    # @return [String]
+    ACTION_KEY = 'action'.freeze
+
+    # ActionControllerRouteSubscriber sends route stat information, including
+    # performance data.
+    #
+    # @since v8.0.0
+    class ActionControllerRouteSubscriber
+      def initialize
+        @app = Airbrake::Rails::App.new
+      end
+
+      def call(*args)
+        # We don't track routeless events.
+        return unless (routes = Airbrake::Rack::RequestStore[:routes])
+
+        event = Airbrake::Rails::Event.new(*args)
+        route = find_route(event.params)
+        return unless route
+
+        routes[route.path] = {
+          method: event.method,
+          response_type: event.response_type,
+          groups: {}
+        }
+      end
+
+      private
+
+      def find_route(params)
+        @app.routes.find do |route|
+          route.controller == params[CONTROLLER_KEY] &&
+            route.action == params[ACTION_KEY]
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_job.rb

@@ -0,0 +1,33 @@
+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
+        notice[:params].merge!(job.serialize)
+
+        Airbrake.notify(notice)
+
+        raise exception
+      end
+
+      included do
+        rescue_from(Exception) do |exception|
+          Airbrake::Rails::ActiveJob.notify_airbrake(exception, self)
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_record.rb

@@ -0,0 +1,34 @@
+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,42 @@
+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)
+        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],
+            start_time: event.time,
+            end_time: event.end
+          )
+        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,43 @@
+module Airbrake
+  module Rails
+    # App is a wrapper around Rails.application and Rails::Engine.
+    #
+    # @since v9.0.3
+    # @api private
+    class App
+      Route = Struct.new(:path, :controller, :action)
+
+      def routes
+        @routes ||= app_routes.merge(engine_routes).flat_map do |(engine_name, routes)|
+          routes.map { |rails_route| build_route(engine_name, rails_route) }
+        end
+      end
+
+      private
+
+      def app_routes
+        # Engine name is nil because this is default (non-engine) routes.
+        { nil => ::Rails.application.routes.routes.routes }
+      end
+
+      def engine_routes
+        ::Rails::Engine.subclasses.flat_map.with_object({}) do |engine, hash|
+          next if (eng_routes = engine.routes.routes.routes).none?
+
+          hash[engine.engine_name] = eng_routes
+        end
+      end
+
+      def build_route(engine_name, rails_route)
+        engine_prefix = engine_name
+        engine_prefix += '#' if engine_prefix
+
+        Route.new(
+          "#{engine_prefix}#{rails_route.path.spec}",
+          rails_route.defaults[:controller],
+          rails_route.defaults[:action]
+        )
+      end
+    end
+  end
+end

data/lib/airbrake/rails/backtrace_cleaner.rb

@@ -0,0 +1,10 @@
+module Airbrake
+  module Rails
+    # BacktraceCleaner is a wrapper around Rails.backtrace_cleaner.
+    class BacktraceCleaner
+      def self.clean(backtrace)
+        ::Rails.backtrace_cleaner.clean(backtrace).first(1)
+      end
+    end
+  end
+end

data/lib/airbrake/rails/curb.rb

@@ -0,0 +1,35 @@
+module Curl
+  # Monkey-patch to measure request timing.
+  class Easy
+    alias http_without_airbrake http
+
+    def http(verb)
+      Airbrake::Rack.capture_timing(:http) do
+        http_without_airbrake(verb)
+      end
+    end
+
+    alias perform_without_airbrake perform
+
+    def perform(&block)
+      Airbrake::Rack.capture_timing(:http) do
+        perform_without_airbrake(&block)
+      end
+    end
+  end
+end
+
+module Curl
+  # Monkey-patch to measure request timing.
+  class Multi
+    class << self
+      alias http_without_airbrake http
+
+      def http(urls_with_config, multi_options = {}, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          http_without_airbrake(urls_with_config, multi_options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/event.rb

@@ -0,0 +1,83 @@
+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 = "*/*".freeze
+
+      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 end
+        @event.end
+      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,21 @@
+require 'airbrake/rails/event'
+
+module Airbrake
+  module Rails
+    # @api private
+    # @since v9.2.0
+    class Excon
+      def call(*args)
+        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

data/lib/airbrake/rails/http.rb

@@ -0,0 +1,12 @@
+module HTTP
+  # Monkey-patch to measure request timing.
+  class Client
+    alias perform_without_airbrake perform
+
+    def perform(request, options)
+      Airbrake::Rack.capture_timing(:http) do
+        perform_without_airbrake(request, options)
+      end
+    end
+  end
+end