dfg-airbrake 5.6.2

data/lib/airbrake/rails/active_job.rb

@@ -0,0 +1,35 @@
+module Airbrake
+  module Rails
+    ##
+    # Enables support for exceptions occurring in ActiveJob jobs.
+    module ActiveJob
+      extend ActiveSupport::Concern
+
+      included do
+        if ::Rails.application.config.respond_to?(:active_job)
+          active_job_cfg = ::Rails.application.config.active_job
+          is_resque_adapter = (active_job_cfg.queue_adapter == :resque)
+        end
+
+        rescue_from(Exception) do |exception|
+          if (notice = Airbrake.build_notice(exception))
+            notice[:context][:component] = 'active_job'
+            notice[:context][:action] = self.class.name
+
+            notice[:params] = serialize
+
+            # We special case Resque because it kills our workers by forking, so
+            # we use synchronous delivery instead.
+            if is_resque_adapter
+              Airbrake.notify_sync(notice)
+            else
+              Airbrake.notify(notice)
+            end
+          end
+
+          raise exception
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_record.rb

@@ -0,0 +1,36 @@
+module Airbrake
+  module Rails
+    ##
+    # Rails <4.2 has a bug with regard to swallowing exceptions in the
+    # +after_commit+ and the +after_rollback+ hooks: it doesn't bubble up
+    # exceptions from there.
+    #
+    # This module makes it possible to report exceptions occurring there.
+    #
+    # @see https://github.com/rails/rails/pull/14488 Detailed description of the
+    #   bug and the fix
+    # @see https://goo.gl/348lor Rails 4.2+ implementation (fixed)
+    # @see https://goo.gl/ddFNg7 Rails <4.2 implementation (bugged)
+    module ActiveRecord
+      ##
+      # Patches default +run_callbacks+ with our version, which is capable of
+      # notifying about exceptions.
+      #
+      # rubocop:disable Lint/RescueException
+      def run_callbacks(kind, *args, &block)
+        # Let the post process handle the exception if it's not a bugged hook.
+        return super unless [:commit, :rollback].include?(kind)
+
+        # Handle the exception ourselves. The 'ex' exception won't be
+        # propagated, therefore we must notify it here.
+        begin
+          super
+        rescue Exception => ex
+          Airbrake.notify(ex)
+          raise ex
+        end
+      end
+      # rubocop:enable Lint/RescueException
+    end
+  end
+end

data/lib/airbrake/rails/railtie.rb

@@ -0,0 +1,79 @@
+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.start_with?('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)
+          # 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/task_ext'
+
+        # Defines tasks such as `airbrake:test` & `airbrake:deploy`.
+        require 'airbrake/rake/tasks'
+      end
+
+      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
+        end
+      end
+
+      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
+        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
+
+      runner do
+        at_exit do
+          Airbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rake/task_ext.rb

@@ -0,0 +1,66 @@
+# 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)
+      return unless (notice = Airbrake.build_notice(exception))
+
+      notice[:context][:component] = 'rake'
+      notice[:context][:action] = name
+      notice[:params] = {
+        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,118 @@
+namespace :airbrake do
+  desc 'Verify your gem installation by sending a test exception'
+  task test: :environment do
+    require 'pp'
+
+    begin
+      raise StandardError, 'Exception from the test Rake task'
+    rescue => ex
+      response = Airbrake.notify_sync(ex)
+    end
+
+    notifiers = Airbrake.instance_variable_get(:@notifiers).map do |name, notif|
+      cfg = notif.instance_variable_get(:@config)
+      filters = notif.instance_variable_get(:@filter_chain)
+      "#{name}:\n  " + [cfg, filters].pretty_inspect
+    end.join("\n")
+
+    if !response
+      puts <<-NORESPONSE.gsub(/^\s+\|/, '')
+        |Couldn't send a test exception. There are two reasons for this:
+        |
+        |1. Airbrake ignored this exception due to misconfigured filters
+        |2. Airbrake was configured to ignore the '#{Rails.env}' environment.
+        |   To fix this try one of the following:
+        |     * specify another environment via RAILS_ENV
+        |     * temporarily unignore the '#{Rails.env}' environment
+      NORESPONSE
+    elsif response['error']
+      puts <<-ERROR.gsub(/^\s+\|/, '')
+        |Error occurred: #{response['error']}
+        |Make sure that your Project ID and Project Key are correct:
+        |https://github.com/airbrake/airbrake-ruby#project_id--project_key
+      ERROR
+    else
+      puts <<-OUTPUT.gsub(/^\s+\|/, '')
+        |[ruby]
+        |description: #{RUBY_DESCRIPTION}
+        |
+        |#{if defined?(Rails)
+             "[rails]\nversion: #{Rails::VERSION::STRING}"
+           elsif defined?(Sinatra)
+             "[sinatra]\nversion: #{Sinatra::VERSION}"
+           end}
+        |
+        |[airbrake]
+        |version: #{Airbrake::AIRBRAKE_VERSION}
+        |
+        |[airbrake-ruby]
+        |version: #{Airbrake::Notice::NOTIFIER[:version]}
+        |
+        |[notifiers]
+        |#{notifiers}
+        |
+        |The output above contains useful information about your environment. Our support
+        |team may request this information if you have problems using the Airbrake gem;
+        |we would be really grateful if you could attach the output to your message.
+        |
+        |The test exception was sent. Find it here: #{response['url']}
+      OUTPUT
+    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?
+        load initializer
+      else
+        Rake::Task[:environment].invoke
+      end
+    end
+
+    Airbrake.create_deploy(
+      environment: ENV['ENVIRONMENT'],
+      username: ENV['USERNAME'],
+      revision: ENV['REVISION'],
+      repository: ENV['REPOSITORY'],
+      version: ENV['VERSION']
+    )
+  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
+
+    url = "https://airbrake.io/api/v3/projects/#{id}/heroku-deploys?key=#{key}"
+    url << "&environment=#{env}"
+
+    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/failure.rb

@@ -0,0 +1,19 @@
+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
+        params = payload.merge(
+          component: 'resque',
+          action: payload['class'].to_s
+        )
+
+        ::Airbrake.notify_sync(exception, params)
+      end
+    end
+  end
+end

data/lib/airbrake/sidekiq/error_handler.rb

@@ -0,0 +1,35 @@
+module Airbrake
+  module Sidekiq
+    ##
+    # Provides integration with Sidekiq 2 and Sidekiq 3.
+    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)
+        params = context.merge(component: 'sidekiq', action: context['class'])
+        Airbrake.notify(exception, params)
+      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

