airbrake-ruby 4.1.0 → 5.0.0

data/spec/airbrake_spec.rb

@@ -1,7 +1,33 @@
 RSpec.describe Airbrake do
-  before { Airbrake::Config.instance = Airbrake::Config.new }
+  let(:remote_settings) { instance_double(Airbrake::RemoteSettings) }
+
+  before do
+    allow(Airbrake::RemoteSettings).to receive(:poll).and_return(remote_settings)
+    allow(remote_settings).to receive(:stop_polling)
+  end
+
+  after { described_class.instance_variable_set(:@remote_settings, nil) }
+
+  it "gets initialized with a performance notifier" do
+    expect(described_class.performance_notifier).not_to be_nil
+  end
+
+  it "gets initialized with a notice notifier" do
+    expect(described_class.notice_notifier).not_to be_nil
+  end
+
+  it "gets initialized with a deploy notifier" do
+    expect(described_class.deploy_notifier).not_to be_nil
+  end
 
   describe ".configure" do
+    before do
+      Airbrake::Config.instance = Airbrake::Config.new
+      described_class.reset
+    end
+
+    after { described_class.reset }
+
     it "yields the config" do
       expect do |b|
         begin
@@ -23,17 +49,410 @@ RSpec.describe Airbrake do
       expect(Airbrake::Loggable.instance).to eql(logger)
     end
 
