airbrake-ruby 5.1.1-java → 6.0.1-java

data/lib/airbrake-ruby.rb

@@ -58,6 +58,7 @@ require 'airbrake-ruby/benchmark'
 require 'airbrake-ruby/monotonic_time'
 require 'airbrake-ruby/timed_trace'
 require 'airbrake-ruby/queue'
+require 'airbrake-ruby/context'
 
 # Airbrake is a thin wrapper around instances of the notifier classes (such as
 # notice, performance & deploy notifiers). It creates a way to access them via a
@@ -273,7 +274,7 @@ module Airbrake
     #   Airbrake.notify('App crashed!') #=> raises Airbrake::Error
     #
     # @return [nil]
-    # rubocop:disable Style/IfUnlessModifier, Metrics/CyclomaticComplexity
+    # rubocop:disable Style/IfUnlessModifier
     def close
       if defined?(@notice_notifier) && @notice_notifier
         @notice_notifier.close
@@ -289,7 +290,7 @@ module Airbrake
 
       nil
     end
-    # rubocop:enable Style/IfUnlessModifier, Metrics/CyclomaticComplexity
+    # rubocop:enable Style/IfUnlessModifier
 
     # Pings the Airbrake Deploy API endpoint about the occurred deploy.
     #

data/spec/airbrake_spec.rb

@@ -30,11 +30,9 @@ RSpec.describe Airbrake do
 
     it "yields the config" do
       expect do |b|
-        begin
-          described_class.configure(&b)
-        rescue Airbrake::Error
-          nil
-        end
+        described_class.configure(&b)
+      rescue Airbrake::Error
+        nil
       end.to yield_with_args(Airbrake::Config)
     end
 
@@ -62,26 +60,26 @@ RSpec.describe Airbrake do
 
     context "when called multiple times" do
       it "doesn't overwrite performance notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         performance_notifier = described_class.performance_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.performance_notifier).to eql(performance_notifier)
       end
 
       it "doesn't overwrite notice notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         notice_notifier = described_class.notice_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.notice_notifier).to eql(notice_notifier)
       end
 
       it "doesn't overwrite deploy notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         deploy_notifier = described_class.deploy_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.deploy_notifier).to eql(deploy_notifier)
       end
 
@@ -91,20 +89,24 @@ RSpec.describe Airbrake do
           c.project_key = '2'
         end
 
-        expect(described_class.notice_notifier).not_to receive(:add_filter)
-        10.times { described_class.configure {} }
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
+        10.times { described_class.configure { anything } }
+
+        expect(described_class.notice_notifier).not_to have_received(:add_filter)
       end
 
       it "appends some default filters" do
         allow(described_class.notice_notifier).to receive(:add_filter)
-        expect(described_class.notice_notifier).to receive(:add_filter).with(
-          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
-        )
 
         described_class.configure do |c|
           c.project_id = 1
           c.project_key = '2'
         end
+
+        expect(described_class.notice_notifier).to have_received(:add_filter).with(
+          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
+        )
       end
     end
 
@@ -112,14 +114,21 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds blocklist filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
       end
 
       it "initializes blocklist with specified parameters" do
-        expect(Airbrake::Filters::KeysBlocklist).to receive(:new).with(%w[password])
+        allow(Airbrake::Filters::KeysBlocklist).to receive(:new)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(Airbrake::Filters::KeysBlocklist)
+          .to have_received(:new).with(%w[password])
       end
     end
 
@@ -127,14 +136,17 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds allowlist filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
         described_class.configure { |c| c.allowlist_keys = %w[banana] }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
       end
 
       it "initializes allowlist with specified parameters" do
-        expect(Airbrake::Filters::KeysAllowlist).to receive(:new).with(%w[banana])
+        allow(Airbrake::Filters::KeysAllowlist).to receive(:new)
+
         described_class.configure { |c| c.allowlist_keys = %w[banana] }
+        expect(Airbrake::Filters::KeysAllowlist)
+          .to have_received(:new).with(%w[banana])
       end
     end
 
@@ -142,77 +154,90 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds root directory filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
       end
 
       it "initializes root directory filter with specified path" do
-        expect(Airbrake::Filters::RootDirectoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::RootDirectoryFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::RootDirectoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git revision filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
       end
 
       it "initializes git revision filter with correct root directory" do
-        expect(Airbrake::Filters::GitRevisionFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRevisionFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRevisionFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git repository filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
       end
 
       it "initializes git repository filter with correct root directory" do
-        expect(Airbrake::Filters::GitRepositoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRepositoryFilter).to receive(:new)
+
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRepositoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git last checkout filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
       end
 
       it "initializes git last checkout filter with correct root directory" do
-        expect(Airbrake::Filters::GitLastCheckoutFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitLastCheckoutFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitLastCheckoutFilter)
+          .to have_received(:new).with('/my/path')
       end
     end
   end
 
   describe ".notify_request" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the request" do
-        expect(described_class.performance_notifier).to receive(:notify) do |request|
-          expect(request.stash).to be_empty
-        end
-
         described_class.notify_request(
           method: 'GET',
           route: '/',
           status_code: 200,
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the request" do
-        expect(described_class.performance_notifier).to receive(:notify) do |request|
-          expect(request.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_request(
           {
             method: 'GET',
@@ -222,13 +247,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_request_sync" do
     it "notifies request synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_request_sync(
         {
@@ -239,31 +270,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_query" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the query" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the query" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_query(
           {
             method: 'GET',
@@ -273,13 +308,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_query_sync" do
     it "notifies query synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_query_sync(
         {
@@ -290,33 +331,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_performance_breakdown" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the performance breakdown" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
-      end
-    end
 
-    context "when :stash key is provided" do
-      it "adds the value as the stash of the performance breakdown" do
         expect(
           described_class.performance_notifier,
-        ).to receive(:notify) do |performance_breakdown|
-          expect(performance_breakdown.stash).to eq(request_id: 1)
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
         end
+      end
+    end
 
+    context "when :stash key is provided" do
+      it "adds the value as the stash of the performance breakdown" do
         described_class.notify_performance_breakdown(
           {
             method: 'GET',
@@ -327,13 +370,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |performance_breakdown|
+          expect(performance_breakdown.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_performance_breakdown_sync" do
     it "notifies performance breakdown synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_performance_breakdown_sync(
         {
@@ -345,29 +394,33 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_queue" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the queue" do
-        expect(described_class.performance_notifier).to receive(:notify) do |queue|
-          expect(queue.stash).to be_empty
-        end
-
         described_class.notify_queue(
           queue: 'bananas',
           error_count: 10,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the queue" do
-        expect(described_class.performance_notifier).to receive(:notify) do |queue|
-          expect(queue.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_queue(
           {
             queue: 'bananas',
@@ -375,13 +428,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_queue_sync" do
     it "notifies queue synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_queue_sync(
         {
@@ -390,6 +449,8 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
@@ -412,6 +473,7 @@ RSpec.describe Airbrake do
     end
   end
 
+  # rubocop:disable RSpec/MessageSpies
   describe ".close" do
     after { described_class.reset }
 
@@ -456,4 +518,5 @@ RSpec.describe Airbrake do
       end
     end
   end
+  # rubocop:enable RSpec/MessageSpies
 end

data/spec/async_sender_spec.rb

@@ -13,18 +13,20 @@ RSpec.describe Airbrake::AsyncSender do
   end
 
   describe "#send" do
+    subject(:async_sender) { described_class.new }
+
     context "when sender has the capacity to send" do
       it "sends notices to Airbrake" do
-        2.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
+        2.times { async_sender.send(notice, Airbrake::Promise.new) }
+        async_sender.close
 
         expect(a_request(:post, endpoint)).to have_been_made.twice
       end
 
       it "returns a resolved promise" do
         promise = Airbrake::Promise.new
-        subject.send(notice, promise)
-        subject.close
+        async_sender.send(notice, promise)
+        async_sender.close
 
         expect(promise).to be_resolved
       end
@@ -40,8 +42,8 @@ RSpec.describe Airbrake::AsyncSender do
       end
 
       it "doesn't send the exceeded notices to Airbrake" do
-        15.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
+        15.times { async_sender.send(notice, Airbrake::Promise.new) }
+        async_sender.close
 
         expect(a_request(:post, endpoint)).not_to have_been_made
       end
@@ -49,9 +51,9 @@ RSpec.describe Airbrake::AsyncSender do
       it "returns a rejected promise" do
         promise = nil
         15.times do
-          promise = subject.send(notice, Airbrake::Promise.new)
+          promise = async_sender.send(notice, Airbrake::Promise.new)
         end
-        subject.close
+        async_sender.close
 
         expect(promise).to be_rejected
         expect(promise.value).to eq(

data/spec/backtrace_spec.rb

@@ -177,10 +177,13 @@ RSpec.describe Airbrake::Backtrace do
       end
 
       it "logs frames that cannot be parsed" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
+        allow(Airbrake::Loggable.instance).to receive(:error)
+
+        described_class.parse(ex)
+
+        expect(Airbrake::Loggable.instance).to have_received(:error).with(
           /can't parse 'a b c 1 23 321 .rb'/,
         )
-        described_class.parse(ex)
       end
     end
 
@@ -298,9 +301,9 @@ RSpec.describe Airbrake::Backtrace do
         it "attaches code to those frames files of which match root_directory" do
           ex = RuntimeError.new
           backtrace = [
-            project_root_path('code.rb') + ":94:in `to_json'",
-            fixture_path('notroot.txt' + ":3:in `pineapple'"),
-            project_root_path('vendor/bundle/ignored_file.rb') + ":2:in `ignore_me'",
+            "#{project_root_path('code.rb')}:94:in `to_json'",
+            fixture_path("notroot.txt:3:in `pineapple'"),
+            "#{project_root_path('vendor/bundle/ignored_file.rb')}:2:in `ignore_me'",
           ]
           ex.set_backtrace(backtrace)
           expect(described_class.parse(ex)).to eq(parsed_backtrace)
@@ -335,7 +338,7 @@ RSpec.describe Airbrake::Backtrace do
 
         it "attaches code to those frames files of which match root_directory" do
           ex = RuntimeError.new
-          ex.set_backtrace([project_root_path('code.rb') + ":94:in `to_json'"])
+          ex.set_backtrace(["#{project_root_path('code.rb')}:94:in `to_json'"])
           expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end
       end
@@ -387,9 +390,9 @@ RSpec.describe Airbrake::Backtrace do
         it "attaches code to first N frames" do
           ex = RuntimeError.new
           backtrace = [
-            project_root_path('code.rb') + ":94:in `to_json'",
-            project_root_path('code.rb') + ":95:in `to_json'",
-            project_root_path('code.rb') + ":96:in `to_json'",
+            "#{project_root_path('code.rb')}:94:in `to_json'",
+            "#{project_root_path('code.rb')}:95:in `to_json'",
+            "#{project_root_path('code.rb')}:96:in `to_json'",
           ]
           ex.set_backtrace(backtrace)
           expect(described_class.parse(ex)).to eq(parsed_backtrace)
@@ -417,7 +420,7 @@ RSpec.describe Airbrake::Backtrace do
 
         it "doesn't attach code to frames" do
           ex = RuntimeError.new
-          backtrace = [project_root_path('code.rb') + ":94:in `to_json'"]
+          backtrace = ["#{project_root_path('code.rb')}:94:in `to_json'"]
           ex.set_backtrace(backtrace)
           expect(described_class.parse(ex)).to eq(parsed_backtrace)
         end

data/spec/benchmark_spec.rb

@@ -1,4 +1,6 @@
 RSpec.describe Airbrake::Benchmark do
+  subject(:benchmark) { described_class.new }
+
   describe ".measure" do
     it "returns measured performance time" do
       expect(described_class.measure { '10' * 10 }).to be_kind_of(Numeric)
@@ -6,14 +8,14 @@ RSpec.describe Airbrake::Benchmark do
   end
 
   describe "#stop" do
-    before { subject }
+    before { benchmark }
 
     context "when called one time" do
       its(:stop) { is_expected.to eq(true) }
     end
 
     context "when called twice or more" do
-      before { subject.stop }
+      before { benchmark.stop }
 
       its(:stop) { is_expected.to eq(false) }
     end
@@ -25,7 +27,7 @@ RSpec.describe Airbrake::Benchmark do
     end
 
     context "when #stop was called" do
-      before { subject.stop }
+      before { benchmark.stop }
 
       its(:duration) { is_expected.to be > 0 }
     end