airbrake 4.3.8 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a9e654c767701024f31596525a324fd9941a284c
-  data.tar.gz: d8beec9cd6a92be3308a4cb2cf945aaea5150eab
+  metadata.gz: 444112058d438d1d60afddd2d18fe604e0056c43
+  data.tar.gz: 275985dd0bb4949f08e7d881ac74a2ce039f1351
 SHA512:
-  metadata.gz: e469080a0f94afeebb3be23db68c551a8ddd864b643436581f9711b7a1546f61977d80b69d9f220c56b6fe0d33e26afcb716a38d4d029ec6a8b2e810b6d52263
-  data.tar.gz: ad08bb1d86cbd84d056bae1e55d261b3b23be3c00712eb094360e99fbfd0e5967bbc0ce2219cc45d3e8477a420bf3d44284c648768b0570b19d39a59b2dca605
+  metadata.gz: aff3b34806a8391c5cb917cc8cd02e3de21120cec7f04d214f5b85becbb38495b4de039e952e2f76f03990da68640fcc89549151e26bb57560039493af0eb775
+  data.tar.gz: 6438d408657247dbb1d6cf93cf9c77ab9d2f9e389ec64af55d6d5dd54b8311e910ca2d91d97739d86a3b9a0492421abce818919d9fe61d377b7c20f2af5078c7

data/lib/airbrake/capistrano/tasks.rb

@@ -0,0 +1,64 @@
+require 'shellwords'
+require 'fileutils'
+
+if defined?(Capistrano::VERSION) &&
+   Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
+  namespace :airbrake do
+    desc "Notify Airbrake of the deploy"
+    task :deploy do
+      on roles(:all) do
+        within release_path do
+          with rails_env: fetch(:rails_env, fetch(:stage)) do
+            execute :rake, <<-CMD
+              airbrake:deploy USERNAME=#{Shellwords.shellescape(local_user)} \
+                              ENVIRONMENT=#{fetch(:rails_env, fetch(:stage))} \
+                              REVISION=#{fetch(:current_revision)} \
+                              REPOSITORY=#{fetch(:repo_url)} \
+                              VERSION=#{fetch(:app_version)}
+            CMD
+
+            info 'Notified Airbrake of the deploy'
+          end
+        end
+      end
+    end
+  end
+else
+  module Airbrake
+    ##
+    # The Capistrano v2 integration.
+    module Capistrano
+      # rubocop:disable Metrics/AbcSize
+      def self.load_into(config)
+        config.load do
+          after 'deploy',            'airbrake:deploy'
+          after 'deploy:migrations', 'airbrake:deploy'
+          after 'deploy:cold',       'airbrake:deploy'
+
+          namespace :airbrake do
+            desc "Notify Airbrake of the deploy"
+            task :deploy, except: { no_release: true }, on_error: :continue do
+              FileUtils.cd(config.release_path) do
+                username = Shellwords.shellescape(ENV['USER'] || ENV['USERNAME'])
+
+                system(<<-CMD)
+                  bundle exec rake airbrake:deploy \
+                    USERNAME=#{username} \
+                    ENVIRONMENT=#{fetch(:rails_env, 'production')} \
+                    REVISION=#{current_revision.strip} \
+                    REPOSITORY=#{repository} \
+                    VERSION=#{fetch(:app_version, nil)}
+                CMD
+              end
+
+              logger.info 'Notified Airbrake of the deploy'
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+
+  Airbrake::Capistrano.load_into(Capistrano::Configuration.instance)
+end

data/lib/airbrake/delayed_job/plugin.rb

@@ -0,0 +1,48 @@
+module Delayed
+  module Plugins
+    ##
+    # Provides integration with Delayed Job.
+    # rubocop:disable Lint/RescueException
+    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
+            params = job.as_json.merge(
+              component: 'delayed_job',
+              action: job.payload_object.class.name
+            )
+
+            # If DelayedJob is used through ActiveJob, it contains extra info.
+            if job.payload_object.respond_to?(:job_data)
+              params[:active_job] = job.payload_object.job_data
+            end
+
+            ::Airbrake.notify(exception, params)
+            raise exception
+          end
+        end
+      end
+    end
+    # rubocop:enable Lint/RescueException
+  end
+end
+
+if RUBY_ENGINE == 'jruby' && defined?(Delayed::Backend::ActiveRecord::Job)
+  ##
+  # Workaround against JRuby bug:
+  # https://github.com/jruby/jruby/issues/3338
+  # rubocop:disable Style/ClassAndModuleChildren
+  class Delayed::Backend::ActiveRecord::Job
+    alias_method :old_to_ary, :to_ary
+
+    def to_ary
+      old_to_ary || [self]
+    end
+  end
+  # rubocop:enable Style/ClassAndModuleChildren
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Airbrake

