airbrake-ruby 4.1.0 → 5.0.0

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require 'simplecov'
+SimpleCov.start if ENV['COVERAGE']
+
 require 'airbrake-ruby'
 
 require 'rspec/its'
@@ -30,7 +33,7 @@ class AirbrakeTestError < RuntimeError
 
   def initialize(*)
     super
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     @backtrace = [
       "/home/kyrylo/code/airbrake/ruby/spec/spec_helper.rb:23:in `<top (required)>'",
       "/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb:54:in `require'",
@@ -44,9 +47,9 @@ class AirbrakeTestError < RuntimeError
       "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb:88:in `run'",
       "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb:73:in `run'",
       "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb:41:in `invoke'",
-      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/exe/rspec:4:in `<main>'"
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/exe/rspec:4:in `<main>'",
     ]
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 
   # rubocop:disable Naming/AccessorMethodName
@@ -63,7 +66,7 @@ end
 class JavaAirbrakeTestError < AirbrakeTestError
   def initialize(*)
     super
-    # rubocop:disable Metrics/LineLength
+    # rubocop:disable Layout/LineLength
     @backtrace = [
       "org.jruby.java.invokers.InstanceMethodInvoker.call(InstanceMethodInvoker.java:26)",
       "org.jruby.ir.interpreter.Interpreter.INTERPRET_EVAL(Interpreter.java:126)",
@@ -75,9 +78,9 @@ class JavaAirbrakeTestError < AirbrakeTestError
       "opt.rubies.jruby_minus_9_dot_0_dot_0_dot_0.bin.irb.RUBY$script(/opt/rubies/jruby-9.0.0.0/bin/irb:13)",
       "org.jruby.ir.Compiler$1.load(Compiler.java:111)",
       "org.jruby.Main.run(Main.java:225)",
-      "org.jruby.Main.main(Main.java:197)"
+      "org.jruby.Main.main(Main.java:197)",
     ]
-    # rubocop:enable Metrics/LineLength
+    # rubocop:enable Layout/LineLength
   end
 
   def is_a?(*)
@@ -95,10 +98,3 @@ class Ruby21Error < RuntimeError
     raise ex
   end
 end
-
-puts <<BANNER
-#{'#' * 80}
-# RUBY_VERSION: #{RUBY_VERSION}
-# RUBY_ENGINE: #{RUBY_ENGINE}
-#{'#' * 80}
-BANNER

data/spec/stashable_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Airbrake::Stashable do
+  let(:klass) do
+    mod = described_class
+    Class.new { include(mod) }
+  end
+
+  describe "#stash" do
+    subject { klass.new }
+
+    it "returns a hash" do
+      expect(subject.stash).to be_a(Hash)
+    end
+
+    it "returns an empty hash" do
+      expect(subject.stash).to be_empty
+    end
+
+    it "remembers what was put in the stash" do
+      subject.stash[:foo] = 1
+      expect(subject.stash[:foo]).to eq(1)
+    end
+  end
+end

data/spec/stat_spec.rb

@@ -5,31 +5,33 @@ RSpec.describe Airbrake::Stat do
         'count' => 0,
         'sum' => 0.0,
         'sumsq' => 0.0,
-        'tdigest' => 'AAAAAkA0AAAAAAAAAAAAAA=='
+        '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) }
+  describe "#increment_ms" do
+    before { subject.increment_ms(1000) }
 
-    before { subject.increment(start_time, end_time) }
+    its(:sum) { is_expected.to eq(1000) }
+    its(:sumsq) { is_expected.to eq(1000000) }
 
-    it "increments count" do
-      expect(subject.count).to eq(1)
-    end
-
-    it "updates sum" do
-      expect(subject.sum).to eq(1000)
+    it "updates tdigest" do
+      expect(subject.tdigest.size).to eq(1)
     end
+  end
 
-    it "updates sumsq" do
-      expect(subject.sumsq).to eq(1000000)
+  describe "#inspect" do
+    it "provides custom inspect output" do
+      expect(subject.inspect).to eq(
+        '#<struct Airbrake::Stat count=0, sum=0.0, sumsq=0.0>',
+      )
     end
+  end
 
-    it "updates tdigest" do
-      expect(subject.tdigest.size).to eq(1)
+  describe "#pretty_print" do
+    it "is an alias of #inspect" do
+      expect(subject.method(:pretty_print)).to eql(subject.method(:inspect))
     end
   end
 end

data/spec/sync_sender_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe Airbrake::SyncSender do
   before do
     Airbrake::Config.instance = Airbrake::Config.new(
-      project_id: 1, project_key: 'banana'
+      project_id: 1, project_key: 'banana',
     )
   end
 
@@ -17,8 +17,8 @@ RSpec.describe Airbrake::SyncSender do
       subject.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
-          headers: { 'Content-Type' => 'application/json' }
-        )
+          headers: { 'Content-Type' => 'application/json' },
+        ),
       ).to have_been_made.once
     end
 
