airbrake-ruby 4.8.0

data/spec/sync_sender_spec.rb

@@ -0,0 +1,133 @@
+RSpec.describe Airbrake::SyncSender do
+  before do
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: 1, project_key: 'banana'
+    )
+  end
+
+  describe "#send" do
+    let(:promise) { Airbrake::Promise.new }
+
+    let(:notice) { Airbrake::Notice.new(AirbrakeTestError.new) }
+    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+
+    before { stub_request(:post, endpoint).to_return(body: '{}') }
+
+    it "sets the Content-Type header to JSON" do
+      subject.send({}, promise)
+      expect(
+        a_request(:post, endpoint).with(
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      ).to have_been_made.once
+    end
+
+    it "sets the User-Agent header to the notifier slug" do
+      subject.send({}, promise)
+      expect(
+        a_request(:post, endpoint).with(
+          headers: {
+            'User-Agent' => %r{airbrake-ruby/\d+\.\d+\.\d+ Ruby/\d+\.\d+\.\d+}
+          }
+        )
+      ).to have_been_made.once
+    end
+
+    it "sets the Authorization header to the project key" do
+      subject.send({}, promise)
+      expect(
+        a_request(:post, endpoint).with(
+          headers: { 'Authorization' => 'Bearer banana' }
+        )
+      ).to have_been_made.once
+    end
+
+    it "catches exceptions raised while sending" do
+      https = double("foo")
+      allow(subject).to receive(:build_https).and_return(https)
+      allow(https).to receive(:request).and_raise(StandardError.new('foo'))
+      expect(Airbrake::Loggable.instance).to receive(:error).with(
+        /HTTP error: foo/
+      )
+      expect(subject.send({}, promise)).to be_an(Airbrake::Promise)
+      expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
+    end
+
+    context "when request body is nil" do
+      it "doesn't send data" do
+        expect_any_instance_of(Airbrake::Truncator)
+          .to receive(:reduce_max_size).and_return(0)
+
+        encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
+        bad_string = Base64.decode64(encoded)
+
+        ex = AirbrakeTestError.new
+        backtrace = []
+        10.times { backtrace << "bin/rails:3:in `<#{bad_string}>'" }
+        ex.set_backtrace(backtrace)
+
+        notice = Airbrake::Notice.new(ex)
+
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /data was not sent/
+        )
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /truncation failed/
+        )
+        expect(subject.send(notice, promise)).to be_an(Airbrake::Promise)
+        expect(promise.value)
+          .to match('error' => '**Airbrake: data was not sent because of missing body')
+      end
+    end
+
+    context "when IP is rate limited" do
+      let(:endpoint) { %r{https://api.airbrake.io/api/v3/projects/1/notices} }
+
+      before do
+        stub_request(:post, endpoint).to_return(
+          status: 429,
+          body: '{"message":"IP is rate limited"}',
+          headers: { 'X-RateLimit-Delay' => '1' }
+        )
+      end
+
+      it "returns error" do
+        p1 = Airbrake::Promise.new
+        subject.send({}, p1)
+        expect(p1.value).to match('error' => '**Airbrake: IP is rate limited')
+
+        p2 = Airbrake::Promise.new
+        subject.send({}, p2)
+        expect(p2.value).to match('error' => '**Airbrake: IP is rate limited')
+
+        # Wait for X-RateLimit-Delay and then make a new request to make sure p2
+        # was ignored (no request made for it).
+        sleep 1
+
+        p3 = Airbrake::Promise.new
+        subject.send({}, p3)
+        expect(p3.value).to match('error' => '**Airbrake: IP is rate limited')
+
+        expect(a_request(:post, endpoint)).to have_been_made.twice
+      end
+    end
+
+    context "when the provided method is :put" do
+      before { stub_request(:put, endpoint).to_return(status: 200, body: '') }
+
+      it "PUTs the request" do
+        sender = described_class.new(:put)
+        sender.send({}, promise)
+        expect(a_request(:put, endpoint)).to have_been_made
+      end
+    end
+
+    context "when the provided method is :post" do
+      it "POSTs the request" do
+        sender = described_class.new(:post)
+        sender.send({}, promise)
+        expect(a_request(:post, endpoint)).to have_been_made
+      end
+    end
+  end
+end

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

data/spec/thread_pool_spec.rb

@@ -0,0 +1,158 @@
+RSpec.describe Airbrake::ThreadPool do
+  let(:tasks) { [] }
+  let(:worker_size) { 1 }
+  let(:queue_size) { 2 }
+
+  subject do
+    described_class.new(
+      worker_size: worker_size,
+      queue_size: queue_size,
+      block: proc { |message| tasks << message }
+    )
+  end
+
+  describe "#<<" do
+    it "returns true" do
+      retval = subject << 1
+      subject.close
+      expect(retval).to eq(true)
+    end
+
+    it "performs work in background" do
+      subject << 2
+      subject << 1
+      subject.close
+
+      expect(tasks).to eq([2, 1])
+    end
+
+    context "when the queue is full" do
+      before do
+        allow(subject).to receive(:backlog).and_return(queue_size)
+      end
+
+      subject do
+        described_class.new(
+          worker_size: 1,
+          queue_size: 1,
+          block: proc { |message| tasks << message }
+        )
+      end
+
+      it "returns false" do
+        retval = subject << 1
+        subject.close
+        expect(retval).to eq(false)
+      end
+
+      it "discards tasks" do
+        200.times { subject << 1 }
+        subject.close
+
+        expect(tasks.size).to be_zero
+      end
+    end
+  end
+
+  describe "#backlog" do
+    let(:worker_size) { 0 }
+
+    it "returns the size of the queue" do
+      subject << 1
+      expect(subject.backlog).to eq(1)
+    end
+  end
+
+  describe "#has_workers?" do
+    it "returns false when the thread pool is not closed, but has 0 workers" do
+      subject.workers.list.each do |worker|
+        worker.kill.join
+      end
+      expect(subject).not_to have_workers
+    end
+
+    it "returns false when the thread pool is closed" do
+      subject.close
+      expect(subject).not_to have_workers
+    end
+
+    it "respawns workers on fork()", skip: %w[jruby].include?(RUBY_ENGINE) do
+      pid = fork { expect(subject).to have_workers }
+      Process.wait(pid)
+      subject.close
+      expect(subject).not_to have_workers
+    end
+  end
+
+  describe "#close" do
+    context "when there's no work to do" do
+      it "joins the spawned thread" do
+        workers = subject.workers.list
+        expect(workers).to all(be_alive)
+
+        subject.close
+        expect(workers).to all(be_stop)
+      end
+    end
+
+    context "when there's some work to do" do
+      it "logs how many tasks are left to process" do
+        thread_pool = described_class.new(
+          worker_size: 0, queue_size: 2, block: proc {}
+        )
+
+        expect(Airbrake::Loggable.instance).to receive(:debug).with(
+          /waiting to process \d+ task\(s\)/
+        )
+        expect(Airbrake::Loggable.instance).to receive(:debug).with(/closed/)
+
+        2.times { thread_pool << 1 }
+        thread_pool.close
+      end
+
+      it "waits until the queue gets empty" do
+        thread_pool = described_class.new(
+          worker_size: 1, queue_size: 2, block: proc {}
+        )
+
+        10.times { subject << 1 }
+        thread_pool.close
+        expect(thread_pool.backlog).to be_zero
+      end
+    end
+
+    context "when it was already closed" do
+      it "doesn't increase the queue size" do
+        begin
+          subject.close
+        rescue Airbrake::Error
+          nil
+        end
+
+        expect(subject.backlog).to be_zero
+      end
+
+      it "raises error" do
+        subject.close
+        expect { subject.close }.to raise_error(
+          Airbrake::Error, 'this thread pool is closed already'
+        )
+      end
+    end
+  end
+
+  describe "#spawn_workers" do
+    it "spawns alive threads in an enclosed ThreadGroup" do
+      expect(subject.workers).to be_a(ThreadGroup)
+      expect(subject.workers.list).to all(be_alive)
+      expect(subject.workers).to be_enclosed
+
+      subject.close
+    end
+
+    it "spawns exactly `workers_size` workers" do
+      expect(subject.workers.list.size).to eq(worker_size)
+      subject.close
+    end
+  end
+end