data/lib/airbrake/rack/middleware.rb

@@ -0,0 +1,45 @@
+module Airbrake
+  module Rack
+    ##
+    # Airbrake Rack middleware for Rails and Sinatra applications (or any other
+    # Rack-compliant app). Any errors raised by the upstream application will be
+    # delivered to Airbrake and re-raised.
+    #
+    # The middleware automatically sends information about the framework that
+    # uses it (name and version).
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      ##
+      # Rescues any exceptions, sends them to Airbrake and re-raises the
+      # exception.
+      # @param [Hash] env the Rack environment
+      def call(env)
+        # rubocop:disable Lint/RescueException
+        begin
+          response = @app.call(env)
+        rescue Exception => ex
+          notify_airbrake(ex, env)
+          raise ex
+        end
+        # rubocop:enable Lint/RescueException
+
+        # The internal framework middlewares store exceptions inside the Rack
+        # env. See: https://goo.gl/Kd694n
+        exception = env['action_dispatch.exception'] || env['sinatra.error']
+        notify_airbrake(exception, env) if exception
+
+        response
+      end
+
+      private
+
+      def notify_airbrake(exception, env)
+        notice = NoticeBuilder.new(env).build_notice(exception)
+        Airbrake.notify(notice)
+      end
+    end
+  end
+end

data/lib/airbrake/rack/notice_builder.rb

@@ -0,0 +1,80 @@
+module Airbrake
+  module Rack
+    ##
+    # A helper class for filling notices with all sorts of useful information
+    # coming from the Rack environment.
+    class NoticeBuilder
+      ##
+      # @return [String] the name of the host machine
+      HOSTNAME = Socket.gethostname.freeze
+
+      ##
+      # @param [Hash{String=>Object}] rack_env The Rack environment
+      def initialize(rack_env)
+        @rack_env = rack_env
+        @request = ::Rack::Request.new(rack_env)
+        @controller = rack_env['action_controller.instance']
+        @session = @request.session
+        @user = Airbrake::Rack::User.extract(rack_env)
+
+        @framework_version =
+          if defined?(::Rails)
+            "Rails/#{::Rails.version}"
+          elsif defined?(::Sinatra)
+            "Sinatra/#{Sinatra::VERSION}"
+          else
+            "Rack.version/#{::Rack.version} Rack.release/#{::Rack.release}"
+          end.freeze
+      end
+
+      ##
+      # Adds context, session, params and other fields based on the Rack env.
+      #
+      # @param [Exception] exception
+      # @return [Airbrake::Notice] the notice with extra information
+      def build_notice(exception)
+        notice = Airbrake.build_notice(exception)
+
+        add_context(notice)
+        add_session(notice)
+        add_params(notice)
+
+        notice
+      end
+
+      private
+
+      def add_context(notice)
+        context = notice[:context]
+
+        context[:url] = @request.url
+        context[:userAgent] = @request.user_agent
+        context[:hostname] = HOSTNAME
+
+        if context.key?(:version)
+          context[:version] += " #{@framework_version}"
+        else
+          context[:version] = @framework_version
+        end
+
+        if @controller
+          context[:component] = @controller.controller_name
+          context[:action] = @controller.action_name
+        end
+
+        notice[:context].merge!(@user.to_hash) if @user
+
+        nil
+      end
+
+      def add_session(notice)
+        notice[:session] = @session if @session
+      end
+
+      def add_params(notice)
+        params = @request.env['action_dispatch.request.parameters']
+        notice[:params] = params if params
+      end
+    end
+  end
+end

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'.freeze
 end