-    context "when user config doesn't contain a project id" do
-      it "raises error" do
-        expect { described_class.configure { |c| c.project_key = '1' } }
-          .to raise_error(Airbrake::Error, ':project_id is required')
+    it "makes Airbrake configured" do
+      expect(described_class).not_to be_configured
+
+      described_class.configure do |c|
+        c.project_id = 1
+        c.project_key = '2'
+      end
+
+      expect(described_class).to be_configured
+    end
+
+    context "when called multiple times" do
+      it "doesn't overwrite performance notifier" do
+        described_class.configure {}
+        performance_notifier = described_class.performance_notifier
+
+        described_class.configure {}
+        expect(described_class.performance_notifier).to eql(performance_notifier)
+      end
+
+      it "doesn't overwrite notice notifier" do
+        described_class.configure {}
+        notice_notifier = described_class.notice_notifier
+
+        described_class.configure {}
+        expect(described_class.notice_notifier).to eql(notice_notifier)
+      end
+
+      it "doesn't overwrite deploy notifier" do
+        described_class.configure {}
+        deploy_notifier = described_class.deploy_notifier
+
+        described_class.configure {}
+        expect(described_class.deploy_notifier).to eql(deploy_notifier)
+      end
+
+      it "doesn't append the same notice notifier filters over and over" do
+        described_class.configure do |c|
+          c.project_id = 1
+          c.project_key = '2'
+        end
+
+        expect(described_class.notice_notifier).not_to receive(:add_filter)
+        10.times { described_class.configure {} }
+      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
+      end
+    end
+
+    context "when blocklist_keys gets configured" 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))
+        described_class.configure { |c| c.blocklist_keys = %w[password] }
+      end
+
+      it "initializes blocklist with specified parameters" do
+        expect(Airbrake::Filters::KeysBlocklist).to receive(:new).with(%w[password])
+        described_class.configure { |c| c.blocklist_keys = %w[password] }
+      end
+    end
+
+    context "when allowlist_keys gets configured" 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] }
+      end
+
+      it "initializes allowlist with specified parameters" do
+        expect(Airbrake::Filters::KeysAllowlist).to receive(:new).with(%w[banana])
+        described_class.configure { |c| c.allowlist_keys = %w[banana] }
+      end
+    end
+
+    context "when root_directory gets configured" 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' }
+      end
+
+      it "initializes root directory filter with specified path" do
+        expect(Airbrake::Filters::RootDirectoryFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/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' }
+      end
+
+      it "initializes git revision filter with correct root directory" do
+        expect(Airbrake::Filters::GitRevisionFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/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' }
+      end
+
+      it "initializes git repository filter with correct root directory" do
+        expect(Airbrake::Filters::GitRepositoryFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/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' }
+      end
+
+      it "initializes git last checkout filter with correct root directory" do
+        expect(Airbrake::Filters::GitLastCheckoutFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+    end
+  end
+
+  describe ".notify_request" do
+    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,
+        )
+      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',
+            route: '/',
+            status_code: 200,
+            timing: 1,
+          },
+          request_id: 1,
+        )
+      end
+    end
+  end
+
+  describe ".notify_request_sync" do
+    it "notifies request synchronously" do
+      expect(described_class.performance_notifier).to receive(:notify_sync)
+
+      described_class.notify_request_sync(
+        {
+          method: 'GET',
+          route: '/',
+          status_code: 200,
+          timing: 1,
+        },
+        request_id: 1,
+      )
+    end
+  end
+
+  describe ".notify_query" do
+    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,
+        )
+      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',
+            route: '/',
+            query: '',
+            timing: 1,
+          },
+          request_id: 1,
+        )
+      end
+    end
+  end
+
+  describe ".notify_query_sync" do
+    it "notifies query synchronously" do
+      expect(described_class.performance_notifier).to receive(:notify_sync)
+
+      described_class.notify_query_sync(
+        {
+          method: 'GET',
+          route: '/',
+          query: '',
+          timing: 1,
+        },
+        request_id: 1,
+      )
+    end
+  end
+
+  describe ".notify_performance_breakdown" do
+    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)
+        end
+
+        described_class.notify_performance_breakdown(
+          {
+            method: 'GET',
+            route: '/',
+            response_type: :html,
+            groups: {},
+            timing: 1,
+          },
+          request_id: 1,
+        )
+      end
+    end
+  end
+
+  describe ".notify_performance_breakdown_sync" do
+    it "notifies performance breakdown synchronously" do
+      expect(described_class.performance_notifier).to receive(:notify_sync)
+
+      described_class.notify_performance_breakdown_sync(
+        {
+          method: 'GET',
+          route: '/',
+          response_type: :html,
+          groups: {},
+          timing: 1,
+        },
+        request_id: 1,
+      )
+    end
+  end
+
+  describe ".notify_queue" do
+    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,
+        )
+      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',
+            error_count: 10,
+          },
+          request_id: 1,
+        )
+      end
+    end
+  end
+
+  describe ".notify_queue_sync" do
+    it "notifies queue synchronously" do
+      expect(described_class.performance_notifier).to receive(:notify_sync)
+
+      described_class.notify_queue_sync(
+        {
+          queue: 'bananas',
+          error_count: 10,
+        },
+        request_id: 1,
+      )
+    end
+  end
+
+  describe ".performance_notifier" do
+    it "returns a performance notifier" do
+      expect(described_class.performance_notifier)
+        .to be_an(Airbrake::PerformanceNotifier)
+    end
+  end
+
+  describe ".notice_notifier" do
+    it "returns a notice notifier" do
+      expect(described_class.notice_notifier).to be_an(Airbrake::NoticeNotifier)
+    end
+  end
+
+  describe ".deploy_notifier" do
+    it "returns a deploy notifier" do
+      expect(described_class.deploy_notifier).to be_an(Airbrake::DeployNotifier)
+    end
+  end
+
+  describe ".close" do
+    after { described_class.reset }
+
+    context "when notice_notifier is defined" do
+      it "gets closed" do
+        expect(described_class.notice_notifier).to receive(:close)
+      end
+    end
+
+    context "when notice_notifier is undefined" do
+      it "doesn't get closed (because it wasn't initialized)" do
+        described_class.instance_variable_set(:@notice_notifier, nil)
+        expect_any_instance_of(Airbrake::NoticeNotifier).not_to receive(:close)
+      end
+    end
+
+    context "when performance_notifier is defined" do
+      it "gets closed" do
+        expect(described_class.performance_notifier).to receive(:close)
+      end
+    end
+
+    context "when perforance_notifier is undefined" do
+      it "doesn't get closed (because it wasn't initialized)" do
+        described_class.instance_variable_set(:@performance_notifier, nil)
+        expect_any_instance_of(Airbrake::PerformanceNotifier)
+          .not_to receive(:close)
+      end
+    end
+
+    context "when remote settings are defined" do
+      it "stops polling" do
+        described_class.instance_variable_set(:@remote_settings, remote_settings)
+        expect(remote_settings).to receive(:stop_polling)
       end
     end
 
-    context "when user config doesn't contain a project key" do
-      it "raises error" do
-        expect { described_class.configure { |c| c.project_id = 1 } }
-          .to raise_error(Airbrake::Error, ':project_key is required')
+    context "when remote settings are undefined" do
+      it "doesn't stop polling (because they weren't initialized)" do
+        described_class.instance_variable_set(:@remote_settings, nil)
+        expect(remote_settings).not_to receive(:stop_polling)
       end
     end
   end

data/spec/async_sender_spec.rb

