airbrake-ruby 4.6.0

data/spec/performance_breakdown_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Airbrake::PerformanceBreakdown do
+  describe "#stash" 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
+end

data/spec/performance_notifier_spec.rb

@@ -0,0 +1,435 @@
+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(:breakdowns) { 'https://api.airbrake.io/api/v5/projects/1/routes-breakdowns' }
+
+  before do
+    stub_request(:put, routes).to_return(status: 200, body: '')
+    stub_request(:put, queries).to_return(status: 200, body: '')
+    stub_request(:put, breakdowns).to_return(status: 200, body: '')
+
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: 1,
+      project_key: 'banana',
+      performance_stats: true,
+      performance_stats_flush_period: 0,
+      query_stats: true
+    )
+  end
+
+  describe "#notify" do
+    it "sends full query" do
+      subject.notify(
+        Airbrake::Query.new(
+          method: 'POST',
+          route: '/foo',
+          query: 'SELECT * FROM things',
+          func: 'foo',
+          file: 'foo.rb',
+          line: 123,
+          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, queries).with(body: %r|
+          \A{"queries":\[{
+            "method":"POST",
+            "route":"/foo",
+            "query":"SELECT\s\*\sFROM\sthings",
+            "time":"2018-01-01T00:49:00\+00:00",
+            "function":"foo",
+            "file":"foo.rb",
+            "line":123,
+            "count":1,
+            "sum":60000.0,
+            "sumsq":3600000000.0,
+            "tdigest":"AAAAAkA0AAAAAAAAAAAAAUdqYAAB"
+          }\]}\z|x)
+      ).to have_been_made
+    end
+
+    it "sends full request" do
+      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":"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 "sends full performance breakdown" do
+      subject.notify(
+        Airbrake::PerformanceBreakdown.new(
+          method: 'DELETE',
+          route: '/routes-breakdowns',
+          response_type: 'json',
+          start_time: Time.new(2018, 1, 1, 0, 49, 0, 0),
+          end_time: Time.new(2018, 1, 1, 0, 50, 0, 0),
+          groups: { db: 131, view: 421 }
+        )
+      )
+
+      expect(
+        a_request(:put, breakdowns).with(body: %r|
+          \A{"routes":\[{
+            "method":"DELETE",
+            "route":"/routes-breakdowns",
+            "responseType":"json",
+            "time":"2018-01-01T00:49:00\+00:00",
+            "count":1,
+            "sum":60000.0,
+            "sumsq":3600000000.0,
+            "tdigest":"AAAAAkA0AAAAAAAAAAAAAUdqYAAB",
+            "groups":{
+              "db":{
+                "count":1,
+                "sum":131.0,
+                "sumsq":17161.0,
+                "tdigest":"AAAAAkA0AAAAAAAAAAAAAUMDAAAB"
+              },
+              "view":{
+                "count":1,
+                "sum":421.0,
+                "sumsq":177241.0,
+                "tdigest":"AAAAAkA0AAAAAAAAAAAAAUPSgAAB"
+              }
+            }
+        }\]}\z|x)
+      ).to have_been_made
+    end
+
+    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 "groups performance breakdowns by route key" do
+      subject.notify(
+        Airbrake::PerformanceBreakdown.new(
+          method: 'DELETE',
+          route: '/routes-breakdowns',
+          response_type: 'json',
+          start_time: Time.new(2018, 1, 1, 0, 0, 20, 0),
+          end_time: Time.new(2018, 1, 1, 0, 0, 22, 0),
+          groups: { db: 131, view: 421 }
+        )
+      )
+      subject.notify(
+        Airbrake::PerformanceBreakdown.new(
+          method: 'DELETE',
+          route: '/routes-breakdowns',
+          response_type: 'json',
+          start_time: Time.new(2018, 1, 1, 0, 0, 30, 0),
+          end_time: Time.new(2018, 1, 1, 0, 0, 32, 0),
+          groups: { db: 55, view: 11 }
+        )
+      )
+
+      expect(
+        a_request(:put, breakdowns).with(body: %r|
+          \A{"routes":\[{
+            "method":"DELETE",
+            "route":"/routes-breakdowns",
+            "responseType":"json",
+            "time":"2018-01-01T00:00:00\+00:00",
+            "count":2,
+            "sum":4000.0,
+            "sumsq":8000000.0,
+            "tdigest":"AAAAAkA0AAAAAAAAAAAAAUT6AAAC",
+            "groups":{
+              "db":{
+                "count":2,
+                "sum":186.0,
+                "sumsq":20186.0,
+                "tdigest":"AAAAAkA0AAAAAAAAAAAAAkJcAABCmAAAAQE="
+              },
+              "view":{
+                "count":2,
+                "sum":432.0,
+                "sumsq":177362.0,
+                "tdigest":"AAAAAkA0AAAAAAAAAAAAAkEwAABDzQAAAQE="
+              }
+            }
+        }\]}\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 "checks performance stat configuration" do
+      request = Airbrake::Request.new(
+        method: 'GET', route: '/foo', status_code: 200, start_time: Time.new
+      )
+      expect(Airbrake::Config.instance).to receive(:check_performance_options)
+        .with(request).and_return(Airbrake::Promise.new)
+      subject.notify(request)
+    end
+
+    it "sends environment when it's specified" do
+      Airbrake::Config.instance.merge(performance_stats: true, environment: 'test')
+
+      subject.notify(
+        Airbrake::Request.new(
+          method: 'POST',
+          route: '/foo',
+          status_code: 200,
+          start_time: Time.new
+        )
+      )
+      expect(
+        a_request(:put, routes).with(
+          body: /\A{"routes":\[.+\],"environment":"test"}\z/x
+        )
+      ).to have_been_made
+    end
+
+    context "when config is invalid" do
+      before { Airbrake::Config.instance.merge(project_id: nil) }
+
+      it "returns a rejected promise" do
+        promise = subject.notify({})
+        expect(promise).to be_rejected
+      end
+    end
+
+    describe "payload grouping" do
+      let(:flush_period) { 0.5 }
+
+      it "groups payload by performance name and sends it separately" do
+        Airbrake::Config.instance.merge(
+          project_id: 1,
+          project_key: 'banana',
+          performance_stats: true,
+          performance_stats_flush_period: flush_period
+        )
+
+        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); 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,197 @@
+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
+
+  describe "#rejected?" do
+    context "when it was rejected" do
+      before { subject.reject(1) }
+      it { is_expected.to be_rejected }
+    end
+
+    context "when it wasn't rejected" do
+      it { is_expected.not_to be_rejected }
+    end
+
+    context "when it was resolved" do
+      before { subject.resolve }
+      it { is_expected.not_to be_rejected }
+    end
+  end
+
+  describe "#resolved?" do
+    context "when it was resolved" do
+      before { subject.resolve }
+      it { is_expected.to be_resolved }
+    end
+
+    context "when it wasn't resolved" do
+      it { is_expected.not_to be_resolved }
+    end
+
+    context "when it was rejected" do
+      before { subject.reject(1) }
+      it { is_expected.not_to be_resolved }
+    end
+  end
+end