airbrake 4.3.8 → 5.0.0.rc.1

data/lib/airbrake/rack/user.rb

@@ -0,0 +1,51 @@
+module Airbrake
+  module Rack
+    ##
+    # Represents an authenticated Warden user, which can be converted to
+    # Airbrake's payload format.
+    class User
+      # Finds the Warden user in the Rack environment and creates a new user
+      # wrapper.
+      #
+      # @param [Hash{String=>Object}] rack_env The Rack environment
+      # @return [Airbrake::Rack::User, nil]
+      def self.extract(rack_env)
+        return unless (warden = rack_env['warden'])
+        new(warden.user(run_callbacks: false))
+      end
+
+      ##
+      # @param [Warden::Proxy] warden_user
+      def initialize(warden_user)
+        @warden_user = warden_user
+      end
+
+      ##
+      # Converts the user to Airbrake payload user.
+      # @return [Hash{Symbol=>String}] the hash with retrieved user details
+      def to_hash
+        user = {}
+
+        user[:id] = try_to_get(:id)
+        user[:name] = full_name
+        user[:username] = try_to_get(:username)
+        user[:email] = try_to_get(:email)
+
+        user = user.delete_if { |_key, val| val.nil? }
+        user.empty? ? user : { user: user }
+      end
+
+      private
+
+      def try_to_get(key)
+        String(@warden_user.__send__(key)) if @warden_user.respond_to?(key)
+      end
+
+      def full_name
+        # Try to get first and last names. If that fails, try to get just 'name'.
+        name = [try_to_get(:first_name), try_to_get(:last_name)].compact.join(' ')
+        name.empty? ? try_to_get(:name) : name
+      end
+    end
+  end
+end

data/lib/airbrake/rails/action_controller.rb

@@ -0,0 +1,35 @@
+module Airbrake
+  module Rails
+    ##
+    # Contains helper methods that can be used inside Rails controllers to send
+    # notices to Airbrake. The main benefit of using them instead of the direct
+    # API is that they automatically add information from the Rack environment
+    # to notices.
+    module ActionController
+      private
+
+      ##
+      # A helper method for sending notices to Airbrake *asynchronously*.
+      # Attaches information from the Rack env.
+      # @see Airbrake#notify, #notify_airbrake_sync
+      def notify_airbrake(exception, parameters = {}, notifier = :default)
+        Airbrake.notify(build_notice(exception), parameters, notifier)
+      end
+
+      ##
+      # A helper method for sending notices to Airbrake *synchronously*.
+      # Attaches information from the Rack env.
+      # @see Airbrake#notify_sync, #notify_airbrake
+      def notify_airbrake_sync(exception, parameters = {}, notifier = :default)
+        Airbrake.notify_sync(build_notice(exception), parameters, notifier)
+      end
+
+      ##
+      # @param [Exception] exception
+      # @return [Airbrake::Notice] the notice with information from the Rack env
+      def build_notice(exception)
+        Airbrake::Rack::NoticeBuilder.new(request.env).build_notice(exception)
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_job.rb

@@ -0,0 +1,23 @@
+module Airbrake
+  module Rails
+    ##
+    # Enables support for exceptions occurring in ActiveJob jobs.
+    module ActiveJob
+      extend ActiveSupport::Concern
+
+      included do
+        rescue_from(Exception) do |exception|
+          notice = Airbrake.build_notice(exception)
+
+          notice[:context][:component] = self.class.name
+          notice[:context][:action] = job_id
+
+          notice[:params] = as_json
+
+          Airbrake.notify(notice)
+          raise exception
+        end
+      end
+    end
+  end
+end

data/lib/airbrake/rails/active_record.rb

@@ -0,0 +1,40 @@
+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
+      ##
+      # @return [Array<Symbol>] the hooks that needs fixing
+      KINDS = [:commit, :rollback].freeze
+
+      ##
+      # 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 KINDS.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,61 @@
+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 =~ /\A5\./
+          # Avoid the warning about deprecated strings.
+          app.config.middleware.insert_after(
+            ActionDispatch::DebugExceptions, Airbrake::Rack::Middleware
+          )
+        else
+          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
+    end
+  end
+end

data/lib/airbrake/rake/task_ext.rb

@@ -0,0 +1,61 @@
+# 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_method :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
+      notice = Airbrake.build_notice(ex)
+      notice[:context][:component] = 'rake'
+      notice[:context][:action] = name
+      notice[:params] = {
+        rake_task: task_info,
+        execute_args: args,
+        argv: ARGV.join(' ')
+      }
+
+      Airbrake.notify(notice)
+      raise ex
+    end
+    # rubocop:enable Lint/RescueException
+
+    private
+
+    # 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,93 @@
+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")
+
+    puts <<OUTPUT
+[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
+
+  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('=')])
+    end
+
+    id = heroku_env['AIRBRAKE_PROJECT_ID']
+    key = heroku_env['AIRBRAKE_API_KEY']
+
+    exit!(1) if [id, key].any?(&:nil?)
+
+    url = "https://airbrake.io/api/v3/projects/#{id}/heroku-deploys?key=#{key}"
+
+    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

@@ -1,3 +1,6 @@
+##
+# We use Semantic Versioning v2.0.0
+# More information: http://semver.org/
 module Airbrake
-  VERSION = "4.3.8".freeze
+  AIRBRAKE_VERSION = '5.0.0.rc.1'.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