airbrake 9.3.0 → 13.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f0a71f9f79da2a5989445a300bebe3d9025df839
-  data.tar.gz: 177632611970f6791ed686d3344df1eef7923010
+SHA256:
+  metadata.gz: 29da4f7ace6d408a64f855ddab6385fd40863235694a22cd31f5e46d1ae9c957
+  data.tar.gz: 4c08d2305072b5b48936e87dd2e53bf1610459637c7e23c7e75e118e475232b9
 SHA512:
-  metadata.gz: 978eef94355d7bc09429086301983dfabb87426e7c54d0bb2044ef19ebcf3c39c1fae79f9e2954e718013ce7071c13a16005294b9ce48c47ff4e7fbf1aba2719
-  data.tar.gz: c1006e0378f3f3b195362a9ca172359a3e131eae8de3e31cbaa017be6b7a8dc43dc58e3bb2ec4ca88b28cebab9f38bd9518a4b8a2f8e19c30340760c732124fa
+  metadata.gz: 9ddb0e206f5723439061ca14af99f2c228f80f6db5907f07a16a8fde611b4f1e13533a0dea5e5b27d564a90e3044fb449fa09731274042c59fbb84bdb7f83af1
+  data.tar.gz: b78091a0e4391c27eea3c884130e1c6515cf10cf417ea29ec6c6df32075f5917dead2efd2f6e42395a64142f761d3870408ba5f7c7fb3ed1a90f53204c7bc8b2

data/lib/airbrake/capistrano/capistrano2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   # The Capistrano v2 integration.
   module Capistrano
@@ -19,7 +21,7 @@ module Airbrake
                 RAILS_ENV=#{fetch(:rails_env, nil)} \
 
                 bundle exec rake airbrake:deploy \
-                  USERNAME=#{Shellwords.shellescape(ENV['USER'] || ENV['USERNAME'])} \
+                  USERNAME=#{Shellwords.shellescape(ENV.fetch('USER', nil) || ENV.fetch('USERNAME', nil))} \
                   ENVIRONMENT=#{fetch(:airbrake_env, fetch(:rails_env, 'production'))} \
                   REVISION=#{current_revision.strip} \
                   REPOSITORY=#{repository} \

data/lib/airbrake/capistrano/capistrano3.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :airbrake do
   desc "Notify Airbrake of the deploy"
   task :deploy do
@@ -11,7 +13,7 @@ namespace :airbrake do
                             REVISION=#{fetch(:current_revision)} \
                             REPOSITORY=#{fetch(:repo_url)} \
                             VERSION=#{fetch(:app_version)}
-            CMD
+          CMD
 
           info 'Notified Airbrake of the deploy'
         end

data/lib/airbrake/capistrano.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if defined?(Capistrano::VERSION) &&
    Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
   require 'airbrake/capistrano/capistrano3'

data/lib/airbrake/delayed_job.rb

@@ -1,33 +1,49 @@
+# frozen_string_literal: true
+
 module Delayed
   module Plugins
     # Provides integration with Delayed Job.
-    # rubocop:disable Lint/RescueException
+    # rubocop:disable Metrics/BlockLength
     class Airbrake < ::Delayed::Plugin
       callbacks do |lifecycle|
         lifecycle.around(:invoke_job) do |job, *args, &block|
-          begin
+          timing = ::Airbrake::Benchmark.measure do
             # Forward the call to the next callback in the callback chain
             block.call(job, *args)
-          rescue Exception => exception
-            params = job.as_json
+          end
+        rescue Exception => exception # rubocop:disable Lint/RescueException
+          params = job.as_json
 
-            # If DelayedJob is used through ActiveJob, it contains extra info.
-            if job.payload_object.respond_to?(:job_data)
-              params[:active_job] = job.payload_object.job_data
-              job_class = job.payload_object.job_data['job_class']
-            end
+          # If DelayedJob is used through ActiveJob, it contains extra info.
+          if job.payload_object.respond_to?(:job_data)
+            params[:active_job] = job.payload_object.job_data
+            job_class = job.payload_object.job_data['job_class']
+          end
 
