airbrake-ruby 5.2.0-java → 6.0.2-java

data/spec/tdigest_spec.rb

@@ -1,16 +1,18 @@
 RSpec.describe Airbrake::TDigest do
+  subject(:tdigest) { described_class.new }
+
   describe "byte serialization" do
     it "loads serialized data" do
-      subject.push(60, 100)
-      10.times { subject.push(rand * 100) }
-      bytes = subject.as_bytes
+      tdigest.push(60, 100)
+      10.times { tdigest.push(rand * 100) }
+      bytes = tdigest.as_bytes
       new_tdigest = described_class.from_bytes(bytes)
-      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+      expect(new_tdigest.percentile(0.9)).to eq(tdigest.percentile(0.9))
       expect(new_tdigest.as_bytes).to eq(bytes)
     end
 
     it "handles zero size" do
-      bytes = subject.as_bytes
+      bytes = tdigest.as_bytes
       expect(described_class.from_bytes(bytes).size).to be_zero
     end
 
@@ -24,65 +26,64 @@ RSpec.describe Airbrake::TDigest do
 
   describe "small byte serialization" do
     it "loads serialized data" do
-      10.times { subject.push(10) }
-      bytes = subject.as_small_bytes
+      10.times { tdigest.push(10) }
+      bytes = tdigest.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),
+        tdigest.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
+      bytes = tdigest.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
+      tdigest.push(60, 100)
+      json = tdigest.as_json
       new_tdigest = described_class.from_json(json)
-      expect(new_tdigest.percentile(0.9)).to eq(subject.percentile(0.9))
+      expect(new_tdigest.percentile(0.9)).to eq(tdigest.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
+      expect(tdigest.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)
+      expect { tdigest.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)
+        tdigest.push(60, 100)
+        expect(tdigest.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])
+        tdigest.push(0)
+        expect(tdigest.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 }
+        values = Array.new(100_000).map { rand }
         srand(seed)
 
-        subject.push(values)
-        subject.compress!
+        tdigest.push(values)
+        tdigest.compress!
 
         0.step(1, 0.1).each do |i|
-          q = subject.percentile(i)
+          q = tdigest.percentile(i)
           maxerr = [maxerr, (i - q).abs].max
         end
 
@@ -93,7 +94,7 @@ RSpec.describe Airbrake::TDigest do
 
   describe "#push" do
     it "calls _cumulate so won't crash because of uninitialized mean_cumn" do
