airbrake-ruby 4.15.0 → 5.0.0.rc.1

data/lib/airbrake-ruby/sync_sender.rb

@@ -23,7 +23,7 @@ module Airbrake
     # @param [#to_json] data
     # @param [URI::HTTPS] endpoint
     # @return [Hash{String=>String}] the parsed HTTP response
-    def send(data, promise, endpoint = @config.endpoint)
+    def send(data, promise, endpoint = @config.error_endpoint)
       return promise if rate_limited_ip?(promise)
 
       response = nil

data/lib/airbrake-ruby/version.rb

@@ -2,5 +2,5 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '4.15.0'.freeze
+  AIRBRAKE_RUBY_VERSION = '5.0.0.rc.1'.freeze
 end

data/spec/airbrake_spec.rb

@@ -1,4 +1,13 @@
 RSpec.describe Airbrake do
+  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
@@ -100,10 +109,10 @@ RSpec.describe Airbrake do
     end
 
     context "when blocklist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds blocklist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        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
@@ -115,10 +124,10 @@ RSpec.describe Airbrake do
     end
 
     context "when allowlist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds allowlist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        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
@@ -130,10 +139,10 @@ RSpec.describe Airbrake do
     end
 
     context "when root_directory gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds root directory filter" do
-        expect(Airbrake.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 { |c| c.root_directory = '/my/path' }
       end
@@ -145,7 +154,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git revision filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        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
@@ -157,7 +166,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git repository filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        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
@@ -169,7 +178,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git last checkout filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        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
@@ -182,7 +191,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_request" do
+  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|
@@ -217,7 +226,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_request_sync" do
+  describe ".notify_request_sync" do
     it "notifies request synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -233,7 +242,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_query" do
+  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|
@@ -268,7 +277,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_query_sync" do
+  describe ".notify_query_sync" do
     it "notifies query synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -284,7 +293,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_performance_breakdown" do
+  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|
@@ -322,7 +331,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_performance_breakdown_sync" do
+  describe ".notify_performance_breakdown_sync" do
     it "notifies performance breakdown synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -339,7 +348,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_queue" do
+  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|
@@ -370,7 +379,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_queue_sync" do
+  describe ".notify_queue_sync" do
     it "notifies queue synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -404,33 +413,47 @@ RSpec.describe Airbrake do
   end
 
   describe ".close" do
-    after { Airbrake.reset }
+    after { described_class.reset }
 
     context "when notice_notifier is defined" do
       it "gets closed" do
-        expect(Airbrake.notice_notifier).to receive(:close)
+        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
-        Airbrake.instance_variable_set(:@notice_notifier, nil)
+        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(Airbrake.performance_notifier).to receive(:close)
+        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
-        Airbrake.instance_variable_set(:@performance_notifier, nil)
+        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 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
 end

data/spec/config/processor_spec.rb

@@ -0,0 +1,223 @@
+RSpec.describe Airbrake::Config::Processor do
+  let(:notifier) { Airbrake::NoticeNotifier.new }
+
+  describe "#process_blocklist" do
+    let(:config) { Airbrake::Config.new(blocklist_keys: %w[a b c]) }
+
+    context "when there ARE blocklist keys" do
+      it "adds the blocklist filter" do
+        described_class.new(config).process_blocklist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist)).to eq(true)
+      end
+    end
+
+    context "when there are NO blocklist keys" do
+      let(:config) { Airbrake::Config.new(blocklist_keys: %w[]) }
+
+      it "doesn't add the blocklist filter" do
+        described_class.new(config).process_blocklist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysBlocklist))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#process_allowlist" do
+    let(:config) { Airbrake::Config.new(allowlist_keys: %w[a b c]) }
+
+    context "when there ARE allowlist keys" do
+      it "adds the allowlist filter" do
+        described_class.new(config).process_allowlist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist)).to eq(true)
+      end
+    end
+
+    context "when there are NO allowlist keys" do
+      let(:config) { Airbrake::Config.new(allowlist_keys: %w[]) }
+
+      it "doesn't add the allowlist filter" do
+        described_class.new(config).process_allowlist(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::KeysAllowlist))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#process_remote_configuration" do
+    context "when the config doesn't define a project_id" do
+      let(:config) { Airbrake::Config.new(project_id: nil) }
+
+      it "doesn't set remote settings" do
+        expect(Airbrake::RemoteSettings).not_to receive(:poll)
+        described_class.new(config).process_remote_configuration
+      end
+    end
+
+    context "when the config defines a project_id" do
+      context "and when remote configuration is false" do
+        let(:config) do
+          Airbrake::Config.new(project_id: 123, __remote_configuration: false)
+        end
+
+        it "doesn't set remote settings" do
+          expect(Airbrake::RemoteSettings).not_to receive(:poll)
+          described_class.new(config).process_remote_configuration
+        end
+      end
+
+      context "and when remote configuration is true" do
+        let(:config) do
+          Airbrake::Config.new(project_id: 123, __remote_configuration: true)
+        end
+
+        it "sets remote settings" do
+          expect(Airbrake::RemoteSettings).to receive(:poll)
+          described_class.new(config).process_remote_configuration
+        end
+      end
+    end
+  end
+
+  describe "#add_filters" do
+    context "when there's a root directory" do
+      let(:config) { Airbrake::Config.new(root_directory: '/abc') }
+
+      it "adds RootDirectoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
+          .to eq(true)
+      end
+
+      it "adds GitRevisionFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
+          .to eq(true)
+      end
+
+      it "adds GitRepositoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
+          .to eq(true)
+      end
+
+      it "adds GitLastCheckoutFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
+          .to eq(true)
+      end
+    end
+
+    context "when there's NO root directory" do
+      let(:config) { Airbrake::Config.new(root_directory: nil) }
+
+      it "doesn't add RootDirectoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::RootDirectoryFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitRevisionFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRevisionFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitRepositoryFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitRepositoryFilter))
+          .to eq(false)
+      end
+
+      it "doesn't add GitLastCheckoutFilter" do
+        described_class.new(config).add_filters(notifier)
+        expect(notifier.has_filter?(Airbrake::Filters::GitLastCheckoutFilter))
+          .to eq(false)
+      end
+    end
+  end
+
+  describe "#poll_callback" do
+    let(:logger) { Logger.new(File::NULL) }
+
+    let(:config) do
+      Airbrake::Config.new(
+        project_id: 123,
+        __remote_configuration: true,
+        logger: logger,
+      )
+    end
+
+    let(:data) do
+      instance_double(Airbrake::RemoteSettings::SettingsData)
+    end
+
+    before do
+      allow(data).to receive(:to_h)
+      allow(data).to receive(:error_host)
+      allow(data).to receive(:apm_host)
+      allow(data).to receive(:error_notifications?)
+      allow(data).to receive(:performance_stats?)
+    end
+
+    it "logs given data" do
+      expect(logger).to receive(:debug).with(/applying remote settings/)
+      described_class.new(config).poll_callback(data)
+    end
+
+    it "sets the error_notifications option" do
+      config.error_notifications = false
+      expect(data).to receive(:error_notifications?).and_return(true)
+
+      described_class.new(config).poll_callback(data)
+      expect(config.error_notifications).to eq(true)
+    end
+
+    it "sets the performance_stats option" do
+      config.performance_stats = false
+      expect(data).to receive(:performance_stats?).and_return(true)
+
+      described_class.new(config).poll_callback(data)
+      expect(config.performance_stats).to eq(true)
+    end
+
+    context "when error_host returns a value" do
+      it "sets the error_host option" do
+        config.error_host = 'http://api.airbrake.io'
+        allow(data).to receive(:error_host).and_return('https://api.example.com')
+
+        described_class.new(config).poll_callback(data)
+        expect(config.error_host).to eq('https://api.example.com')
+      end
+    end
+
+    context "when error_host returns nil" do
+      it "doesn't modify the error_host option" do
+        config.error_host = 'http://api.airbrake.io'
+        allow(data).to receive(:error_host).and_return(nil)
+
+        described_class.new(config).poll_callback(data)
+        expect(config.error_host).to eq('http://api.airbrake.io')
+      end
+    end
+
+    context "when apm_host returns a value" do
+      it "sets the apm_host option" do
+        config.apm_host = 'http://api.airbrake.io'
+        allow(data).to receive(:apm_host).and_return('https://api.example.com')
+
+        described_class.new(config).poll_callback(data)
+        expect(config.apm_host).to eq('https://api.example.com')
+      end
+    end
+
+    context "when apm_host returns nil" do
+      it "doesn't modify the apm_host option" do
+        config.apm_host = 'http://api.airbrake.io'
+        allow(data).to receive(:apm_host).and_return(nil)
+
+        described_class.new(config).poll_callback(data)
+        expect(config.apm_host).to eq('http://api.airbrake.io')
+      end
+    end
+  end
+end

data/spec/config/validator_spec.rb

@@ -169,7 +169,7 @@ RSpec.describe Airbrake::Config::Validator do
         }
       end
 
-      it "returns a rejected promise" do
+      it "returns a resolved promise" do
         promise = described_class.check_notify_ability(config)
         expect(promise).to be_resolved
       end
@@ -180,5 +180,22 @@ RSpec.describe Airbrake::Config::Validator do
         described_class.check_notify_ability(config)
       end
     end
+
+    context "when the error_notifications option is false" do
+      let(:config_params) do
+        {
+          project_id: valid_id,
+          project_key: valid_key,
+          error_notifications: false,
+        }
+      end
+
+      it "returns a rejected promise" do
+        promise = described_class.check_notify_ability(config)
+        expect(promise.value).to eq(
+          'error' => "error notifications are disabled",
+        )
+      end
+    end
   end
 end