-            ::Airbrake.notify(exception, params) do |notice|
-              notice[:context][:component] = 'delayed_job'
-              notice[:context][:action] = job_class || job.payload_object.class.name
-            end
+          action = job_class || job.payload_object.class.name
 
-            raise exception
+          ::Airbrake.notify(exception, params) do |notice|
+            notice[:context][:component] = 'delayed_job'
+            notice[:context][:action] = action
           end
+
+          ::Airbrake.notify_queue(
+            queue: action,
+            error_count: 1,
+            timing: 0.01,
+          )
+
+          raise exception
+        else
+          ::Airbrake.notify_queue(
+            queue: job_class || job.payload_object.class.name,
+            error_count: 0,
+            timing: timing,
+          )
         end
       end
     end
-    # rubocop:enable Lint/RescueException
+    # rubocop:enable Metrics/BlockLength
   end
 end
 

data/lib/airbrake/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'delegate'
 
@@ -7,7 +9,7 @@ module Airbrake
   #
   # @example
   #   # Create a logger like you normally do and decorate it.
-  #   logger = Airbrake::AirbrakeLogger.new(Logger.new(STDOUT))
+  #   logger = Airbrake::AirbrakeLogger.new(Logger.new($stdout))
   #
   #   # Just use the logger like you normally do.
   #   logger.fatal('oops')
@@ -22,6 +24,8 @@ module Airbrake
     attr_reader :airbrake_level
 
     def initialize(logger)
+      super
+
       __setobj__(logger)
       @airbrake_notifier = Airbrake
       self.level = logger.level

data/lib/airbrake/rack/context_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Adds context (URL, User-Agent, framework version, controller and more).
@@ -18,9 +20,9 @@ module Airbrake
         context = notice[:context]
 
         context[:url] = request.url
-        context[:userAddr] = request.ip
         context[:userAgent] = request.user_agent
 
+        add_ip(context, request)
         add_framework_version(context)
 
         controller = request.env['action_controller.instance']
@@ -49,10 +51,19 @@ module Airbrake
           else
             {
               'rack_version' => ::Rack.version,
-              'rack_release' => ::Rack.release
+              'rack_release' => ::Rack.release,
             }
           end
       end
+
+      def add_ip(context, request)
+        context[:userAddr] =
+          if request.respond_to?(:remote_ip)
+            request.remote_ip
+          else
+            request.ip
+          end
+      end
     end
   end
 end

data/lib/airbrake/rack/http_headers_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Adds HTTP request parameters.
@@ -6,10 +8,10 @@ module Airbrake
     class HttpHeadersFilter
       # @return [Array<String>] the prefixes of the majority of HTTP headers in
       #   Rack (some prefixes match the header names for simplicity)
