airbrake-ruby 4.15.0 → 5.0.2

data/spec/filters/keys_allowlist_spec.rb

@@ -151,6 +151,7 @@ RSpec.describe Airbrake::Filters::KeysAllowlist do
           # thing. One is a Java exception, the other is a Ruby exception.
           # Likely a bug: https://github.com/jruby/jruby/issues/1903
           raise ex unless RUBY_ENGINE == 'jruby'
+
           expect { subject.call(notice) }.to raise_error(java.lang.StackOverflowError)
         end
       end

data/spec/filters/keys_blocklist_spec.rb

@@ -150,6 +150,16 @@ RSpec.describe Airbrake::Filters::KeysBlocklist do
           { bongo: { bish: '[Filtered]' } },
         ],
       )
+
+      it "doesn't mutate the original hash" do
+        params = { bongo: { bish: 'bash' } }
+        notice[:params] = params
+
+        blocklist = described_class.new([:bish])
+        blocklist.call(notice)
+
+        expect(params[:bongo][:bish]).to eq('bash')
+      end
     end
 
     context "and it is recursive" do

data/spec/filters/root_directory_filter_spec.rb

@@ -5,18 +5,18 @@ RSpec.describe Airbrake::Filters::RootDirectoryFilter do
   let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
 
   it "replaces root directory in the backtrace with a label" do
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     notice[:errors].first[:backtrace] = [
       { file: "/home/kyrylo/code/airbrake/ruby/spec/spec_helper.rb" },
       { file: "#{root_directory}/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb " },
       { file: "/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb" },
       { file: "#{root_directory}/gems/rspec-core-3.3.2/exe/rspec" },
     ]
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
 
     subject.call(notice)
 
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     expect(notice[:errors].first[:backtrace]).to(
       eq(
         [
@@ -27,7 +27,7 @@ RSpec.describe Airbrake::Filters::RootDirectoryFilter do
         ],
       ),
     )
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 
   it "does not filter file when it is nil" do

data/spec/filters/sql_filter_spec.rb

@@ -22,7 +22,7 @@ RSpec.describe Airbrake::Filters::SqlFilter do
 
   ALL_DIALECTS = %i[mysql postgres sqlite cassandra oracle].freeze
 