@@ -27,9 +27,11 @@ RSpec.describe Airbrake::SyncSender do
       expect(
         a_request(:post, endpoint).with(
           headers: {
-            'User-Agent' => %r{airbrake-ruby/\d+\.\d+\.\d+ Ruby/\d+\.\d+\.\d+}
-          }
-        )
+            'User-Agent' => %r{
+              airbrake-ruby/\d+\.\d+\.\d+(\.rc\.\d+)?\sRuby/\d+\.\d+\.\d+
+            }x,
+          },
+        ),
       ).to have_been_made.once
     end
 
@@ -37,8 +39,8 @@ RSpec.describe Airbrake::SyncSender do
       subject.send({}, promise)
       expect(
         a_request(:post, endpoint).with(
-          headers: { 'Authorization' => 'Bearer banana' }
-        )
+          headers: { 'Authorization' => 'Bearer banana' },
+        ),
       ).to have_been_made.once
     end
 
@@ -47,7 +49,7 @@ RSpec.describe Airbrake::SyncSender do
       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/
+        /HTTP error: foo/,
       )
       expect(subject.send({}, promise)).to be_an(Airbrake::Promise)
       expect(promise.value).to eq('error' => '**Airbrake: HTTP error: foo')
@@ -69,10 +71,10 @@ RSpec.describe Airbrake::SyncSender do
         notice = Airbrake::Notice.new(ex)
 
         expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /data was not sent/
+          /data was not sent/,
         )
         expect(Airbrake::Loggable.instance).to receive(:error).with(
-          /truncation failed/
+          /truncation failed/,
         )
         expect(subject.send(notice, promise)).to be_an(Airbrake::Promise)
         expect(promise.value)
@@ -87,7 +89,7 @@ RSpec.describe Airbrake::SyncSender do
         stub_request(:post, endpoint).to_return(
           status: 429,
           body: '{"message":"IP is rate limited"}',
-          headers: { 'X-RateLimit-Delay' => '1' }
+          headers: { 'X-RateLimit-Delay' => '1' },
         )
       end
 

data/spec/tdigest_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Airbrake::TDigest do
       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)
+        subject.percentile(0.9).round(5),
       )
       expect(new_tdigest.as_small_bytes).to eq(bytes)
     end
@@ -126,8 +126,8 @@ RSpec.describe Airbrake::TDigest do
           113270270.27027026,
           154459459.45945945,
           123829787.23404256,
-          103191489.36170213
-        ]
+          103191489.36170213,
+        ],
       )
     end
 
@@ -166,13 +166,13 @@ RSpec.describe Airbrake::TDigest do
       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)
+          subject.instance_variable_get(:@delta),
         )
         expect(new_tdigest.instance_variable_get(:@k)).to eq(
-          subject.instance_variable_get(:@k)
+          subject.instance_variable_get(:@k),
         )
         expect(new_tdigest.instance_variable_get(:@cx)).to eq(
-          subject.instance_variable_get(:@cx)
+          subject.instance_variable_get(:@cx),
         )
       end
 

data/spec/thread_pool_spec.rb

@@ -0,0 +1,187 @@
+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
+
+      it "logs discarded tasks" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /reached its capacity/,
+        ).exactly(15).times
+
+        15.times { subject << 1 }
+        subject.close
+      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
+
+    describe "forking behavior" do
+      before do
+        skip('fork() is unsupported on JRuby') if %w[jruby].include?(RUBY_ENGINE)
+        unless Process.respond_to?(:last_status)
+          skip('Process.last_status is unsupported on this Ruby')
+        end
+      end
+
+      it "respawns workers on fork()" do
+        pid = fork { expect(subject).to have_workers }
+        Process.wait(pid)
+        subject.close
+
+        expect(Process.last_status).to be_success
+        expect(subject).not_to have_workers
+      end
+
+      it "ensures that a new thread group is created per process" do
+        subject << 1
+        pid = fork { subject.has_workers? }
+        Process.wait(pid)
+        subject.close
+
+        expect(Process.last_status).to be_success
+      end
+    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

data/spec/timed_trace_spec.rb

