airbrake-ruby 3.1.0 → 3.2.0

data/spec/notice_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Airbrake::Notice do
   let(:notice) do
     described_class.new(Airbrake::Config.new, AirbrakeTestError.new, bingo: '1')
@@ -261,7 +259,7 @@ RSpec.describe Airbrake::Notice do
     it "raises error if notice is ignored" do
       notice.ignore!
       expect { notice[:params] }.
-        to raise_error(Airbrake::Error, 'cannot access ignored notice')
+        to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
     end
   end
 
@@ -275,7 +273,7 @@ RSpec.describe Airbrake::Notice do
     it "raises error if notice is ignored" do
       notice.ignore!
       expect { notice[:params] = {} }.
-        to raise_error(Airbrake::Error, 'cannot access ignored notice')
+        to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
     end
 
     it "raises error when trying to assign unrecognized key" do

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

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Airbrake::Promise do
   describe ".then" do
     let(:resolved_with) { [] }

data/spec/response_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Airbrake::Response do
   describe ".parse" do
     let(:out) { StringIO.new }

data/spec/stat_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Airbrake::Stat do
+  describe "#to_h" do
+    it "converts to a hash" do
+      expect(subject.to_h).to eq(
+        'count' => 0,
+        'sum' => 0.0,
+        'sumsq' => 0.0,
+        'tdigest' => 'AAAAAkA0AAAAAAAAAAAAAA=='
+      )
+    end
+  end
+
+  describe "#increment" do
+    let(:start_time) { Time.new(2018, 1, 1, 0, 0, 20, 0) }
+    let(:end_time) { Time.new(2018, 1, 1, 0, 0, 21, 0) }
+
+    before { subject.increment(start_time, end_time) }
+
+    it "increments count" do
+      expect(subject.count).to eq(1)
+    end
+
+    it "updates sum" do
+      expect(subject.sum).to eq(1000)
+    end
+
+    it "updates sumsq" do
+      expect(subject.sumsq).to eq(1000000)
+    end
+
+    it "updates tdigest" do
+      expect(subject.tdigest.size).to eq(1)
+    end
+  end
+end

data/spec/sync_sender_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 RSpec.describe Airbrake::SyncSender do
   describe "#build_https" do
     it "overrides Net::HTTP's open_timeout and read_timeout if timeout is specified" do

data/spec/tdigest_spec.rb