-  # rubocop:disable Metrics/LineLength
+  # rubocop:disable Layout/LineLength
   [
     {
       input: 'SELECT * FROM things;',
@@ -229,7 +229,7 @@ RSpec.describe Airbrake::Filters::SqlFilter do
   ].each do |test|
     include_examples 'query filtering', test
   end
-  # rubocop:enable Metrics/LineLength
+  # rubocop:enable Layout/LineLength
 
   [
     'COMMIT',

data/spec/notice_notifier/options_spec.rb

@@ -149,10 +149,10 @@ RSpec.describe Airbrake::NoticeNotifier do
         expect(proxied_request.header['proxy-authorization'].first)
           .to eq('Basic dXNlcjpwYXNzd29yZA==')
 
-        # rubocop:disable Metrics/LineLength
+        # rubocop:disable Layout/LineLength
         expect(proxied_request.request_line)
           .to eq("POST http://localhost:#{proxy.config[:Port]}/api/v3/projects/105138/notices HTTP/1.1\r\n")
-        # rubocop:enable Metrics/LineLength
+        # rubocop:enable Layout/LineLength
       end
     end
 

data/spec/notice_notifier_spec.rb

@@ -309,7 +309,7 @@ RSpec.describe Airbrake::NoticeNotifier do
 
         notice = subject.build_notice(Exception.new)
 
-        # rubocop:disable Metrics/LineLength
+        # rubocop:disable Layout/LineLength
         expect(notice[:errors].first[:backtrace]).to eq(
           [
             { file: 'org/jruby/RubyKernel.java', line: 998, function: 'eval' },
@@ -317,7 +317,7 @@ RSpec.describe Airbrake::NoticeNotifier do
             { file: '/ruby/stdlib/irb.rb:489', line: 489, function: 'block in eval_input' },
           ],
         )
-        # rubocop:enable Metrics/LineLength
+        # rubocop:enable Layout/LineLength
       end
     end
 

data/spec/notice_spec.rb

@@ -268,7 +268,7 @@ RSpec.describe Airbrake::Notice do
     it "sets a payload value" do
       hash = { bingo: 'bango' }
       notice[:params] = hash
-      expect(notice[:params]).to equal(hash)
+      expect(notice[:params]).to eq(hash)
     end
 
     it "raises error if notice is ignored" do

data/spec/performance_breakdown_spec.rb

@@ -3,21 +3,9 @@ RSpec.describe Airbrake::PerformanceBreakdown do
     subject do
       described_class.new(
         method: 'GET', route: '/', response_type: '', groups: {},
-        start_time: Time.now
       )
     end
 
     it { is_expected.to respond_to(:stash) }
   end
-
-  describe "#end_time" do
-    it "is always equal to start_time + 1 second by default" do
-      time = Time.now
-      performance_breakdown = described_class.new(
-        method: 'GET', route: '/', response_type: '', groups: {},
-        start_time: time
-      )
-      expect(performance_breakdown.end_time).to eq(time + 1)
-    end
-  end
 end

data/spec/performance_notifier_spec.rb

@@ -541,31 +541,6 @@ RSpec.describe Airbrake::PerformanceNotifier do
       end
     end
 
-    context "when :start_time is specified (deprecated)" do
-      before do
-        allow(Kernel).to receive(:warn)
-      end
-
-      it "uses the value of :start_time to update stat" do
-        subject.notify(
-          Airbrake::Query.new(
-            method: 'POST',
-            route: '/foo',
-            query: 'SELECT * FROM things',
-            start_time: Time.new(2018, 1, 1, 0, 49, 0, 0),
-            end_time: Time.new(2018, 1, 1, 0, 50, 0, 0),
-          ),
-        )
-        subject.close
-
-        expect(
-          a_request(:put, queries).with(
-            body: /"count":1,"sum":60000.0,"sumsq":3600000000.0/,
-          ),
-        ).to have_been_made
-      end
-    end
-
     context "when provided :timing is zero" do
       it "doesn't notify" do
         queue = Airbrake::Queue.new(queue: 'bananas', error_count: 0, timing: 0)

data/spec/query_spec.rb

@@ -2,20 +2,10 @@ RSpec.describe Airbrake::Query do
   describe "#stash" do
     subject do
       described_class.new(
-        method: 'GET', route: '/', query: '', start_time: Time.now,
+        method: 'GET', route: '/', query: '',
       )
     end
 
     it { is_expected.to respond_to(:stash) }
   end
-
-  describe "#end_time" do
-    it "is always equal to start_time + 1 second by default" do
-      time = Time.now
-      query = described_class.new(
-        method: 'GET', route: '/', query: '', start_time: time,
-      )
-      expect(query.end_time).to eq(time + 1)
-    end
-  end
 end

data/spec/queue_spec.rb

@@ -9,21 +9,9 @@ RSpec.describe Airbrake::Queue do
     it { is_expected.to respond_to(:stash) }
   end
 
-  describe "#end_time" do
-    it "is always equal to start_time + 1 second by default" do
-      time = Time.now
-      queue = described_class.new(
-        queue: 'bananas', error_count: 0, start_time: time,
-      )
-      expect(queue.end_time).to eq(time + 1)
-    end
-  end
-
   describe "#route" do
     it "always returns an empty route" do
-      queue = described_class.new(
-        queue: 'a', error_count: 0, start_time: Time.now,
-      )
+      queue = described_class.new(queue: 'a', error_count: 0)
       expect(queue.route).to be_empty
     end
   end

data/spec/remote_settings/callback_spec.rb

@@ -0,0 +1,141 @@
+RSpec.describe Airbrake::RemoteSettings::Callback do
+  describe "#call" do
+    let(:logger) { Logger.new(File::NULL) }
+
+    let(:config) do
+      Airbrake::Config.new(
+        project_id: 123,
+        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).call(data)
+    end
+
+    context "when the config disables error notifications" do
+      before do
+        config.error_notifications = false
+        allow(data).to receive(:error_notifications?).and_return(true)
+      end
+
+      it "keeps the option disabled forever" do
+        callback = described_class.new(config)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+      end
+    end
+
+    context "when the config enables error notifications" do
+      before { config.error_notifications = true }
+
+      it "can disable and enable error notifications" do
+        expect(data).to receive(:error_notifications?).and_return(false)
+
+        callback = described_class.new(config)
+        callback.call(data)
+        expect(config.error_notifications).to eq(false)
+
+        expect(data).to receive(:error_notifications?).and_return(true)
+        callback.call(data)
+        expect(config.error_notifications).to eq(true)
+      end
+    end
+
+    context "when the config disables performance_stats" do
+      before do
+        config.performance_stats = false
+        allow(data).to receive(:performance_stats?).and_return(true)
+      end
+
+      it "keeps the option disabled forever" do
+        callback = described_class.new(config)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+      end
+    end
+
+    context "when the config enables performance stats" do
+      before { config.performance_stats = true }
+
+      it "can disable and enable performance_stats" do
+        expect(data).to receive(:performance_stats?).and_return(false)
+
+        callback = described_class.new(config)
+        callback.call(data)
+        expect(config.performance_stats).to eq(false)
+
+        expect(data).to receive(:performance_stats?).and_return(true)
+        callback.call(data)
+        expect(config.performance_stats).to eq(true)
+      end
+    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).call(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).call(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).call(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).call(data)
+        expect(config.apm_host).to eq('http://api.airbrake.io')
+      end
+    end
+  end
+end

data/spec/remote_settings/settings_data_spec.rb

@@ -0,0 +1,348 @@
+RSpec.describe Airbrake::RemoteSettings::SettingsData do
+  let(:project_id) { 123 }
+
+  describe "#merge!" do
+    it "returns self" do
+      settings_data = described_class.new(project_id, {})
+      expect(settings_data.merge!({})).to eql(settings_data)
+    end
+
+    it "merges the given hash with the data" do
+      settings_data = described_class.new(project_id, {})
+      settings_data.merge!('poll_sec' => 123, 'config_route' => 'abc')
+
+      expect(settings_data.interval).to eq(123)
+      expect(settings_data.config_route(''))
+        .to eq('/abc')
+    end
+  end
+
+  describe "#interval" do
+    context "when given data has zero interval" do
+      let(:data) do
+        { 'poll_sec' => 0 }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has negative interval" do
+      let(:data) do
+        { 'poll_sec' => -1 }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has nil interval" do
+      let(:data) do
+        { 'poll_sec' => nil }
+      end
+
+      it "returns the default interval" do
+        expect(described_class.new(project_id, data).interval).to eq(600)
+      end
+    end
+
+    context "when given data has a positive interval" do
+      let(:data) do
+        { 'poll_sec' => 123 }
+      end
+
+      it "returns the interval from data" do
+        expect(described_class.new(project_id, data).interval).to eq(123)
+      end
+    end
+  end
+
+  describe "#config_route" do
+    let(:host) { 'http://example.com/' }
+
+    context "when remote config specifies a config route" do
+      let(:data) do
+        { 'config_route' => '123/cfg/321/cfg.json' }
+      end
+
+      it "returns the config route with the provided location" do
+        expect(described_class.new(project_id, data).config_route(host)).to eq(
+          'http://example.com/123/cfg/321/cfg.json',
+        )
+      end
+    end
+
+    context "when remote config DOES NOT specify a config route" do
+      it "returns the config route with the default location" do
+        expect(described_class.new(project_id, {}).config_route(host)).to eq(
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
+        )
+      end
+    end
+
+    context "when a config route is specified but is set to nil" do
+      let(:data) do
+        { 'config_route' => nil }
+      end
+
+      it "returns the config route with the default location" do
+        expect(described_class.new(project_id, data).config_route(host)).to eq(
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
+        )
+      end
+    end
+
+    context "when a config route is specified but is set to an empty string" do
+      let(:data) do
+        { 'config_route' => '' }
+      end
+
+      it "returns the route with the default instead" do
+        expect(described_class.new(project_id, data).config_route(host)).to eq(
+          "http://example.com/2020-06-18/config/#{project_id}/config.json",
+        )
+      end
+    end
+  end
+
+  describe "#error_notifications?" do
+    context "when the 'errors' setting is present" do
+      context "and when it is enabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns true" do
+          expect(described_class.new(project_id, data).error_notifications?)
+            .to eq(true)
+        end
+      end
+
+      context "and when it is disabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => false,
+              },
+            ],
+          }
+        end
+
+        it "returns false" do
+          expect(described_class.new(project_id, data).error_notifications?)
+            .to eq(false)
+        end
+      end
+    end
+
+    context "when the 'errors' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns true" do
+        expect(described_class.new(project_id, data).error_notifications?)
+          .to eq(true)
+      end
+    end
+  end
+
+  describe "#performance_stats?" do
+    context "when the 'apm' setting is present" do
+      context "and when it is enabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns true" do
+          expect(described_class.new(project_id, data).performance_stats?)
+            .to eq(true)
+        end
+      end
+
+      context "and when it is disabled" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => false,
+              },
+            ],
+          }
+        end
+
+        it "returns false" do
+          expect(described_class.new(project_id, data).performance_stats?)
+            .to eq(false)
+        end
+      end
+    end
+
+    context "when the 'apm' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns true" do
+        expect(described_class.new(project_id, data).performance_stats?)
+          .to eq(true)
+      end
+    end
+  end
+
+  describe "#error_host" do
+    context "when the 'errors' setting is present" do
+      context "and when 'endpoint' is specified" do
+        let(:endpoint) { 'https://api.example.com/' }
+
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+                'endpoint' => endpoint,
+              },
+            ],
+          }
+        end
+
+        it "returns the endpoint" do
+          expect(described_class.new(project_id, data).error_host).to eq(endpoint)
+        end
+      end
+
+      context "and when an endpoint is NOT specified" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'errors',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns nil" do
+          expect(described_class.new(project_id, data).error_host).to be_nil
+        end
+      end
+    end
+
+    context "when the 'errors' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns nil" do
+        expect(described_class.new(project_id, data).error_host).to be_nil
+      end
+    end
+  end
+
+  describe "#apm_host" do
+    context "when the 'apm' setting is present" do
+      context "and when 'endpoint' is specified" do
+        let(:endpoint) { 'https://api.example.com/' }
+
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+                'endpoint' => endpoint,
+              },
+            ],
+          }
+        end
+
+        it "returns the endpoint" do
+          expect(described_class.new(project_id, data).apm_host).to eq(endpoint)
+        end
+      end
+
+      context "and when an endpoint is NOT specified" do
+        let(:data) do
+          {
+            'settings' => [
+              {
+                'name' => 'apm',
+                'enabled' => true,
+              },
+            ],
+          }
+        end
+
+        it "returns nil" do
+          expect(described_class.new(project_id, data).apm_host).to be_nil
+        end
+      end
+    end
+
+    context "when the 'apm' setting is missing" do
+      let(:data) do
+        { 'settings' => [] }
+      end
+
+      it "returns nil" do
+        expect(described_class.new(project_id, data).apm_host).to be_nil
+      end
+    end
+  end
+
+  describe "#to_h" do
+    let(:data) do
+      {
+        'poll_sec' => 123,
+        'settings' => [
+          {
+            'name' => 'apm',
+            'enabled' => false,
+          },
+        ],
+      }
+    end
+
+    subject { described_class.new(project_id, data) }
+
+    it "returns a hash representation of settings" do
+      expect(described_class.new(project_id, data).to_h).to eq(data)
+    end
+
+    it "doesn't allow mutation of the original data object" do
+      hash = subject.to_h
+      hash['poll_sec'] = 0
+
+      expect(subject.to_h).to eq(
+        'poll_sec' => 123,
+        'settings' => [
+          {
+            'name' => 'apm',
+            'enabled' => false,
+          },
+        ],
+      )
+    end
+  end
+end