@@ -0,0 +1,125 @@
+RSpec.describe Airbrake::TimedTrace do
+  describe ".span" do
+    it "returns a timed trace" do
+      expect(described_class.span('operation') {}).to be_a(described_class)
+    end
+
+    it "returns a timed trace with a stopped span" do
+      timed_trace = described_class.span('operation') {}
+      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)
+    end
+  end
+
+  describe "#start_span" do
+    context "when called once" do
+      it "returns true" do
+        expect(subject.start_span('operation')).to eq(true)
+      end
+    end
+
+    context "when called multiple times" do
+      before { subject.start_span('operation') }
+
+      it "returns false" do
+        expect(subject.start_span('operation')).to eq(false)
+      end
+    end
+
+    context "when another span was started" do
+      before { subject.start_span('operation') }
+
+      it "returns true" do
+        expect(subject.start_span('another operation')).to eq(true)
+      end
+    end
+
+    context "when #spans was called" do
+      before { subject.start_span('operation') }
+
+      it "returns spans with zero values" do
+        expect(subject.spans).to eq('operation' => 0.0)
+      end
+    end
+  end
+
+  describe "#stop_span" do
+    context "when #start_span wasn't invoked" do
+      it "returns false" do
+        expect(subject.stop_span('operation')).to eq(false)
+      end
+    end
+
+    context "when #start_span was invoked" do
+      before { subject.start_span('operation') }
+
+      it "returns true" do
+        expect(subject.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')
+      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)
+        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)
+        end
+      end
+    end
+  end
+
+  describe "#spans" do
+    context "when no spans were captured" do
+      it "returns an empty hash" do
+        expect(subject.spans).to eq({})
+      end
+    end
+
+    context "when a span was captured" do
+      before do
+        subject.start_span('operation')
+        subject.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)
+      end
+    end
+
+    context "when multiple spans were captured" do
+      before do
+        subject.start_span('operation')
+        subject.stop_span('operation')
+
+        subject.start_span('another operation')
+        subject.stop_span('another operation')
+      end
+
+      it "returns a Hash with all spans" do
+        expect(subject.spans).to match(
+          'operation' => be > 0,
+          'another operation' => be > 0,
+        )
+      end
+    end
+  end
+end

data/spec/truncator_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe Airbrake::Truncator do
           banana: multiply_by_2_max_len('a'),
           kiwi: multiply_by_2_max_len('b'),
           strawberry: 'c',
-          shrimp: 'd'
+          shrimp: 'd',
         }.freeze
       end
 
@@ -34,7 +34,7 @@ RSpec.describe Airbrake::Truncator do
         expect(subject).to be_frozen
 
         expect(subject).to eq(
-          banana: 'aaa[Truncated]', kiwi: 'bbb[Truncated]', strawberry: 'c'
+          banana: 'aaa[Truncated]', kiwi: 'bbb[Truncated]', strawberry: 'c',
         )
         expect(subject[:banana]).to be_frozen
         expect(subject[:kiwi]).to be_frozen
@@ -48,7 +48,7 @@ RSpec.describe Airbrake::Truncator do
           multiply_by_2_max_len('a'),
           'b',
           multiply_by_2_max_len('c'),
-          'd'
+          'd',
         ].freeze
       end
 
@@ -69,7 +69,7 @@ RSpec.describe Airbrake::Truncator do
           multiply_by_2_max_len('a'),
           'b',
           multiply_by_2_max_len('c'),
-          'd'
+          'd',
         ]).freeze
       end
 
@@ -78,7 +78,7 @@ RSpec.describe Airbrake::Truncator do
         expect(subject).to be_frozen
 
         expect(subject).to eq(
-          Set.new(['aaa[Truncated]', 'b', 'ccc[Truncated]'])
+          Set.new(['aaa[Truncated]', 'b', 'ccc[Truncated]']),
         )
         expect(subject).to be_frozen
       end
@@ -166,7 +166,7 @@ RSpec.describe Airbrake::Truncator do
 
       it "prevents recursion" do
         expect(subject).to eq(
-          Set.new(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]'])
+          Set.new(['[Circular]', { k: '[Circular]' }, 'aaa[Truncated]']),
         )
         expect(subject).to be_frozen
       end
@@ -177,13 +177,13 @@ RSpec.describe Airbrake::Truncator do
         {
           a: multiply_by_2_max_len('a'),
           b: multiply_by_2_max_len('b'),
-          c: { d: multiply_by_2_max_len('d'), e: 'e' }
+          c: { d: multiply_by_2_max_len('d'), e: 'e' },
         }
       end
 
       it "truncates the long strings" do
         expect(subject).to eq(
-          a: 'aaa[Truncated]', b: 'bbb[Truncated]', c: { d: 'ddd[Truncated]', e: 'e' }
+          a: 'aaa[Truncated]', b: 'bbb[Truncated]', c: { d: 'ddd[Truncated]', e: 'e' },
         )
         expect(subject).to be_frozen
       end
@@ -218,8 +218,8 @@ RSpec.describe Airbrake::Truncator do
           errors: [
             { file: 'a' },
             { file: 'a' },
-            hashie.new.merge(file: 'bcde')
-          ]
+            hashie.new.merge(file: 'bcde'),
+          ],
         }
       end
 
@@ -228,8 +228,8 @@ RSpec.describe Airbrake::Truncator do
           errors: [
             { file: 'a' },
             { file: 'a' },
-            hashie.new.merge(file: 'bcd[Truncated]')
-          ]
+            hashie.new.merge(file: 'bcd[Truncated]'),
+          ],
         )
         expect(subject).to be_frozen
       end