airbrake 3.1.6 → 11.0.0

data/lib/airbrake/rails/http.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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

data/lib/airbrake/rails/http_client.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Allows measuring request timing.
+    module HTTPClient
+      def do_get_block(request, proxy, connection, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(request, proxy, connection, &block)
+        end
+      end
+    end
+  end
+end
+
+HTTPClient.prepend(Airbrake::Rails::HTTPClient)

data/lib/airbrake/rails/net_http.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Monkey-patch Net::HTTP to benchmark it.
+    # @api private
+    # @since v10.0.2
+    module NetHttp
+      def request(request, *args, &block)
+        Airbrake::Rack.capture_timing(:http) do
+          super(request, *args, &block)
+        end
+      end
+    end
+  end
+end
+
+Net::HTTP.prepend(Airbrake::Rails::NetHttp)

data/lib/airbrake/rails/railtie.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+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.
+    #
+    # rubocop:disable Metrics/BlockLength
+    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
+
+      initializer('airbrake.action_controller') do
+        ActiveSupport.on_load(:action_controller, run_once: true) 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
+
+          # 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)
+          require 'airbrake/rails/curb' if defined?(Curl) && defined?(Curl::CURB_VERSION)
+          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)
+
+          if defined?(Excon)
+            require 'airbrake/rails/excon_subscriber'
+            ActiveSupport::Notifications.subscribe(/excon/, Airbrake::Rails::Excon.new)
+            ::Excon.defaults[:instrumentor] = ActiveSupport::Notifications
+          end
+        end
+      end
+
+      initializer('airbrake.active_record') do
+        ActiveSupport.on_load(:active_record, run_once: true) do
+          # Reports exceptions occurring in some bugged ActiveRecord callbacks.
+          # Applicable only to the versions of Rails lower than 4.2.
+          if defined?(::Rails) &&
+             Gem::Version.new(::Rails.version) <= Gem::Version.new('4.2')
+            require 'airbrake/rails/active_record'
+            include Airbrake::Rails::ActiveRecord
+          end
+
+          if defined?(ActiveRecord)
+            # 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.
+            if ::ActiveRecord::Base.respond_to?(:connection_db_config)
+              # Rails 6.1+ deprecates "connection_config" in favor of
+              # "connection_db_config", so we need an updated call.
+              Airbrake.add_performance_filter(
+                Airbrake::Filters::SqlFilter.new(
+                  ::ActiveRecord::Base.connection_db_config.configuration_hash[:adapter],
+                ),
+              )
+            else
+              Airbrake.add_performance_filter(
+                Airbrake::Filters::SqlFilter.new(
+                  ::ActiveRecord::Base.connection_config[:adapter],
+                ),
+              )
+            end
+          end
+        end
+      end
+
+      initializer('airbrake.active_job') do
+        ActiveSupport.on_load(:active_job, run_once: true) 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, run_once: true) 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
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/airbrake/rails/typhoeus.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Airbrake
+  module Rails
+    # Allow measuring request timing.
+    module TyphoeusRequest
+      def run
+        Airbrake::Rack.capture_timing(:http) do
+          super
+        end
+      end
+    end
+  end
+end
+
+Typhoeus::Request.prepend(Airbrake::Rails::TyphoeusRequest)

data/lib/airbrake/rake.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# This is not bulletproof, but if this file is executed before a task
+# definition, we can grab tasks descriptions and locations.
+# See: https://goo.gl/ksn6PE
+Rake::TaskManager.record_task_metadata = true
+
+module Rake
+  # Redefine +Rake::Task#execute+, so it can report errors to Airbrake.
+  class Task
+    # Store the original method to use it later.
+    alias execute_without_airbrake execute
+
+    # A wrapper around the original +#execute+, that catches all errors and
+    # notifies Airbrake.
+    #
+    # rubocop:disable Lint/RescueException
+    def execute(args = nil)
+      execute_without_airbrake(args)
+    rescue Exception => ex
+      notify_airbrake(ex, args)
+      raise ex
+    end
+    # rubocop:enable Lint/RescueException
+
+    private
+
+    def notify_airbrake(exception, args)
+      notice = Airbrake.build_notice(exception)
+      notice[:context][:component] = 'rake'
+      notice[:context][:action] = name
+      notice[:params].merge!(
+        rake_task: task_info,
+        execute_args: args,
+        argv: ARGV.join(' '),
+      )
+
+      Airbrake.notify_sync(notice)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    def task_info
+      info = {}
+
+      info[:name] = name
+      info[:timestamp] = timestamp.to_s
+      info[:investigation] = investigation
+
+      info[:full_comment] = full_comment if full_comment
+      info[:arg_names] = arg_names if arg_names.any?
+      info[:arg_description] = arg_description if arg_description
+      info[:locations] = locations if locations.any?
+      info[:sources] = sources if sources.any?
+
+      if prerequisite_tasks.any?
+        info[:prerequisite_tasks] = prerequisite_tasks.map do |p|
+          p.__send__(:task_info)
+        end
+      end
+
+      info
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+  end
+end

data/lib/airbrake/rake/tasks.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'airbrake-ruby'
+
+namespace :airbrake do
+  desc 'Verify your gem installation by sending a test exception'
+  task test: (:environment if defined?(Rails)) do
+    raise Airbrake::Error, 'airbrake-ruby is not configured' unless Airbrake.configured?
+
+    require 'pp'
+
+    response = Airbrake.notify_sync('Exception from the test Rake task')
+    if response['error']
+      puts "Error: #{response['error']}"
+    elsif response.nil? || response['code']
+      puts <<-ERROR.gsub(/^\s+\|/, '')
+        |#{response['type']}: #{response['message']} (#{response['code']})
+        |
+        |Possible problems:
+        |  1. Project id/key is incorrect
+        |  2. Custom filters ignore the exception we try to send
+        |  3. Environment this task runs in is ignored (see `ignored_environments`)
+        |
+        |If nothing works, please file an issue at: https://github.com/airbrake/airbrake/issues
+      ERROR
+    elsif response['url']
+      puts <<-SUCCESS.gsub(/^\s+\|/, '')
+        |A test exception was sent to Airbrake.
+        |Find it here: #{response['url']}
+      SUCCESS
+    else
+      puts <<-ERROR.gsub(/^\s+\|/, '')
+        |Unexpected error occurred. Response from Airbrake:
+        |#{response}
+      ERROR
+    end
+  end
+
+  desc 'Notify Airbrake of a new deploy'
+  task :deploy do
+    if defined?(Rails)
+      initializer = Rails.root.join('config', 'initializers', 'airbrake.rb')
+
+      # Avoid loading the environment to speed up the deploy task and try guess
+      # the initializer file location.
+      if initializer.exist? && !Airbrake.configured?
+        load(initializer)
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+
+    raise Airbrake::Error, 'airbrake-ruby is not configured' unless Airbrake.configured?
+
+    deploy_params = {
+      environment: ENV['ENVIRONMENT'],
+      username: ENV['USERNAME'],
+      revision: ENV['REVISION'],
+      repository: ENV['REPOSITORY'],
+      version: ENV['VERSION'],
+    }
+    promise = Airbrake.notify_deploy(deploy_params)
+    promise.then do
+      puts "The #{deploy_params[:environment]} environment was deployed."
+    end
+    promise.rescue { |error| abort(error) }
+  end
+
+  desc 'Install a Heroku deploy hook to notify Airbrake of deploys'
+  task :install_heroku_deploy_hook do
+    app = ENV['HEROKU_APP']
+
+    config = Bundler.with_clean_env do
+      `heroku config --shell#{" --app #{app}" if app}`
+    end
+
+    heroku_env = config.each_line.with_object({}) do |line, h|
+      h.merge!(Hash[*line.rstrip.split("\n").flat_map { |v| v.split('=', 2) }])
+    end
+
+    id = heroku_env['AIRBRAKE_PROJECT_ID']
+    key = heroku_env['AIRBRAKE_API_KEY']
+
+    exit!(1) if [id, key].any?(&:nil?)
+
+    unless (env = heroku_env['RAILS_ENV'])
+      env = 'production'
+      puts "Airbrake couldn't identify your app's environment, so the '#{env}'" \
+           " environment will be used."
+    end
+
+    unless (repo = ENV['REPOSITORY_URL'])
+      repo = `git remote get-url origin 2>/dev/null`.chomp
+      if repo.empty?
+        puts "Airbrake couldn't identify your app's repository."
+      else
+        puts "Airbrake couldn't identify your app's repository, so the " \
+             "'origin' remote url '#{repo}' will be used."
+      end
+    end
+
+    url = ["https://airbrake.io/api/v3/projects/#{id}/heroku-deploys?key=#{key}"]
+    url << "&environment=#{env}"
+    url << "&repository=#{repo}" unless repo.empty?
+
+    command = [%(heroku addons:create deployhooks:http --url="#{url.join}")]
+    command << " --app #{app}" if app
+
+    puts "$ #{command.join}"
+    Bundler.with_clean_env { puts `#{command}` }
+  end
+end

data/lib/airbrake/resque.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Resque
+  module Failure
+    # Provides Resque integration with Airbrake.
+    #
+    # @since v5.0.0
+    # @see https://github.com/resque/resque/wiki/Failure-Backends
+    class Airbrake < Base
+      def save
+        ::Airbrake.notify_sync(exception, payload) do |notice|
+          notice[:context][:component] = 'resque'
+          notice[:context][:action] = action(payload)
+        end
+      end
+
+      private
+
+      # @return [String] job's name. When ActiveJob is present, retrieve
+      #   job_class. When used directly, use worker's name
+      def action(payload)
+        active_job_args = payload['args'].first if payload['args']
+        if active_job_args.is_a?(Hash) && active_job_args['job_class']
+          active_job_args['job_class']
+        else
+          payload['class'].to_s
+        end
+      end
+    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