@@ -0,0 +1,230 @@
+RSpec.describe Airbrake::TDigest do
+  describe "byte serialization" do
+    it "loads serialized data" do
+      subject.push(60, 100)
+      10.times { subject.push(rand * 100) }
+      bytes = subject.as_bytes
+      new_tdigest = described_class.from_bytes(bytes)
+      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+      expect(new_tdigest.as_bytes).to eq(bytes)
+    end
+
+    it "handles zero size" do
+      bytes = subject.as_bytes
+      expect(described_class.from_bytes(bytes).size).to be_zero
+    end
+
+    it "preserves compression" do
+      td = described_class.new(0.001)
+      bytes = td.as_bytes
+      new_tdigest = described_class.from_bytes(bytes)
+      expect(new_tdigest.compression).to eq(td.compression)
+    end
+  end
+
+  describe "small byte serialization" do
+    it "loads serialized data" do
+      10.times { subject.push(10) }
+      bytes = subject.as_small_bytes
+      new_tdigest = described_class.from_bytes(bytes)
+      # Expect some rounding error due to compression
+      expect(new_tdigest.percentile(0.9).round(5)).to eq(
+        subject.percentile(0.9).round(5)
+      )
+      expect(new_tdigest.as_small_bytes).to eq(bytes)
+    end
+
+    it "handles zero size" do
+      bytes = subject.as_small_bytes
+      expect(described_class.from_bytes(bytes).size).to be_zero
+    end
+  end
+
+  describe "JSON serialization" do
+    it "loads serialized data" do
+      subject.push(60, 100)
+      json = subject.as_json
+      new_tdigest = described_class.from_json(json)
+      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+    end
+  end
+
+  describe "#percentile" do
+    it "returns nil if empty" do
+      expect(subject.percentile(0.90)).to be_nil # This should not crash
+    end
+
+    it "raises ArgumentError of input not between 0 and 1" do
+      expect { subject.percentile(1.1) }.to raise_error(ArgumentError)
+    end
+
+    describe "with only single value" do
+      it "returns the value" do
+        subject.push(60, 100)
+        expect(subject.percentile(0.90)).to eq(60)
+      end
+
+      it "returns 0 for all percentiles when only 0 present" do
+        subject.push(0)
+        expect(subject.percentile([0.0, 0.5, 1.0])).to eq([0, 0, 0])
+      end
+    end
+
+    describe "with alot of uniformly distributed points" do
+      it "has minimal error" do
+        seed = srand(1234) # Makes the values a proper fixture
+        N = 100_000
+        maxerr = 0
+        values = Array.new(N).map { rand }
+        srand(seed)
+
+        subject.push(values)
+        subject.compress!
+
+        0.step(1, 0.1).each do |i|
+          q = subject.percentile(i)
+          maxerr = [maxerr, (i - q).abs].max
+        end
+
+        expect(maxerr).to be < 0.01
+      end
+    end
+  end
+
+  describe "#push" do
+    it "calls _cumulate so won't crash because of uninitialized mean_cumn" do
+      subject.push(
+        [
+          125000000.0,
+          104166666.66666666,
+          135416666.66666666,
+          104166666.66666666,
+          104166666.66666666,
+          93750000.0,
+          125000000.0,
+          62500000.0,
+          114583333.33333333,
+          156250000.0,
+          124909090.90909092,
+          104090909.0909091,
+          135318181.81818184,
+          104090909.0909091,
+          104090909.0909091,
+          93681818.18181819,
+          124909090.90909092,
+          62454545.45454546,
+          114500000.00000001,
+          156136363.63636366,
+          123567567.56756756,
+          102972972.97297296,
+          133864864.86486486,
+          102972972.97297296,
+          102972972.97297296,
+          92675675.67567568,
+          123567567.56756756,
+          61783783.78378378,
+          113270270.27027026,
+          154459459.45945945,
+          123829787.23404256,
+          103191489.36170213
+        ]
+      )
+    end
+
+    it "does not blow up if data comes in sorted" do
+      subject.push(0..10_000)
+      expect(subject.centroids.size).to be < 5_000
+      subject.compress!
+      expect(subject.centroids.size).to be < 1_000
+    end
+  end
+
+  describe "#size" do
+    it "reports the number of observations" do
+      n = 10_000
+      n.times { subject.push(rand) }
+      subject.compress!
+      expect(subject.size).to eq(n)
+    end
+  end
+
+  describe "#+" do
+    it "works with empty tdigests" do
+      other = described_class.new(0.001, 50, 1.2)
+      expect((subject + other).centroids.size).to eq(0)
+    end
+
+    describe "adding two tdigests" do
+      before do
+        @other = described_class.new(0.001, 50, 1.2)
+        [subject, @other].each do |td|
+          td.push(60, 100)
+          10.times { td.push(rand * 100) }
+        end
+      end
+
+      it "has the parameters of the left argument (the calling tdigest)" do
+        new_tdigest = subject + @other
+        expect(new_tdigest.instance_variable_get(:@delta)).to eq(
+          subject.instance_variable_get(:@delta)
+        )
+        expect(new_tdigest.instance_variable_get(:@k)).to eq(
+          subject.instance_variable_get(:@k)
+        )
+        expect(new_tdigest.instance_variable_get(:@cx)).to eq(
+          subject.instance_variable_get(:@cx)
+        )
+      end
+
+      it "returns a tdigest with less than or equal centroids" do
+        new_tdigest = subject + @other
+        expect(new_tdigest.centroids.size).
+          to be <= subject.centroids.size + @other.centroids.size
+      end
+
+      it "has the size of the two digests combined" do
+        new_tdigest = subject + @other
+        expect(new_tdigest.size).to eq(subject.size + @other.size)
+      end
+    end
+  end
+
+  describe "#merge!" do
+    it "works with empty tdigests" do
+      other = described_class.new(0.001, 50, 1.2)
+      subject.merge!(other)
+      expect(subject.centroids.size).to be_zero
+    end
+
+    describe "with populated tdigests" do
+      before do
+        @other = described_class.new(0.001, 50, 1.2)
+        [subject, @other].each do |td|
+          td.push(60, 100)
+          10.times { td.push(rand * 100) }
+        end
+      end
+
+      it "has the parameters of the calling tdigest" do
+        vars = %i[@delta @k @cx]
+        expected = Hash[vars.map { |v| [v, subject.instance_variable_get(v)] }]
+        subject.merge!(@other)
+        vars.each do |v|
+          expect(subject.instance_variable_get(v)).to eq(expected[v])
+        end
+      end
+
+      it "returns a tdigest with less than or equal centroids" do
+        combined_size = subject.centroids.size + @other.centroids.size
+        subject.merge!(@other)
+        expect(subject.centroids.size).to be <= combined_size
+      end
+
+      it "has the size of the two digests combined" do
+        combined_size = subject.size + @other.size
+        subject.merge!(@other)
+        expect(subject.size).to eq(combined_size)
+      end
+    end
+  end
+end