airbrake 9.5.5 → 10.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90f7f39f6012a7e8383f50d1d99c8631582032feddaaa5a452bb7ba9afc40fc6
-  data.tar.gz: 728831ea6a9a57815fec54ac507f4712923bcfe5b012b31658ddd0c1b4d576ba
+  metadata.gz: 83054730bd07260d0293206623452abacfc4b0006f65900811bac214a026c8a0
+  data.tar.gz: dee0bf02404e401d98b065e0550cffb4fb8bdec9e208cb31d4e37155a4b9e29c
 SHA512:
-  metadata.gz: d899543189d807cbc393fba4643274eea3b02134fa09aec828926dc2dced70adef3071b36092fa0f3ba9809217b3c74aa8e6d25849c22cfcc88640a6d257c85b
-  data.tar.gz: ca0c24bbd41fdd983a128763c99a3ce43aef445266d71606d54263782894e9a4987dde638c08083eb037ae6cae322d51ba1f42e4b690422478f4c3550cec817b
+  metadata.gz: b62c7face7778e77164b5f5222c64b6623984e2925a5b1928de2eb9a5b15a224111aa87b427cdb79b6626e0ae0bee0fc2d59b0780bfc6e5d852f227d4ed4679b
+  data.tar.gz: 41407ade81d73fb1594c67ebd26311f69d3888445fa8b28ae23a0a48031a323dc9ac4a68dc6a9906b532e0855b2878edf9712565b5ef458ec2e9250d59864c2f

data/lib/airbrake/delayed_job.rb

@@ -1,14 +1,16 @@
 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 +19,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_sync(
+              queue: action,
+              error_count: 1,
+              timing: 0.01,
+            )
+
             raise exception
+          else
+            ::Airbrake.notify_queue_sync(
+              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/rack/context_filter.rb

@@ -18,7 +18,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 +54,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

@@ -9,7 +9,7 @@ module Airbrake
       HTTP_HEADER_PREFIXES = [
         'HTTP_'.freeze,
         'CONTENT_TYPE'.freeze,
-        'CONTENT_LENGTH'.freeze
+        'CONTENT_LENGTH'.freeze,
       ].freeze
 
       # @return [Integer]
@@ -34,7 +34,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/middleware.rb

@@ -94,7 +94,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/rails.rb

@@ -12,7 +12,7 @@ module Airbrake
 
           # 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)
+          level: (::Rails.logger ? ::Rails.logger.level : Logger::ERROR),
         )
       end
     end

data/lib/airbrake/rails/action_controller_notify_subscriber.rb

@@ -18,8 +18,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

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

@@ -14,14 +14,14 @@ module Airbrake
 
         event = Airbrake::Rails::Event.new(*args)
         route = Airbrake::Rails::App.recognize_route(
-          Airbrake::Rack::RequestStore[:request]
+          Airbrake::Rack::RequestStore[:request],
         )
         return unless route
 
         routes[route.path] = {
           method: event.method,
           response_type: event.response_type,
-          groups: {}
+          groups: {},
         }
       end
     end

data/lib/airbrake/rails/active_job.rb

