airbrake 9.4.0 → 11.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6231106842eab5861b73b11301a7fa14858cf7da
-  data.tar.gz: 4441123b54f2c50fff4c014eb90b2da35046bbbe
+SHA256:
+  metadata.gz: 4b780328fc01621a0273577655179008c6314c6fe5187e5562f15c5112f296cd
+  data.tar.gz: 3036e80e03bbb2fa4159a9167a6971adcda2dcbee789ed3db320c0eaf0408d9b
 SHA512:
-  metadata.gz: d598e73a591a249bae78ef19d790787b25379ded02bc42e8f7e85099eb8c96946caa44c74d44691697393e61c37c1cecb2ead27f41184b7639750787c06d1253
-  data.tar.gz: 936f8650bcb5cbacf86b29e5782341b08225faac7cda727a3dbe01a10dffff76e824033e6a8bdbf79f9f6a5227ccb297b8e22acf2e5b2ea517ae45e84945f942
+  metadata.gz: f307768db070afd129623ed312e7f4da4e4040f1bdf33cb9d1e31f2f1ee4278e992eac0e901a6bb257042ff9aff5f651c2a8bd74579606771c56d4040e63c0b1
+  data.tar.gz: b6376325c1b352ac7f13a0a0467737fb2a8cb08a12748c10d991265342119bcd6f510271744facb11018312de593857835aceadef557c20bbf1e85a2296e7bd4

data/lib/airbrake.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'shellwords'
 require 'English'
 

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/capistrano/capistrano2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Airbrake
   # The Capistrano v2 integration.
   module Capistrano

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/delayed_job.rb

@@ -1,14 +1,18 @@
+# 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
-            # Forward the call to the next callback in the callback chain
-            block.call(job, *args)
-          rescue Exception => exception
+            timing = ::Airbrake::Benchmark.measure do
+              # Forward the call to the next callback in the callback chain
+              block.call(job, *args)
+            end
+          rescue Exception => exception # rubocop:disable Lint/RescueException
             params = job.as_json
 
             # If DelayedJob is used through ActiveJob, it contains extra info.
@@ -17,17 +21,31 @@ module Delayed
               job_class = job.payload_object.job_data['job_class']
             end
 
+            action = job_class || job.payload_object.class.name
+
             ::Airbrake.notify(exception, params) do |notice|
               notice[:context][:component] = 'delayed_job'
-              notice[:context][:action] = job_class || job.payload_object.class.name
+              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
     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'
 

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/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,7 +20,12 @@ module Airbrake
         context = notice[:context]
 
         context[:url] = request.url
-        context[:userAddr] = request.ip
+        context[:userAddr] =
+          if request.respond_to?(:remote_ip)
+            request.remote_ip
+          else
+            request.ip
+          end
         context[:userAgent] = request.user_agent
 
         add_framework_version(context)
@@ -49,7 +56,7 @@ module Airbrake
           else
             {
               'rack_version' => ::Rack.version,
-              'rack_release' => ::Rack.release
+              'rack_release' => ::Rack.release,
             }
           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,120 @@ 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
+            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
+          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
+          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
+        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,20 +27,14 @@ 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(' ')
       end
 

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/rails.rb

@@ -1,140 +1,19 @@
-module Airbrake
-  module Rails
-    # This railtie works for any Rails application that supports railties (Rails
-    # 3.2+ apps). It makes Airbrake Ruby work with Rails and report errors
-    # 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
-      end
-
-      rake_tasks do
-        # Report exceptions occurring in Rake tasks.
-        require 'airbrake/rake'
-
-        # Defines tasks such as `airbrake:test` & `airbrake:deploy`.
-        require 'airbrake/rake/tasks'
-      end
-
-      # rubocop:disable Metrics/BlockLength
-      initializer('airbrake.action_controller') do
-        ActiveSupport.on_load(:action_controller) 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
+# frozen_string_literal: true
 
-            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)
+require 'airbrake/rails/railtie'
 
-            if defined?(Excon)
-              require 'airbrake/rails/excon_subscriber'
-              ActiveSupport::Notifications.subscribe(/excon/, Airbrake::Rails::Excon.new)
-              ::Excon.defaults[:instrumentor] = ActiveSupport::Notifications
-            end
-          end
-        end
-      end
-      # rubocop:enable Metrics/BlockLength
-
-      initializer('airbrake.active_record') do
-        ActiveSupport.on_load(:active_record) do
-          # Reports exceptions occurring in some bugged ActiveRecord callbacks.
-          # Applicable only to the versions of Rails lower than 4.2.
-          require 'airbrake/rails/active_record'
-          include Airbrake::Rails::ActiveRecord
-
-          if defined?(ActiveRecord) && Airbrake::Config.instance.performance_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
-      end
-
-      initializer('airbrake.active_job') do
-        ActiveSupport.on_load(:active_job) do
-          # Reports exceptions occurring in ActiveJob jobs.
-          require 'airbrake/rails/active_job'
-          include Airbrake::Rails::ActiveJob
-        end
-      end
-
-      initializer('airbrake.action_cable') do
-        ActiveSupport.on_load(:action_cable) do
-          # Reports exceptions occurring in ActionCable connections.
-          require 'airbrake/rails/action_cable'
-        end
-      end
-
-      runner do
-        at_exit do
-          Airbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
-        end
+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: level)
+      else
+        Logger.new(::Rails.root.join('log', 'airbrake.log'), level: level)
       end
     end
   end