dfg-airbrake 5.6.2

data/spec/airbrake_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake do
+  describe ".add_rack_builder" do
+    let :builder do
+      proc { |_, _| nil }
+    end
+
+    after { Airbrake::Rack::NoticeBuilder.builders.delete(builder) }
+
+    it "adds new builder to the chain" do
+      expect { Airbrake.add_rack_builder(&builder) }.to change {
+        Airbrake::Rack::NoticeBuilder.builders.count
+      }.by(1)
+    end
+  end
+end

data/spec/apps/rack/dummy_app.rb

@@ -0,0 +1,17 @@
+DummyApp = Rack::Builder.new do
+  use Rack::ShowExceptions
+  use Airbrake::Rack::Middleware
+  use Warden::Manager
+
+  map '/' do
+    run(
+      proc do |_env|
+        [200, { 'Content-Type' => 'text/plain' }, ['Hello from index']]
+      end
+    )
+  end
+
+  map '/crash' do
+    run proc { |_env| raise AirbrakeTestError }
+  end
+end

data/spec/apps/rails/dummy_app.rb

@@ -0,0 +1,156 @@
+class DummyApp < Rails::Application
+  # Rails requires these two keys.
+  config.session_store :cookie_store, key: 'jiez4Mielu1AiHugog3shiiPhe3lai3faer'
+  config.secret_token = 'ni6aeph6aeriBiphesh8omahv6cohpue5Quah5ceiMohtuvei8'
+
+  if Gem::Version.new(Rails.version) > Gem::Version.new('3.2.0')
+    config.secret_key_base = '62773890cad9d9d584b57320f8612f8f7378a90aadcabc6ee'
+  end
+
+  # Configure a logger, without it the tests can't run.
+  vsn = Rails.version.split('').values_at(0, 2).join('')
+  log_path = File.join(File.dirname(__FILE__), 'logs', "#{vsn}.log")
+  config.logger = Logger.new(log_path)
+  Rails.logger = config.logger
+
+  config.active_support.deprecation = :stderr
+
+  config.middleware.use Warden::Manager
+
+  # In Rails 4.2.x Active Record suppresses errors raised within
+  # 'after_rollback' & 'after_commit' callbacks and only print them to the
+  # logs. In the next version, these errors will no longer be suppressed.
+  # Instead, the errors will propagate normally just like in other Active Record
+  # callbacks.
+  config.active_record.raise_in_transactional_callbacks = true if vsn == '42'
+
+  # Silences the warning, which says 'config.eager_load is set to nil'.
+  config.eager_load = false
+
+  routes.append do
+    get '/' => 'dummy#index'
+    get '/crash' => 'dummy#crash'
+    get '/notify_airbrake_helper' => 'dummy#notify_airbrake_helper'
+    get '/notify_airbrake_sync_helper' => 'dummy#notify_airbrake_sync_helper'
+    get '/active_record_after_commit' => 'dummy#active_record_after_commit'
+    get '/active_record_after_rollback' => 'dummy#active_record_after_rollback'
+    get '/active_job' => 'dummy#active_job'
+    get '/resque' => 'dummy#resque'
+    get '/delayed_job' => 'dummy#delayed_job'
+  end
+end
+
+class Book < ActiveRecord::Base
+  after_commit :raise_error_after_commit
+  after_rollback :raise_error_after_rollback
+
+  def raise_error_after_commit
+    raise AirbrakeTestError, 'after_commit'
+  end
+
+  def raise_error_after_rollback
+    raise AirbrakeTestError, 'after_rollback'
+  end
+end
+
+# ActiveJob.
+if Gem::Version.new(Rails.version) >= Gem::Version.new('4.2')
+  class BingoJob < ActiveJob::Base
+    queue_as :bingo
+
+    class BingoWrapper
+      def initialize(bingo)
+        @bingo = bingo
+      end
+    end
+
+    def perform(*_args)
+      @wrapper = BingoWrapper.new(self)
+      raise AirbrakeTestError, 'active_job error'
+    end
+  end
+end
+
+# Resque.
+class BingoWorker
+  @queue = :bingo_workers_queue
+
+  def self.perform(_bango, _bongo)
+    raise AirbrakeTestError, 'resque error'
+  end
+end
+
+# DelayedJob.
+BangoJob = Struct.new(:bingo, :bongo) do
+  def perform
+    raise AirbrakeTestError, 'delayed_job error'
+  end
+end
+
+class DummyController < ActionController::Base
+  layout 'application'
+
+  self.view_paths = [
+    ActionView::FixtureResolver.new(
+      'layouts/application.html.erb' => '<%= yield %>',
+      'dummy/index.html.erb' => 'Hello from index',
+      'dummy/notify_airbrake_helper.html.erb' => 'notify_airbrake_helper',
+      'dummy/notify_airbrake_sync_helper.html.erb' => 'notify_airbrake_helper_sync',
+      'dummy/active_record_after_commit.html.erb' => 'active_record_after_commit',
+      'dummy/active_record_after_rollback.html.erb' => 'active_record_after_rollback',
+      'dummy/active_job.html.erb' => 'active_job',
+      'dummy/resque.html.erb' => 'resque',
+      'dummy/delayed_job.html.erb' => 'delayed_job'
+    )
+  ]
+
+  def index; end
+
+  def crash
+    raise AirbrakeTestError
+  end
+
+  def notify_airbrake_helper
+    notify_airbrake(AirbrakeTestError.new)
+  end
+
+  def notify_airbrake_sync_helper
+    notify_airbrake_sync(AirbrakeTestError.new)
+  end
+
+  def active_record_after_commit
+    Book.create(title: 'Bingo')
+  end
+
+  def active_record_after_rollback
+    Book.transaction do
+      Book.create(title: 'Bango')
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  def active_job
+    BingoJob.perform_later('bango', 'bongo')
+  end
+
+  def resque
+    Resque.enqueue(BingoWorker, 'bango', 'bongo')
+  end
+
+  def delayed_job
+    Delayed::Job.enqueue(BangoJob.new('bingo', 'bongo'))
+  end
+end
+
+# Initializes middlewares and such.
+DummyApp.initialize!
+
+ActiveRecord::Base.connection.create_table(:books) do |t|
+  t.string(:title)
+end
+
+ActiveRecord::Migration.verbose = false
+require 'generators/delayed_job/templates/migration'
+ActiveRecord::Schema.define do
+  CreateDelayedJobs.up
+end

data/spec/apps/rails/dummy_task.rake

@@ -0,0 +1,20 @@
+# Keep this before any task definitions to collect extra info about tasks.
+# Without this line the tests will fail.
+Rake::TaskManager.record_task_metadata = true
+
+namespace :bingo do
+  # This task contains *maximum* amount of information.
+  desc 'Dummy description'
+  task :bango, [:dummy_arg] => [:environment] do |_t, _args|
+    raise AirbrakeTestError
+  end
+
+  # This task contains *minimum* amount of information.
+  task :bongo do
+    raise AirbrakeTestError
+  end
+
+  task :environment do
+    # No-op.
+  end
+end

data/spec/apps/sinatra/composite_app/sinatra_app1.rb

@@ -0,0 +1,11 @@
+require 'sinatra/base'
+
+class SinatraApp1 < Sinatra::Base
+  get('/') { raise AirbrakeTestError }
+end
+
+Airbrake.configure(SinatraApp1) do |c|
+  c.project_id = 113743
+  c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
+  c.logger = Logger.new('/dev/null')
+end

data/spec/apps/sinatra/composite_app/sinatra_app2.rb

@@ -0,0 +1,11 @@
+require 'sinatra/base'
+
+class SinatraApp2 < Sinatra::Base
+  get('/') { raise AirbrakeTestError }
+end
+
+Airbrake.configure(SinatraApp2) do |c|
+  c.project_id = 99123
+  c.project_key = 'ad04e13d806a90f96614ad8e529b2821'
+  c.logger = Logger.new('/dev/null')
+end

data/spec/apps/sinatra/dummy_app.rb

@@ -0,0 +1,12 @@
+class DummyApp < Sinatra::Base
+  use Airbrake::Rack::Middleware
+  use Warden::Manager
+
+  get '/' do
+    'Hello from index'
+  end
+
+  get '/crash' do
+    raise AirbrakeTestError
+  end
+end

data/spec/integration/rack/rack_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'integration/shared_examples/rack_examples'
+
+RSpec.describe "Rack integration specs" do
+  let(:app) { DummyApp }
+
+  include_examples 'rack examples'
+
+  describe "context payload" do
+    it "includes version" do
+      get '/crash'
+      wait_for_a_request_with_body(
+        /"context":{.*"version":"1.2.3 Rack\.version.+Rack\.release/
+      )
+    end
+  end
+end

data/spec/integration/rails/rails_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+require 'integration/shared_examples/rack_examples'
+
+RSpec.describe "Rails integration specs" do
+  include Warden::Test::Helpers
+
+  let(:app) { Rails.application }
+
+  include_examples 'rack examples'
+
+  if ::Rails.version.start_with?('5.')
+    it "inserts the Airbrake Rack middleware after DebugExceptions" do
+      middlewares = Rails.configuration.middleware.middlewares.map(&:inspect)
+      own_idx = middlewares.index('Airbrake::Rack::Middleware')
+
+      expect(middlewares[own_idx - 1]).to eq('ActionDispatch::DebugExceptions')
+    end
+  else
+    it "inserts the Airbrake Rack middleware after ConnectionManagement" do
+      middlewares = Rails.configuration.middleware.middlewares.map(&:inspect)
+      own_idx = middlewares.index('Airbrake::Rack::Middleware')
+
+      expect(middlewares[own_idx - 1]).
+        to eq('ActiveRecord::ConnectionAdapters::ConnectionManagement')
+    end
+  end
+
+  shared_examples 'context payload content' do |route|
+    before do
+      login_as(OpenStruct.new(id: 1, email: 'qa@example.com', username: 'qa-dept'))
+      get(route, foo: :bar)
+    end
+
+    it "includes component information" do
+      wait_for_a_request_with_body(/"context":{.*"component":"dummy".*}/)
+    end
+
+    it "includes action information" do
+      case route
+      when '/crash'
+        wait_for_a_request_with_body(/"context":{.*"action":"crash".*}/)
+      when '/notify_airbrake_helper'
+        wait_for_a_request_with_body(
+          /"context":{.*"action":"notify_airbrake_helper".*}/
+        )
+      when '/notify_airbrake_sync_helper'
+        wait_for_a_request_with_body(
+          /"context":{.*"action":"notify_airbrake_sync_helper".*}/
+        )
+      else
+        raise 'Unknown route'
+      end
+    end
+
+    it "includes version" do
+      wait_for_a_request_with_body(/"context":{.*"version":"1.2.3 Rails/)
+    end
+
+    it "includes session" do
+      wait_for_a_request_with_body(
+        /"context":{.*"session":{.*"session_id":"\w+".*}/
+      )
+    end
+
+    it "includes params" do
+      action = route[1..-1]
+      wait_for_a_request_with_body(
+        /"context":{.*"params":{.*"controller":"dummy","action":"#{action}".*}/
+      )
+    end
+  end
+
+  describe "context payload" do
+    context "when exception reported through middleware" do
+      include_examples('context payload content', '/crash')
+    end
+
+    context "when exception reported through the notify_airbrake helper" do
+      include_examples('context payload content', '/notify_airbrake_helper')
+    end
+
+    context "when exception reported through the notify_airbrake_sync helper" do
+      include_examples('context payload content', '/notify_airbrake_sync_helper')
+    end
+  end
+
+  describe "Active Record callbacks" do
+    if Gem::Version.new(Rails.version) >= Gem::Version.new('5.1.0.alpha')
+      it "reports exceptions in after_commit callbacks" do
+        get '/active_record_after_commit'
+        wait_for(
+          a_request(:post, endpoint).
+          with(body: /"type":"AirbrakeTestError","message":"after_commit"/)
+        ).to have_been_made.twice
+      end
+
+      it "reports exceptions in after_rollback callbacks" do
+        get '/active_record_after_rollback'
+        wait_for(
+          a_request(:post, endpoint).
+          with(body: /"type":"AirbrakeTestError","message":"after_rollback"/)
+        ).to have_been_made.twice
+      end
+    else
+      it "reports exceptions in after_commit callbacks" do
+        get '/active_record_after_commit'
+        wait_for_a_request_with_body(
+          /"type":"AirbrakeTestError","message":"after_commit"/
+        )
+      end
+
+      it "reports exceptions in after_rollback callbacks" do
+        get '/active_record_after_rollback'
+        wait_for_a_request_with_body(
+          /"type":"AirbrakeTestError","message":"after_rollback"/
+        )
+      end
+    end
+  end
+
+  if Gem::Version.new(Rails.version) >= Gem::Version.new('4.2')
+    describe "ActiveJob jobs" do
+      it "reports exceptions occurring in ActiveJob workers" do
+        get '/active_job'
+        sleep 2
+
+        wait_for(
+          a_request(:post, endpoint).
+          with(body: /"message":"active_job error"/)
+        ).to have_been_made.at_least_once
+      end
+
+      it "does not raise SystemStackError" do
+        get '/active_job'
+        sleep 2
+
+        wait_for(
+          a_request(:post, endpoint).
+          with(body: /"type":"SystemStackError"/)
+        ).not_to have_been_made
+      end
+
+      context "when Airbrake is not configured" do
+        it "doesn't report errors" do
+          allow(Airbrake).to receive(:build_notice).and_return(nil)
+          allow(Airbrake).to receive(:notify)
+
+          # Make sure we don't call `build_notice` more than 1 time. Rack
+          # integration will try to handle error 500 and we want to prevent
+          # that: https://github.com/airbrake/airbrake/pull/583
+          allow_any_instance_of(Airbrake::Rack::Middleware).to(
+            receive(:notify_airbrake).
+            and_return(nil)
+          )
+
+          get '/active_job'
+          sleep 2
+
+          wait_for(
+            a_request(:post, endpoint).
+            with(body: /"message":"active_job error"/)
+          ).not_to have_been_made
+
+          expect(Airbrake).to have_received(:build_notice)
+          expect(Airbrake).not_to have_received(:notify)
+        end
+      end
+    end
+  end
+
+  describe "Resque workers" do
+    it "reports exceptions occurring in Resque workers" do
+      with_resque { get '/resque' }
+
+      wait_for_a_request_with_body(
+        /"message":"resque\serror".*"params":{.*
+         "class":"BingoWorker","args":\["bango","bongo"\].*}/x
+      )
+    end
+  end
+
+  # Delayed Job doesn't support Ruby 1.9.2
+  if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('1.9.2')
+    describe "DelayedJob jobs" do
+      it "reports exceptions occurring in DelayedJob jobs" do
+        get '/delayed_job'
+        sleep 2
+
+        wait_for_a_request_with_body(
+          %r("message":"delayed_job\serror".*"params":{.*
+           "handler":"---\s!ruby/struct:BangoJob\\nbingo:\s
+                     bingo\\nbongo:\sbongo\\n".*})x
+        )
+
+        # Two requests are performed during this example. We care only about one.
+        # Sleep guarantees that we let the unimportant request occur here and not
+        # elsewhere.
+        sleep 2
+      end
+    end
+  end
+
+  describe "notice payload when a user is authenticated without Warden" do
+    context "when the current_user method is defined" do
+      it "contains the user information" do
+        user = OpenStruct.new(id: 1, email: 'qa@example.com', username: 'qa-dept')
+        allow_any_instance_of(DummyController).to receive(:current_user) { user }
+
+        get '/crash'
+        wait_for_a_request_with_body(
+          /"user":{"id":"1","username":"qa-dept","email":"qa@example.com"}/
+        )
+      end
+    end
+  end
+end