@@ -8,140 +8,56 @@ RSpec.describe Airbrake::AsyncSender do
     Airbrake::Config.instance = Airbrake::Config.new(
       project_id: '1',
       workers: 3,
-      queue_size: queue_size
+      queue_size: 10,
     )
-
-    allow(Airbrake::Loggable.instance).to receive(:debug)
-    expect(subject).to have_workers
   end
 
   describe "#send" do
-    it "sends payload to Airbrake" do
-      2.times do
-        subject.send(notice, Airbrake::Promise.new)
-      end
-      subject.close
-
-      expect(a_request(:post, endpoint)).to have_been_made.twice
-    end
-
-    context "when the queue is full" do
-      before do
-        allow(subject.unsent).to receive(:size).and_return(queue_size)
-      end
-
-      it "discards payload" do
-        200.times do
-          subject.send(notice, Airbrake::Promise.new)
-        end
+    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
 
-        expect(a_request(:post, endpoint)).not_to have_been_made
+        expect(a_request(:post, endpoint)).to have_been_made.twice
       end
 
-      it "logs discarded payload" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /reached its capacity/
-        ).exactly(15).times
-
-        15.times do
-          subject.send(notice, Airbrake::Promise.new)
-        end
+      it "returns a resolved promise" do
+        promise = Airbrake::Promise.new
+        subject.send(notice, promise)
         subject.close
-      end
-    end
-  end
-
-  describe "#close" do
-    context "when there are no unsent notices" do
-      it "joins the spawned thread" do
-        workers = subject.workers.list
-        expect(workers).to all(be_alive)
 
-        subject.close
-        expect(workers).to all(be_stop)
+        expect(promise).to be_resolved
       end
     end
 
-    context "when there are some unsent notices" do
-      it "logs how many notices are left to send" do
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(
-          /waiting to send \d+ unsent notice\(s\)/
+    context "when sender has exceeded the capacity to send" do
+      before do
+        Airbrake::Config.instance = Airbrake::Config.new(
+          project_id: '1',
+          workers: 0,
+          queue_size: 1,
         )
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(/closed/)
-
-        300.times { subject.send(notice, Airbrake::Promise.new) }
-        subject.close
       end
 
-      it "waits until the unsent notices queue is empty" do
+      it "doesn't send the exceeded notices to Airbrake" do
+        15.times { subject.send(notice, Airbrake::Promise.new) }
         subject.close
-        expect(subject.unsent.size).to be_zero
-      end
-    end
 
-    context "when it was already closed" do
-      it "doesn't increase the unsent queue size" do
-        begin
-          subject.close
-        rescue Airbrake::Error
-          nil
-        end
-
-        expect(subject.unsent.size).to be_zero
+        expect(a_request(:post, endpoint)).not_to have_been_made
       end
 
-      it "raises error" do
+      it "returns a rejected promise" do
+        promise = nil
+        15.times do
+          promise = subject.send(notice, Airbrake::Promise.new)
+        end
         subject.close
 
-        expect(subject).to be_closed
-        expect { subject.close }.to raise_error(
-          Airbrake::Error, 'attempted to close already closed sender'
+        expect(promise).to be_rejected
+        expect(promise.value).to eq(
+          'error' => "AsyncSender has reached its capacity of 1",
         )
       end
     end
-
-    context "when workers were not spawned" do
-      it "correctly closes the notifier nevertheless" do
-        subject.close
-        expect(subject).to be_closed
-      end
-    end
-  end
-
-  describe "#has_workers?" do
-    it "returns false when the sender is not closed, but has 0 workers" do
-      subject.workers.list.each do |worker|
-        worker.kill.join
-      end
-      expect(subject).not_to have_workers
-    end
-
-    it "returns false when the sender is closed" do
-      subject.close
-      expect(subject).not_to have_workers
-    end
-
-    it "respawns workers on fork()", skip: %w[jruby rbx].include?(RUBY_ENGINE) do
-      pid = fork { expect(subject).to have_workers }
-      Process.wait(pid)
-      subject.close
-      expect(subject).not_to have_workers
-    end
-  end
-
-  describe "#spawn_workers" do
-    it "spawns alive threads in an enclosed ThreadGroup" do
-      expect(subject.workers).to be_a(ThreadGroup)
-      expect(subject.workers.list).to all(be_alive)
-      expect(subject.workers).to be_enclosed
-
-      subject.close
-    end
-
-    it "spawns exactly config.workers workers" do
-      expect(subject.workers.list.size).to eq(Airbrake::Config.instance.workers)
-      subject.close
-    end
   end
 end