@@ -23,10 +23,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_sync(
+          queue: job.class.name,
+          error_count: 1,
+          timing: 0.01,
+        )
+        raise exception
+      else
+        Airbrake.notify_queue_sync(
+          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_subscriber.rb

@@ -22,8 +22,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 +33,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

@@ -13,26 +13,42 @@ module Airbrake
         # Duplicate `request` because `recognize` *can* strip the request's
         # `path_info`, which results in broken engine links (when the engine has
         # an isolated namespace).
-        ::Rails.application.routes.router.recognize(request.dup) do |route, _params|
-          path =
-            if route.app.respond_to?(:app) && route.app.app.respond_to?(:engine_name)
-              "#{route.app.app.engine_name}##{route.path.spec}"
-            else
-              route.path.spec.to_s
-            end
+        request_copy = request.dup
 
-          # 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)
+        # 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|
+            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
+
+      def self.engines
+        @engines ||= [*::Rails::Engine.subclasses, ::Rails.application]
+      end
+      private_class_method :engines
     end
   end
 end

data/lib/airbrake/rails/event.rb

@@ -43,10 +43,6 @@ module Airbrake
         @event.time
       end
 
-      def end
-        @event.end
-      end
-
       def groups
         groups = {}
         groups[:db] = db_runtime if db_runtime > 0
@@ -59,7 +55,7 @@ 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
 

data/lib/airbrake/rails/railtie.rb

@@ -16,20 +16,20 @@ module Airbrake
           # exist in Rails 5 anymore.
           app.config.middleware.insert_after(
             ActionDispatch::DebugExceptions,
-            Airbrake::Rack::Middleware
+            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'
+            'Airbrake::Rack::Middleware',
           )
         else
           # Insert after DebugExceptions for apps without ActiveRecord.
           app.config.middleware.insert_after(
             ActionDispatch::DebugExceptions,
-            'Airbrake::Rack::Middleware'
+            'Airbrake::Rack::Middleware',
           )
         end
       end
@@ -55,21 +55,21 @@ module Airbrake
             require 'airbrake/rails/action_controller_route_subscriber'
             ActiveSupport::Notifications.subscribe(
               'start_processing.action_controller',
-              Airbrake::Rails::ActionControllerRouteSubscriber.new
+              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
+              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
+              Airbrake::Rails::ActionControllerPerformanceBreakdownSubscriber.new,
             )
 
             require 'airbrake/rails/net_http' if defined?(Net) && defined?(Net::HTTP)
@@ -112,8 +112,8 @@ module Airbrake
             # Filter out parameters from SQL body.
             Airbrake.add_performance_filter(
               Airbrake::Filters::SqlFilter.new(
-                ::ActiveRecord::Base.connection_config[:adapter]
-              )
+                ::ActiveRecord::Base.connection_config[:adapter],
+              ),
             )
           end
         end

data/lib/airbrake/rake.rb

@@ -30,7 +30,7 @@ module Rake
       notice[:params].merge!(
         rake_task: task_info,
         execute_args: args,
-        argv: ARGV.join(' ')
+        argv: ARGV.join(' '),
       )
 
       Airbrake.notify_sync(notice)

data/lib/airbrake/rake/tasks.rb

@@ -55,7 +55,7 @@ namespace :airbrake do
       username: ENV['USERNAME'],
       revision: ENV['REVISION'],
       repository: ENV['REPOSITORY'],
-      version: ENV['VERSION']
+      version: ENV['VERSION'],
     }
     promise = Airbrake.notify_deploy(deploy_params)
     promise.then do

data/lib/airbrake/resque.rb

@@ -27,3 +27,33 @@ module Resque
     end
   end
 end
+
+module Resque
+  # Measures elapsed time of a job and notifies Airbrake of the execution
+  # status.
+  #
+  # @since v9.6.0
+  class Job
+    # Store the original method to use it later.
+    alias perform_without_airbrake perform
+
+    def perform
+      timing = Airbrake::Benchmark.measure do
+        perform_without_airbrake
+      end
+    rescue StandardError => exception
+      Airbrake.notify_queue_sync(
+        queue: payload['class'],
+        error_count: 1,
+        timing: 0.01,
+      )
+      raise exception
+    else
+      Airbrake.notify_queue_sync(
+        queue: payload['class'],
+        error_count: 0,
+        timing: timing,
+      )
+    end
+  end
+end

data/lib/airbrake/shoryuken.rb

@@ -4,11 +4,23 @@ module Airbrake
     class ErrorHandler
       # rubocop:disable Lint/RescueException
       def call(worker, queue, _sqs_msg, body)
-        yield
+        timing = Airbrake::Benchmark.measure do
+          yield
+        end
       rescue Exception => exception
         notify_airbrake(exception, worker, queue, body)