-      subject.push(
+      tdigest.push(
         [
           125000000.0,
           104166666.66666666,
@@ -132,59 +133,62 @@ RSpec.describe Airbrake::TDigest do
     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
+      tdigest.push(0..10_000)
+      expect(tdigest.centroids.size).to be < 5_000
+      tdigest.compress!
+      expect(tdigest.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)
+      n.times { tdigest.push(rand) }
+      tdigest.compress!
+      expect(tdigest.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)
+      expect((tdigest + other).centroids.size).to eq(0)
     end
 
     describe "adding two tdigests" do
+      let(:other) { described_class.new(0.001, 50, 1.2) }
+
       before do
-        @other = described_class.new(0.001, 50, 1.2)
-        [subject, @other].each do |td|
+        [tdigest, other].each do |td|
           td.push(60, 100)
           10.times { td.push(rand * 100) }
         end
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "has the parameters of the left argument (the calling tdigest)" do
-        new_tdigest = subject + @other
+        new_tdigest = tdigest + other
         expect(new_tdigest.instance_variable_get(:@delta)).to eq(
-          subject.instance_variable_get(:@delta),
+          tdigest.instance_variable_get(:@delta),
         )
         expect(new_tdigest.instance_variable_get(:@k)).to eq(
-          subject.instance_variable_get(:@k),
+          tdigest.instance_variable_get(:@k),
         )
         expect(new_tdigest.instance_variable_get(:@cx)).to eq(
-          subject.instance_variable_get(:@cx),
+          tdigest.instance_variable_get(:@cx),
         )
       end
+      # rubocop:enable RSpec/MultipleExpectations
 
       it "returns a tdigest with less than or equal centroids" do
-        new_tdigest = subject + @other
+        new_tdigest = tdigest + other
         expect(new_tdigest.centroids.size)
-          .to be <= subject.centroids.size + @other.centroids.size
+          .to be <= tdigest.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)
+        new_tdigest = tdigest + other
+        expect(new_tdigest.size).to eq(tdigest.size + other.size)
       end
     end
   end
@@ -192,14 +196,15 @@ RSpec.describe Airbrake::TDigest do
   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
+      tdigest.merge!(other)
+      expect(tdigest.centroids.size).to be_zero
     end
 
     describe "with populated tdigests" do
+      let(:other) { described_class.new(0.001, 50, 1.2) }
+
       before do
-        @other = described_class.new(0.001, 50, 1.2)
-        [subject, @other].each do |td|
+        [tdigest, other].each do |td|
           td.push(60, 100)
           10.times { td.push(rand * 100) }
         end
@@ -207,23 +212,23 @@ RSpec.describe Airbrake::TDigest do
 
       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)
+        expected = vars.map { |v| [v, tdigest.instance_variable_get(v)] }.to_h
+        tdigest.merge!(other)
         vars.each do |v|
-          expect(subject.instance_variable_get(v)).to eq(expected[v])
+          expect(tdigest.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
+        combined_size = tdigest.centroids.size + other.centroids.size
+        tdigest.merge!(other)
+        expect(tdigest.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)
+        combined_size = tdigest.size + other.size
+        tdigest.merge!(other)
+        expect(tdigest.size).to eq(combined_size)
       end
     end
   end

data/spec/thread_pool_spec.rb

@@ -1,9 +1,5 @@
 RSpec.describe Airbrake::ThreadPool do
-  let(:tasks) { [] }
-  let(:worker_size) { 1 }
-  let(:queue_size) { 2 }
-
-  subject do
+  subject(:thread_pool) do
     described_class.new(
       worker_size: worker_size,
       queue_size: queue_size,
@@ -11,27 +7,27 @@ RSpec.describe Airbrake::ThreadPool do
     )
   end
 
+  let(:tasks) { [] }
+  let(:worker_size) { 1 }
+  let(:queue_size) { 2 }
+
   describe "#<<" do
     it "returns true" do
-      retval = subject << 1
-      subject.close
+      retval = thread_pool << 1
+      thread_pool.close
       expect(retval).to eq(true)
     end
 
     it "performs work in background" do
-      subject << 2
-      subject << 1
-      subject.close
+      thread_pool << 2
+      thread_pool << 1
+      thread_pool.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
+      subject(:full_thread_pool) do
         described_class.new(
           worker_size: 1,
           queue_size: 1,
@@ -39,26 +35,33 @@ RSpec.describe Airbrake::ThreadPool do
         )
       end
 
+      before do
+        # rubocop:disable RSpec/SubjectStub
+        allow(full_thread_pool).to receive(:backlog).and_return(queue_size)
+        # rubocop:enable RSpec/SubjectStub
+      end
+
       it "returns false" do
-        retval = subject << 1
-        subject.close
+        retval = full_thread_pool << 1
+        full_thread_pool.close
         expect(retval).to eq(false)
       end
 
       it "discards tasks" do
-        200.times { subject << 1 }
-        subject.close
+        200.times { full_thread_pool << 1 }
+        full_thread_pool.close
 
         expect(tasks.size).to be_zero
       end
 
       it "logs discarded tasks" do
-        expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /reached its capacity/,
-        ).exactly(15).times
+        allow(Airbrake::Loggable.instance).to receive(:info)
+
+        15.times { full_thread_pool << 1 }
+        full_thread_pool.close
 
-        15.times { subject << 1 }
-        subject.close
+        expect(Airbrake::Loggable.instance)
+          .to have_received(:info).exactly(15).times
       end
     end
   end
@@ -67,22 +70,22 @@ RSpec.describe Airbrake::ThreadPool do
     let(:worker_size) { 0 }
 
     it "returns the size of the queue" do
-      subject << 1
-      expect(subject.backlog).to eq(1)
+      thread_pool << 1
+      expect(thread_pool.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|
+      thread_pool.workers.list.each do |worker|
         worker.kill.join
       end
-      expect(subject).not_to have_workers
+      expect(thread_pool).not_to have_workers
     end
 
     it "returns false when the thread pool is closed" do
-      subject.close
-      expect(subject).not_to have_workers
+      thread_pool.close
+      expect(thread_pool).not_to have_workers
     end
 
     describe "forking behavior" do
@@ -93,20 +96,22 @@ RSpec.describe Airbrake::ThreadPool do
         end
       end
 
+      # rubocop:disable RSpec/MultipleExpectations
       it "respawns workers on fork()" do
-        pid = fork { expect(subject).to have_workers }
+        pid = fork { expect(thread_pool).to have_workers }
         Process.wait(pid)
-        subject.close
+        thread_pool.close
 
         expect(Process.last_status).to be_success
-        expect(subject).not_to have_workers
+        expect(thread_pool).not_to have_workers
       end
+      # rubocop:enable RSpec/MultipleExpectations
 
       it "ensures that a new thread group is created per process" do
-        subject << 1
-        pid = fork { subject.has_workers? }
+        thread_pool << 1
+        pid = fork { thread_pool.has_workers? }
         Process.wait(pid)
-        subject.close
+        thread_pool.close
 
         expect(Process.last_status).to be_success
       end
@@ -116,27 +121,29 @@ RSpec.describe Airbrake::ThreadPool do
   describe "#close" do
     context "when there's no work to do" do
       it "joins the spawned thread" do
-        workers = subject.workers.list
+        workers = thread_pool.workers.list
         expect(workers).to all(be_alive)
 
-        subject.close
+        thread_pool.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 {},
-        )
+        allow(Airbrake::Loggable.instance).to receive(:debug)
 
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(
-          /waiting to process \d+ task\(s\)/,
+        thread_pool = described_class.new(
+          name: 'foo', worker_size: 0, queue_size: 2, block: proc {},
         )
-        expect(Airbrake::Loggable.instance).to receive(:debug).with(/closed/)
 
         2.times { thread_pool << 1 }
         thread_pool.close
+
+        expect(Airbrake::Loggable.instance).to have_received(:debug).with(
+          /waiting to process \d+ task\(s\)/,
+        )
+        expect(Airbrake::Loggable.instance).to have_received(:debug).with(/foo.+closed/)
       end
 
       it "waits until the queue gets empty" do
@@ -144,7 +151,7 @@ RSpec.describe Airbrake::ThreadPool do
           worker_size: 1, queue_size: 2, block: proc {},
         )
 
-        10.times { subject << 1 }
+        10.times { thread_pool << 1 }
         thread_pool.close
         expect(thread_pool.backlog).to be_zero
       end
@@ -153,17 +160,17 @@ RSpec.describe Airbrake::ThreadPool do
     context "when it was already closed" do
       it "doesn't increase the queue size" do
         begin
-          subject.close
+          thread_pool.close
         rescue Airbrake::Error
           nil
         end
 
-        expect(subject.backlog).to be_zero
+        expect(thread_pool.backlog).to be_zero
       end
 
       it "raises error" do
-        subject.close
-        expect { subject.close }.to raise_error(
+        thread_pool.close
+        expect { thread_pool.close }.to raise_error(
           Airbrake::Error, 'this thread pool is closed already'
         )
       end
@@ -171,17 +178,19 @@ RSpec.describe Airbrake::ThreadPool do
   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
+    after { thread_pool.close }
+
+    it "spawns an enclosed thread group" do
+      expect(thread_pool.workers).to be_a(ThreadGroup)
+      expect(thread_pool.workers).to be_enclosed
+    end
 
-      subject.close
+    it "spawns threads that are alive" do
+      expect(thread_pool.workers.list).to all(be_alive)
     end
 
     it "spawns exactly `workers_size` workers" do
-      expect(subject.workers.list.size).to eq(worker_size)
-      subject.close
+      expect(thread_pool.workers.list.size).to eq(worker_size)
     end
   end
 end

data/spec/time_truncate_spec.rb

@@ -1,13 +1,30 @@
 RSpec.describe Airbrake::TimeTruncate do
+  time = Time.new(2018, 1, 1, 0, 0, 20, 0)
+  time_with_zone = Time.new(2018, 1, 1, 0, 0, 20, '-05:00')
+
   describe "#utc_truncate_minutes" do
-    it "truncates time to the floor minute and returns an RFC3339 timestamp" do
-      time = Time.new(2018, 1, 1, 0, 0, 20, 0)
-      expect(subject.utc_truncate_minutes(time)).to eq('2018-01-01T00:00:00+00:00')
+    shared_examples 'time conversion' do |t|
+      it "truncates the time to the floor minute and returns an RFC3339 timestamp" do
+        expect(described_class.utc_truncate_minutes(t))
+          .to eq('2018-01-01T00:00:00+00:00')
+      end
+
+      it "converts time with zone to UTC" do
+        expect(described_class.utc_truncate_minutes(time_with_zone))
+          .to eq('2018-01-01T05:00:00+00:00')
+      end
+    end
+
+    context "when the time argument is a Time object" do
+      include_examples 'time conversion', time
+    end
+
+    context "when the time argument is a Float" do
+      include_examples 'time conversion', time.to_f
     end
 
-    it "converts time with zone to UTC" do
-      time = Time.new(2018, 1, 1, 0, 0, 20, '-05:00')
-      expect(subject.utc_truncate_minutes(time)).to eq('2018-01-01T05:00:00+00:00')
+    context "when the time argument is an Integer" do
+      include_examples 'time conversion', time.to_i
     end
   end
 end

data/spec/timed_trace_spec.rb

@@ -1,50 +1,52 @@
 RSpec.describe Airbrake::TimedTrace do
+  subject(:timed_trace) { described_class.new }
+
   describe ".span" do
     it "returns a timed trace" do
-      expect(described_class.span('operation') {}).to be_a(described_class)
+      expect(described_class.span('operation') { anything }).to be_a(described_class)
     end
 
     it "returns a timed trace with a stopped span" do
-      timed_trace = described_class.span('operation') {}
+      timed_trace = described_class.span('operation') { anything }
       expect(timed_trace.spans).to match('operation' => be > 0)
     end
   end
 
   describe "#span" do
     it "captures a span" do
-      subject.span('operation') {}
-      expect(subject.spans).to match('operation' => be > 0)
+      timed_trace.span('operation') { anything }
+      expect(timed_trace.spans).to match('operation' => be > 0)
     end
   end
 
   describe "#start_span" do
     context "when called once" do
       it "returns true" do
-        expect(subject.start_span('operation')).to eq(true)
+        expect(timed_trace.start_span('operation')).to eq(true)
       end
     end
 
     context "when called multiple times" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns false" do
-        expect(subject.start_span('operation')).to eq(false)
+        expect(timed_trace.start_span('operation')).to eq(false)
       end
     end
 
     context "when another span was started" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns true" do
-        expect(subject.start_span('another operation')).to eq(true)
+        expect(timed_trace.start_span('another operation')).to eq(true)
       end
     end
 
     context "when #spans was called" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns spans with zero values" do
-        expect(subject.spans).to eq('operation' => 0.0)
+        expect(timed_trace.spans).to eq('operation' => 0.0)
       end
     end
   end
@@ -52,35 +54,35 @@ RSpec.describe Airbrake::TimedTrace do
   describe "#stop_span" do
     context "when #start_span wasn't invoked" do
       it "returns false" do
-        expect(subject.stop_span('operation')).to eq(false)
+        expect(timed_trace.stop_span('operation')).to eq(false)
       end
     end
 
     context "when #start_span was invoked" do
-      before { subject.start_span('operation') }
+      before { timed_trace.start_span('operation') }
 
       it "returns true" do
-        expect(subject.stop_span('operation')).to eq(true)
+        expect(timed_trace.stop_span('operation')).to eq(true)
       end
     end
 
     context "when multiple spans were started" do
       before do
-        subject.start_span('operation')
-        subject.start_span('another operation')
+        timed_trace.start_span('operation')
+        timed_trace.start_span('another operation')
       end
 
       context "and when stopping in LIFO order" do
         it "returns true for all spans" do
-          expect(subject.stop_span('another operation')).to eq(true)
-          expect(subject.stop_span('operation')).to eq(true)
+          expect(timed_trace.stop_span('another operation')).to eq(true)
+          expect(timed_trace.stop_span('operation')).to eq(true)
         end
       end
 
       context "and when stopping in FIFO order" do
         it "returns true for all spans" do
-          expect(subject.stop_span('operation')).to eq(true)
-          expect(subject.stop_span('another operation')).to eq(true)
+          expect(timed_trace.stop_span('operation')).to eq(true)
+          expect(timed_trace.stop_span('another operation')).to eq(true)
         end
       end
     end
@@ -89,33 +91,33 @@ RSpec.describe Airbrake::TimedTrace do
   describe "#spans" do
     context "when no spans were captured" do
       it "returns an empty hash" do
-        expect(subject.spans).to eq({})
+        expect(timed_trace.spans).to eq({})
       end
     end
 
     context "when a span was captured" do
       before do
-        subject.start_span('operation')
-        subject.stop_span('operation')
+        timed_trace.start_span('operation')
+        timed_trace.stop_span('operation')
       end
 
       it "returns a Hash with the corresponding span" do
-        subject.stop_span('operation')
-        expect(subject.spans).to match('operation' => be > 0)
+        timed_trace.stop_span('operation')
+        expect(timed_trace.spans).to match('operation' => be > 0)
       end
     end
 
     context "when multiple spans were captured" do
       before do
-        subject.start_span('operation')
-        subject.stop_span('operation')
+        timed_trace.start_span('operation')
+        timed_trace.stop_span('operation')
 
-        subject.start_span('another operation')
-        subject.stop_span('another operation')
+        timed_trace.start_span('another operation')
+        timed_trace.stop_span('another operation')
       end
 
       it "returns a Hash with all spans" do
-        expect(subject.spans).to match(
+        expect(timed_trace.spans).to match(
           'operation' => be > 0,
           'another operation' => be > 0,
         )