-      HTTP_HEADER_PREFIXES = [
-        'HTTP_'.freeze,
-        'CONTENT_TYPE'.freeze,
-        'CONTENT_LENGTH'.freeze
+      HTTP_HEADER_PREFIXES = %w[
+        HTTP_
+        CONTENT_TYPE
+        CONTENT_LENGTH
       ].freeze
 
       # @return [Integer]
@@ -34,7 +36,7 @@ module Airbrake
         notice[:context].merge!(
           httpMethod: request.request_method,
           referer: request.referer,
-          headers: http_headers
+          headers: http_headers,
         )
       end
     end

data/lib/airbrake/rack/http_params_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Adds HTTP request parameters.

data/lib/airbrake/rack/instrumentable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Instrumentable holds methods that simplify instrumenting Rack apps.
@@ -15,14 +17,124 @@ module Airbrake
     # @since v9.2.0
     module Instrumentable
       def airbrake_capture_timing(method_name, label: method_name.to_s)
-        alias_method "#{method_name}_without_airbrake", method_name
+        instrumentable = ::Airbrake::Rack::Instrumentable
+        if instrumentable.should_prepend?(self, method_name)
+          instrumentable.prepend_capture_timing(self, method_name, label)
+        else
+          instrumentable.chain_capture_timing(self, method_name, label)
+        end
+        method_name
+      end
+
+      # @api private
+      def __airbrake_capture_timing_module__
+        # Module used to store prepended wrapper methods, saved as an instance
+        # variable so each target class/module gets its own module. This just
+        # a convenience to avoid prepending a lot of anonymous modules.
+        @__airbrake_capture_timing_module__ ||= ::Module.new
+      end
+      private :__airbrake_capture_timing_module__
+
+      # Using api private self methods so they don't get defined in the target
+      # class or module, but can still be called by the above method.
+
+      # @api private
+      def self.should_prepend?(klass, method_name)
+        # Don't chain already-prepended or operator methods.
+        klass.module_exec do
+          self_class_idx = ancestors.index(self)
+          method_owner_idx = ancestors.index(instance_method(method_name).owner)
+          method_owner_idx < self_class_idx || !(/\A\W/ =~ method_name).nil?
+        end
+      end
+
+      # @api private
+      def self.prepend_capture_timing(klass, method_name, label)
+        args = method_signature
+        visibility = method_visibility(klass, method_name)
+
+        # Generate the wrapper method.
+        klass.module_exec do
+          mod = __airbrake_capture_timing_module__
+          mod.module_exec do
+            # rubocop:disable Style/DocumentDynamicEvalDefinition
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method_name}(#{args})
+                Airbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                  super
+                end
+              end
+              #{visibility} :#{method_name}
+            RUBY
+            # rubocop:enable Style/DocumentDynamicEvalDefinition
+          end
+          prepend mod
+        end
+      end
+
+      # @api private
+      def self.chain_capture_timing(klass, method_name, label)
+        args = method_signature
+        visibility = method_visibility(klass, method_name)
 
-        define_method(method_name) do |*args|
-          Airbrake::Rack.capture_timing(label) do
-            __send__("#{method_name}_without_airbrake", *args)
+        # Generate the wrapper method.
+        aliased = method_name.to_s.sub(/([?!=])$/, '')
+        punctuation = Regexp.last_match(1)
+        wrapped_method_name = "#{aliased}_without_airbrake#{punctuation}"
+        needs_removal = method_needs_removal(klass, method_name)
+        klass.module_exec do
+          alias_method wrapped_method_name, method_name
+          remove_method method_name if needs_removal
+          # rubocop:disable Style/DocumentDynamicEvalDefinition
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(#{args})
+              Airbrake::Rack.capture_timing(#{label.to_s.inspect}) do
+                __send__("#{aliased}_without_airbrake#{punctuation}", #{args})
+              end
+            end
+            #{visibility} :#{method_name}
+          RUBY
+          # rubocop:enable Style/DocumentDynamicEvalDefinition
+        end
+      end
+
+      # @api private
+      def self.method_visibility(klass, method_name)
+        klass.module_exec do
+          if protected_method_defined?(method_name)
+            "protected"
+          elsif private_method_defined?(method_name)
+            "private"
+          else
+            "public"
           end
         end
       end
+
+      # @api private
+      # A method instead of a constant so it isn't accessible in the target.
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7")
+        def self.method_signature
+          "*args, **kw_args, &block"
+        end
+      else
+        def self.method_signature
+          "*args, &block"
+        end
+      end
+
+      # @api private
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6")
+        def self.method_needs_removal(klass, method_name)
+          klass.method_defined?(method_name, false) ||
+            klass.private_method_defined?(method_name, false)
+        end
+      else
+        def self.method_needs_removal(klass, method_name)
+          klass.instance_methods(false).include?(method_name) ||
+            klass.private_instance_methods(false).include?(method_name)
+        end
+      end
     end
   end
 end

data/lib/airbrake/rack/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Airbrake Rack middleware for Rails and Sinatra applications (or any other
@@ -94,7 +96,7 @@ end
   Airbrake::Rack::SessionFilter,
   Airbrake::Rack::HttpParamsFilter,
   Airbrake::Rack::HttpHeadersFilter,
-  Airbrake::Rack::RouteFilter
+  Airbrake::Rack::RouteFilter,
 ].each do |filter|
   Airbrake.add_filter(filter.new)
 end

data/lib/airbrake/rack/request_body_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # A filter that appends Rack request body to the notice.

data/lib/airbrake/rack/request_store.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # RequestStore is a thin (and limited) wrapper around *Thread.current* that

data/lib/airbrake/rack/route_filter.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'airbrake/rails/app'
+
 module Airbrake
   module Rack
     # Adds route slugs to context/route.
@@ -23,21 +27,15 @@ module Airbrake
       private
 
       def rails_route(request)
-        ::Rails.application.routes.router.recognize(request) do |route, _parameters|
-          # 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.path.spec.to_s
-        end
+        return unless (route = Airbrake::Rails::App.recognize_route(request))
+
+        route.path
       end
 
       def sinatra_route(request)
         return unless (route = request.env['sinatra.route'])
-        route.split(' ').drop(1).join(' ')
+
+        route.split.drop(1).join(' ')
       end
 
       def action_dispatch_request?(request)

data/lib/airbrake/rack/session_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Adds HTTP session.

data/lib/airbrake/rack/user.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Represents an authenticated user, which can be converted to Airbrake's
@@ -26,7 +28,12 @@ module Airbrake
         controller = rack_env['action_controller.instance']
         return unless controller.respond_to?(:current_user, true)
         return unless [-1, 0].include?(controller.method(:current_user).arity)
-        controller.__send__(:current_user)
+
+        begin
+          controller.__send__(:current_user)
+        rescue Exception => _e # rubocop:disable Lint/RescueException
+          nil
+        end
       end
       private_class_method :try_current_user
 
@@ -53,6 +60,7 @@ module Airbrake
         # try methods with no arguments or with variable number of arguments,
         # where none of them are required
         return unless @user.method(key).arity.between?(-1, 0)
+
         String(@user.__send__(key))
       end
 

data/lib/airbrake/rack/user_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   module Rack
     # Adds current user information.

data/lib/airbrake/rack.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rack/user'
 require 'airbrake/rack/user_filter'
 require 'airbrake/rack/context_filter'
@@ -16,6 +18,8 @@ module Airbrake
     # @since v9.2.0
     # @api public
     def self.capture_timing(label)
+      return yield unless Airbrake::Config.instance.performance_stats
+
       routes = Airbrake::Rack::RequestStore[:routes]
       if !routes || routes.none?
         result = yield

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_cable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'airbrake/rails/action_cable/notify_callback'
 
 %i[subscribe unsubscribe].each do |callback_name|
@@ -8,26 +10,28 @@ require 'airbrake/rails/action_cable/notify_callback'
   end
 end
 
-module ActionCable
-  module Channel
-    # @since v8.3.0
-    # @api private
-    # @see https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/channel/base.rb
-    class Base
-      alias perform_action_without_airbrake perform_action
+module Airbrake
+  module ActionCable
+    module Channel
+      # @since v8.3.0
+      # @api private
+      # @see https://github.com/rails/rails/blob/master/actioncable/lib/action_cable/channel/base.rb
+      module Base
+        def perform_action(*args, &block)
+          super(*args, &block)
+        rescue Exception => ex # rubocop:disable Lint/RescueException
+          Airbrake.notify(ex) do |notice|
+            notice.stash[:action_cable_connection] = connection
+            notice[:context][:component] = self.class
+            notice[:context][:action] = args.first['action']
+            notice[:params].merge!(args.first)
+          end
 
-      def perform_action(*args, &block)
-        perform_action_without_airbrake(*args, &block)
-      rescue Exception => ex # rubocop:disable Lint/RescueException
-        Airbrake.notify(ex) do |notice|
-          notice.stash[:action_cable_connection] = connection
-          notice[:context][:component] = self.class
-          notice[:context][:action] = args.first['action']
-          notice[:params].merge!(args.first)
+          raise ex
         end
-
-        raise ex
       end
     end
   end
 end
+
+ActionCable::Channel::Base.prepend(Airbrake::ActionCable::Channel::Base)

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