-
+        Airbrake.notify_queue(
+          queue: worker.class.to_s,
+          error_count: 1,
+          timing: 0.01,
+        )
         raise exception
+      else
+        Airbrake.notify_queue(
+          queue: worker.class.to_s,
+          error_count: 0,
+          timing: timing,
+        )
       end
       # rubocop:enable Lint/RescueException
 
@@ -24,7 +36,7 @@ module Airbrake
       def notice_context(queue, body)
         {
           queue: queue,
-          body: body.is_a?(Array) ? { batch: body } : { body: body }
+          body: body.is_a?(Array) ? { batch: body } : { body: body },
         }
       end
     end

data/lib/airbrake/sidekiq.rb

@@ -4,14 +4,25 @@ module Airbrake
   module Sidekiq
     # Provides integration with Sidekiq v2+.
     class ErrorHandler
-      # rubocop:disable Lint/RescueException
       def call(_worker, context, _queue)
-        yield
-      rescue Exception => exception
+        timing = Airbrake::Benchmark.measure do
+          yield
+        end
+      rescue Exception => exception # rubocop:disable Lint/RescueException
         notify_airbrake(exception, context)
+        Airbrake.notify_queue(
+          queue: context['class'],
+          error_count: 1,
+          timing: 0.01,
+        )
         raise exception
+      else
+        Airbrake.notify_queue(
+          queue: context['class'],
+          error_count: 0,
+          timing: timing,
+        )
       end
-      # rubocop:enable Lint/RescueException
 
       private
 
@@ -34,14 +45,8 @@ module Airbrake
   end
 end
 
-if Sidekiq::VERSION < '3'
-  Sidekiq.configure_server do |config|
-    config.server_middleware do |chain|
-      chain.add(Airbrake::Sidekiq::ErrorHandler)
-    end
-  end
-else
-  Sidekiq.configure_server do |config|
-    config.error_handlers << Airbrake::Sidekiq::ErrorHandler.new.method(:notify_airbrake)
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add(Airbrake::Sidekiq::ErrorHandler)
   end
 end

data/lib/airbrake/sneakers.rb

@@ -32,3 +32,35 @@ module Airbrake
 end
 
 Sneakers.error_reporters << Airbrake::Sneakers::ErrorReporter.new
+
+module Sneakers
+  # @todo Migrate to Sneakers v2.12.0 middleware API when it's released
+  # @see https://github.com/jondot/sneakers/pull/364
+  module Worker
+    # Sneakers v2.7.0+ renamed `do_work` to `process_work`.
+    if method_defined?(:process_work)
+      alias process_work_without_airbrake process_work
+    else
+      alias process_work_without_airbrake do_work
+    end
+
+    def process_work(delivery_info, metadata, msg, handler)
+      timing = Airbrake::Benchmark.measure do
+        process_work_without_airbrake(delivery_info, metadata, msg, handler)
+      end
+    rescue Exception => exception # rubocop:disable Lint/RescueException
+      Airbrake.notify_queue(
+        queue: self.class.to_s,
+        error_count: 1,
+        timing: 0.01,
+      )
+      raise exception
+    else
+      Airbrake.notify_queue(
+        queue: self.class.to_s,
+        error_count: 0,
+        timing: timing,
+      )
+    end
+  end
+end

data/lib/airbrake/version.rb

@@ -1,5 +1,5 @@
 # We use Semantic Versioning v2.0.0
 # More information: http://semver.org/
 module Airbrake
-  AIRBRAKE_VERSION = '9.5.5'.freeze
+  AIRBRAKE_VERSION = '10.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airbrake
 version: !ruby/object:Gem::Version
-  version: 9.5.5
+  version: 10.0.0
 platform: ruby
 authors:
 - Airbrake Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-02 00:00:00.000000000 Z
+date: 2020-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: airbrake-ruby
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '4.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.8'
+        version: '4.12'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -254,6 +254,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement