airbrake 9.5.0

data/lib/airbrake/rails/http_client.rb

@@ -0,0 +1,10 @@
+# Monkey-patch to measure request timing.
+class HTTPClient
+  alias do_get_without_airbrake do_get_block
+
+  def do_get_block(request, proxy, connection, &block)
+    Airbrake::Rack.capture_timing(:http) do
+      do_get_without_airbrake(request, proxy, connection, &block)
+    end
+  end
+end

data/lib/airbrake/rails/net_http.rb

@@ -0,0 +1,10 @@
+# Monkey-patch Net::HTTP to benchmark it.
+Net::HTTP.class_eval do
+  alias_method :request_without_airbrake, :request
+
+  def request(request, *args, &block)
+    Airbrake::Rack.capture_timing(:http) do
+      request_without_airbrake(request, *args, &block)
+    end
+  end
+end

data/lib/airbrake/rails/railtie.rb

@@ -0,0 +1,141 @@
+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, 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
+
+          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
+
+            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
+      end
+      # rubocop:enable Metrics/BlockLength
+
+      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.
+          require 'airbrake/rails/active_record'
+          include Airbrake::Rails::ActiveRecord
+
+          if defined?(ActiveRecord) && Airbrake::Config.instance.query_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, 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
+  end
+end

data/lib/airbrake/rails/typhoeus.rb

@@ -0,0 +1,12 @@
+module Typhoeus
+  # Monkey-patch to measure request timing.
+  class Request
+    alias run_without_airbrake run
+
+    def run
+      Airbrake::Rack.capture_timing(:http) do
+        run_without_airbrake
+      end
+    end
+  end
+end

data/lib/airbrake/rake.rb

@@ -0,0 +1,63 @@
+# 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,110 @@
+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}")
+    command << " --app #{app}" if app
+
+    puts "$ #{command}"
+    Bundler.with_clean_env { puts `#{command}` }
+  end
+end

data/lib/airbrake/resque.rb

@@ -0,0 +1,29 @@
+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

data/lib/airbrake/shoryuken.rb

@@ -0,0 +1,40 @@
+module Airbrake
+  module Shoryuken
+    # Provides integration with Shoryuken.
+    class ErrorHandler
+      # rubocop:disable Lint/RescueException
+      def call(worker, queue, _sqs_msg, body)
+        yield
+      rescue Exception => exception
+        notify_airbrake(exception, worker, queue, body)
+
+        raise exception
+      end
+      # rubocop:enable Lint/RescueException
+
+      private
+
+      def notify_airbrake(exception, worker, queue, body)
+        Airbrake.notify(exception, notice_context(queue, body)) do |notice|
+          notice[:context][:component] = 'shoryuken'
+          notice[:context][:action] = worker.class.to_s
+        end
+      end
+
+      def notice_context(queue, body)
+        {
+          queue: queue,
+          body: body.is_a?(Array) ? { batch: body } : { body: body }
+        }
+      end
+    end
+  end
+end
+
+if defined?(::Shoryuken)
+  Shoryuken.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add Airbrake::Shoryuken::ErrorHandler
+    end
+  end
+end

data/lib/airbrake/sidekiq.rb

@@ -0,0 +1,47 @@
+require 'airbrake/sidekiq/retryable_jobs_filter'
+
+module Airbrake
+  module Sidekiq
+    # Provides integration with Sidekiq v2+.
+    class ErrorHandler
+      # rubocop:disable Lint/RescueException
+      def call(_worker, context, _queue)
+        yield
+      rescue Exception => exception
+        notify_airbrake(exception, context)
+        raise exception
+      end
+      # rubocop:enable Lint/RescueException
+
+      private
+
+      def notify_airbrake(exception, context)
+        Airbrake.notify(exception, context) do |notice|
+          notice[:context][:component] = 'sidekiq'
+          notice[:context][:action] = action(context)
+        end
+      end
+
+      # @return [String] job's name. When ActiveJob is present, retrieve
+      #   job_class. When used directly, use worker's name
+      def action(context)
+        klass = context['class'] || context[:job] && context[:job]['class']
+        return klass unless context[:job] && context[:job]['args'].first.is_a?(Hash)
+        return klass unless (job_class = context[:job]['args'].first['job_class'])
+        job_class
+      end
+    end
+  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)
+  end
+end