data/lib/airbrake/version.rb

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

data/lib/generators/airbrake_generator.rb

@@ -0,0 +1,25 @@
+##
+# Creates the Airbrake initializer file for Rails apps.
+#
+# @example Invokation from terminal
+#   rails generate airbrake PROJECT_KEY PROJECT_ID [NAME]
+#
+class AirbrakeGenerator < Rails::Generators::Base
+  # Adds current directory to source paths, so we can find the template file.
+  source_root File.expand_path('..', __FILE__)
+
+  argument :project_id, required: false
+  argument :project_key, required: false
+
+  ##
+  # Makes the NAME option optional, which allows to subclass from Base, so we
+  # can pass arguments to the ERB template.
+  #
+  # @see http://asciicasts.com/episodes/218-making-generators-in-rails-3
+  argument :name, type: :string, default: 'application'
+
+  desc 'Configures the Airbrake notifier with your project id and project key'
+  def generate_layout
+    template 'airbrake_initializer.rb.erb', 'config/initializers/airbrake.rb'
+  end
+end

data/lib/generators/airbrake_initializer.rb.erb

@@ -0,0 +1,68 @@
+# Airbrake is an online tool that provides robust exception tracking in your Rails
+# applications. In doing so, it allows you to easily review errors, tie an error
+# to an individual piece of code, and trace the cause back to recent
+# changes. Airbrake enables for easy categorization, searching, and prioritization
+# of exceptions so that when errors occur, your team can quickly determine the
+# root cause.
+#
+# Configuration details:
+# https://github.com/airbrake/airbrake-ruby#configuration
+Airbrake.configure do |c|
+  # You must set both project_id & project_key. To find your project_id and
+  # project_key navigate to your project's General Settings and copy the values
+  # from the right sidebar.
+  # https://github.com/airbrake/airbrake-ruby#project_id--project_key
+<% if project_id -%>
+  c.project_id = <%= project_id %>
+<% else -%>
+  c.project_id = ENV['AIRBRAKE_PROJECT_ID']
+<% end -%>
+<% if project_key -%>
+  c.project_key = '<%= project_key %>'
+<% else -%>
+  c.project_key = ENV['AIRBRAKE_API_KEY']
+<% end -%>
+
+  # Configures the root directory of your project. Expects a String or a
+  # Pathname, which represents the path to your project. Providing this option
+  # helps us to filter out repetitive data from backtrace frames and link to
+  # GitHub files from our dashboard.
+  # https://github.com/airbrake/airbrake-ruby#root_directory
+  c.root_directory = Rails.root
+
+  # By default, Airbrake Ruby outputs to STDOUT. In Rails apps it makes sense to
+  # use the Rails' logger.
+  # https://github.com/airbrake/airbrake-ruby#logger
+  c.logger = Rails.logger
+
+  # Configures the environment the application is running in. Helps the Airbrake
+  # dashboard to distinguish between exceptions occurring in different
+  # environments. By default, it's not set.
+  # NOTE: This option must be set in order to make the 'ignore_environments'
+  # option work.
+  # https://github.com/airbrake/airbrake-ruby#environment
+  c.environment = Rails.env
+
+  # Setting this option allows Airbrake to filter exceptions occurring in
+  # unwanted environments such as :test. By default, it is equal to an empty
+  # Array, which means Airbrake Ruby sends exceptions occurring in all
+  # environments.
+  # NOTE: This option *does not* work if you don't set the 'environment' option.
+  # https://github.com/airbrake/airbrake-ruby#ignore_environments
+  c.ignore_environments = %w(test)
+
+  # A list of parameters that should be filtered out of what is sent to
+  # Airbrake. By default, all "password" attributes will have their contents
+  # replaced.
+  # https://github.com/airbrake/airbrake-ruby#blacklist_keys
+  c.blacklist_keys = [/password/i]
+
+  # Alternatively, you can integrate with Rails' filter_parameters.
+  # Read more: https://goo.gl/gqQ1xS
+  # c.blacklist_keys = Rails.application.config.filter_parameters
+end
+
+# If Airbrake doesn't send any expected exceptions, we suggest to uncomment the
+# line below. It might simplify debugging of background Airbrake workers, which
+# can silently die.
+# Thread.abort_on_exception = ['test', 'development'].include?(Rails.env)