airbrake-ruby 3.2.2-java

data/spec/performance_notifier_spec.rb

@@ -0,0 +1,287 @@
+RSpec.describe Airbrake::PerformanceNotifier do
+  let(:routes) { 'https://api.airbrake.io/api/v5/projects/1/routes-stats' }
+  let(:queries) { 'https://api.airbrake.io/api/v5/projects/1/queries-stats' }
+
+  let(:config) do
+    Airbrake::Config.new(
+      project_id: 1,
+      project_key: 'banana',
+      performance_stats: true,
+      performance_stats_flush_period: 0
+    )
+  end
+
+  subject { described_class.new(config) }
+
+  before do
+    stub_request(:put, routes).to_return(status: 200, body: '')
+    stub_request(:put, queries).to_return(status: 200, body: '')
+  end
+
+  describe "#notify" do
+    it "rounds time to the floor minute" do
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 0, 20, 0)
+        )
+      )
+      expect(
+        a_request(:put, routes).with(body: /"time":"2018-01-01T00:00:00\+00:00"/)
+      ).to have_been_made
+    end
+
+    it "increments routes with the same key" do
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 0, 20, 0)
+        )
+      )
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 0, 50, 0)
+        )
+      )
+      expect(
+        a_request(:put, routes).with(body: /"count":2/)
+      ).to have_been_made
+    end
+
+    it "groups routes by time" do
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 0, 49, 0),
+          end_time: Time.new(2018, 1, 1, 0, 0, 50, 0)
+        )
+      )
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 1, 49, 0),
+          end_time: Time.new(2018, 1, 1, 0, 1, 55, 0)
+        )
+      )
+      expect(
+        a_request(:put, routes).with(
+          body: %r|\A
+            {"routes":\[
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:00:00\+00:00","count":1,"sum":1000.0,
+               "sumsq":1000000.0,"tdigest":"AAAAAkA0AAAAAAAAAAAAAUR6AAAB"},
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:01:00\+00:00","count":1,"sum":6000.0,
+               "sumsq":36000000.0,"tdigest":"AAAAAkA0AAAAAAAAAAAAAUW7gAAB"}\]}
+          \z|x
+        )
+      ).to have_been_made
+    end
+
+    it "groups routes by route key" do
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 49, 0, 0),
+          end_time: Time.new(2018, 1, 1, 0, 50, 0, 0)
+        )
+      )
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'POST',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 49, 0, 0),
+          end_time: Time.new(2018, 1, 1, 0, 50, 0, 0)
+        )
+      )
+      expect(
+        a_request(:put, routes).with(
+          body: %r|\A
+            {"routes":\[
+              {"method":"GET","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:49:00\+00:00","count":1,"sum":60000.0,
+               "sumsq":3600000000.0,"tdigest":"AAAAAkA0AAAAAAAAAAAAAUdqYAAB"},
+              {"method":"POST","route":"/foo","statusCode":200,
+               "time":"2018-01-01T00:49:00\+00:00","count":1,"sum":60000.0,
+               "sumsq":3600000000.0,"tdigest":"AAAAAkA0AAAAAAAAAAAAAUdqYAAB"}\]}
+          \z|x
+        )
+      ).to have_been_made
+    end
+
+    it "returns a promise" do
+      promise = subject.notify(
+        Airbrake::Request.new(
+          method: 'GET',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 49, 0, 0)
+        )
+      )
+      expect(promise).to be_an(Airbrake::Promise)
+      expect(promise.value).to eq('' => nil)
+    end
+
+    it "doesn't send route stats when performance stats are disabled" do
+      notifier = described_class.new(
+        Airbrake::Config.new(
+          project_id: 1, project_key: '2', performance_stats: false
+        )
+      )
+      promise = notifier.notify(
+        Airbrake::Request.new(
+          method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
+        )
+      )
+      expect(a_request(:put, routes)).not_to have_been_made
+      expect(promise.value).to eq(
+        'error' => "The Performance Stats feature is disabled"
+      )
+    end
+
+    it "doesn't send route stats when current environment is ignored" do
+      notifier = described_class.new(
+        Airbrake::Config.new(
+          project_id: 1, project_key: '2', performance_stats: true,
+          environment: 'test', ignore_environments: %w[test]
+        )
+      )
+      promise = notifier.notify(
+        Airbrake::Request.new(
+          method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
+        )
+      )
+      expect(a_request(:put, routes)).not_to have_been_made
+      expect(promise.value).to eq('error' => "The 'test' environment is ignored")
+    end
+
+    describe "payload grouping" do
+      let(:flush_period) { 0.5 }
+
+      let(:config) do
+        Airbrake::Config.new(
+          project_id: 1,
+          project_key: 'banana',
+          performance_stats: true,
+          performance_stats_flush_period: flush_period
+        )
+      end
+
+      it "groups payload by performance name and sends it separately" do
+        subject.notify(
+          Airbrake::Request.new(
+            method: 'GET',
+            route: '/foo',
+            status_code: 200,
+            start_time: Time.new(2018, 1, 1, 0, 49, 0, 0)
+          )
+        )
+
+        subject.notify(
+          Airbrake::Query.new(
+            method: 'POST',
+            route: '/foo',
+            query: 'SELECT * FROM things',
+            start_time: Time.new(2018, 1, 1, 0, 49, 0, 0)
+          )
+        )
+
+        sleep(flush_period + 0.5)
+
+        expect(a_request(:put, routes)).to have_been_made
+        expect(a_request(:put, queries)).to have_been_made
+      end
+    end
+
+    context "when an ignore filter was defined" do
+      before { subject.add_filter(&:ignore!) }
+
+      it "doesn't notify airbrake of requests" do
+        subject.notify(
+          Airbrake::Request.new(
+            method: 'GET',
+            route: '/foo',
+            status_code: 200,
+            start_time: Time.new(2018, 1, 1, 0, 49, 0, 0)
+          )
+        )
+        expect(a_request(:put, routes)).not_to have_been_made
+      end
+
+      it "doesn't notify airbrake of queries" 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)
+          )
+        )
+        expect(a_request(:put, queries)).not_to have_been_made
+      end
+    end
+
+    context "when a filter that modifies payload was defined" do
+      before do
+        subject.add_filter do |resource|
+          resource.route = '[Filtered]'
+        end
+      end
+
+      it "notifies airbrake with modified payload" 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)
+          )
+        )
+        expect(
+          a_request(:put, queries).with(
+            body: /\A{"queries":\[{"method":"POST","route":"\[Filtered\]"/
+          )
+        ).to have_been_made
+      end
+    end
+  end
+
+  describe "#delete_filter" do
+    let(:filter) do
+      Class.new do
+        def call(resource)
+          resource.ignore!
+        end
+      end
+    end
+
+    before { subject.add_filter(filter.new) }
+
+    it "deletes a filter" do
+      subject.delete_filter(filter)
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'POST',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new(2018, 1, 1, 0, 49, 0, 0)
+        )
+      )
+      expect(a_request(:put, routes)).to have_been_made
+    end
+  end
+end

data/spec/promise_spec.rb

@@ -0,0 +1,165 @@
+RSpec.describe Airbrake::Promise do
+  describe ".then" do
+    let(:resolved_with) { [] }
+    let(:rejected_with) { [] }
+
+    context "when it is not resolved" do
+      it "returns self" do
+        expect(subject.then {}).to eq(subject)
+      end
+
+      it "doesn't call the resolve callbacks yet" do
+        subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+        expect(resolved_with).to be_empty
+      end
+    end
+
+    context "when it is resolved" do
+      shared_examples "then specs" do
+        it "returns self" do
+          expect(subject.then {}).to eq(subject)
+        end
+
+        it "yields the resolved value" do
+          yielded = nil
+          subject.then { |value| yielded = value }
+          expect(yielded).to eq('id' => '123')
+        end
+
+        it "calls the resolve callbacks" do
+          expect(resolved_with).to match_array([1, 2])
+        end
+
+        it "doesn't call the reject callbacks" do
+          expect(rejected_with).to be_empty
+        end
+      end
+
+      context "and there are some resolve and reject callbacks in place" do
+        before do
+          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          subject.resolve('id' => '123')
+        end
+
+        include_examples "then specs"
+
+        it "registers the resolve callbacks" do
+          subject.resolve('id' => '456')
+          expect(resolved_with).to match_array([1, 2, 1, 2])
+        end
+      end
+
+      context "and additional then callbacks are added" do
+        before do
+          subject.resolve('id' => '123')
+          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+        end
+
+        include_examples "then specs"
+
+        it "doesn't register new resolve callbacks" do
+          subject.resolve('id' => '456')
+          expect(resolved_with).to match_array([1, 2])
+        end
+      end
+    end
+  end
+
+  describe ".rescue" do
+    let(:resolved_with) { [] }
+    let(:rejected_with) { [] }
+
+    context "when it is not rejected" do
+      it "returns self" do
+        expect(subject.then {}).to eq(subject)
+      end
+
+      it "doesn't call the reject callbacks yet" do
+        subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+        expect(rejected_with).to be_empty
+      end
+    end
+
+    context "when it is rejected" do
+      shared_examples "rescue specs" do
+        it "returns self" do
+          expect(subject.rescue {}).to eq(subject)
+        end
+
+        it "yields the rejected value" do
+          yielded = nil
+          subject.rescue { |value| yielded = value }
+          expect(yielded).to eq('bingo')
+        end
+
+        it "doesn't call the resolve callbacks" do
+          expect(resolved_with).to be_empty
+        end
+
+        it "calls the reject callbacks" do
+          expect(rejected_with).to match_array([1, 2])
+        end
+      end
+
+      context "and there are some resolve and reject callbacks in place" do
+        before do
+          subject.then { resolved_with << 1 }.then { resolved_with << 2 }
+          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+          subject.reject('bingo')
+        end
+
+        include_examples "rescue specs"
+
+        it "registers the reject callbacks" do
+          subject.reject('bingo again')
+          expect(rejected_with).to match_array([1, 2, 1, 2])
+        end
+      end
+
+      context "and additional reject callbacks are added" do
+        before do
+          subject.reject('bingo')
+          subject.rescue { rejected_with << 1 }.rescue { rejected_with << 2 }
+        end
+
+        include_examples "rescue specs"
+
+        it "doesn't register new reject callbacks" do
+          subject.reject('bingo again')
+          expect(rejected_with).to match_array([1, 2])
+        end
+      end
+    end
+  end
+
+  describe ".resolve" do
+    it "returns self" do
+      expect(subject.resolve(1)).to eq(subject)
+    end
+
+    it "executes callbacks attached with .then" do
+      array = []
+      subject.then { |notice_id| array << notice_id }.rescue { array << 999 }
+
+      expect(array.size).to be_zero
+      subject.resolve(1)
+      expect(array).to match_array([1])
+    end
+  end
+
+  describe ".reject" do
+    it "returns self" do
+      expect(subject.reject(1)).to eq(subject)
+    end
+
+    it "executes callbacks attached with .rescue" do
+      array = []
+      subject.then { array << 1 }.rescue { |error| array << error }
+
+      expect(array.size).to be_zero
+      subject.reject(999)
+      expect(array).to match_array([999])
+    end
+  end
+end