airbrake-ruby 4.6.0

data/spec/query_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Airbrake::Query do
+  describe "#stash" do
+    subject do
+      described_class.new(
+        method: 'GET', route: '/', query: '', start_time: Time.now
+      )
+    end
+
+    it { is_expected.to respond_to(:stash) }
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Airbrake::Request do
+  describe "#stash" do
+    subject do
+      described_class.new(
+        method: 'GET', route: '/', status_code: 200, start_time: Time.now
+      )
+    end
+
+    it { is_expected.to respond_to(:stash) }
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,88 @@
+RSpec.describe Airbrake::Response do
+  describe ".parse" do
+    [200, 201, 204].each do |code|
+      context "when response code is #{code}" do
+        it "logs response body" do
+          expect(Airbrake::Loggable.instance).to receive(:debug).with(
+            /Airbrake::Response \(#{code}\): {}/
+          )
+          described_class.parse(OpenStruct.new(code: code, body: '{}'))
+        end
+      end
+    end
+
+    [400, 401, 403, 420].each do |code|
+      context "when response code is #{code}" do
+        it "logs response message" do
+          expect(Airbrake::Loggable.instance).to receive(:error).with(
+            /Airbrake: foo/
+          )
+          described_class.parse(
+            OpenStruct.new(code: code, body: '{"message":"foo"}')
+          )
+        end
+      end
+    end
+
+    context "when response code is 429" do
+      let(:response) { OpenStruct.new(code: 429, body: '{"message":"rate limited"}') }
+
+      it "logs response message" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /Airbrake: rate limited/
+        )
+        described_class.parse(response)
+      end
+
+      it "returns an error response" do
+        time = Time.now
+        allow(Time).to receive(:now).and_return(time)
+
+        resp = described_class.parse(response)
+        expect(resp).to include(
+          'error' => '**Airbrake: rate limited',
+          'rate_limit_reset' => time
+        )
+      end
+    end
+
+    context "when response code is unhandled" do
+      let(:response) { OpenStruct.new(code: 500, body: 'foo') }
+
+      it "logs response body" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /Airbrake: unexpected code \(500\)\. Body: foo/
+        )
+        described_class.parse(response)
+      end
+
+      it "returns an error response" do
+        resp = described_class.parse(response)
+        expect(resp).to eq('error' => 'foo')
+      end
+
+      it "truncates body" do
+        response.body *= 1000
+        resp = described_class.parse(response)
+        expect(resp).to eq('error' => ('foo' * 33) + 'fo...')
+      end
+    end
+
+    context "when response body can't be parsed as JSON" do
+      let(:response) { OpenStruct.new(code: 201, body: 'foo') }
+
+      it "logs response body" do
+        expect(Airbrake::Loggable.instance).to receive(:error).with(
+          /Airbrake: error while parsing body \(.*unexpected token.*\)\. Body: foo/
+        )
+        described_class.parse(response)
+      end
+
+      it "returns an error message" do
+        expect(described_class.parse(response)['error']).to match(
+          /\A#<JSON::ParserError.+>/
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+require 'simplecov'
+SimpleCov.start if ENV['COVERAGE']
+
+require 'airbrake-ruby'
+
+require 'rspec/its'
+
+require 'webmock'
+require 'webmock/rspec'
+require 'pry'
+
+require 'pathname'
+require 'webrick'
+require 'English'
+require 'base64'
+require 'pp'
+
+require 'helpers'
+
+RSpec.configure do |c|
+  c.order = 'random'
+  c.color = true
+  c.disable_monkey_patching!
+  c.include Helpers
+end
+
+Thread.abort_on_exception = true
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+class AirbrakeTestError < RuntimeError
+  attr_reader :backtrace
+
+  def initialize(*)
+    super
+    # rubocop:disable Metrics/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'",
+      "/opt/rubies/ruby-2.2.2/lib/ruby/2.2.0/rubygems/core_ext/kernel_require.rb:54:in `require'",
+      "/home/kyrylo/code/airbrake/ruby/spec/airbrake_spec.rb:1:in `<top (required)>'",
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb:1327:in `load'",
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb:1327:in `block in load_spec_files'",
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb:1325:in `each'",
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/configuration.rb:1325:in `load_spec_files'",
+      "/home/kyrylo/.gem/ruby/2.2.2/gems/rspec-core-3.3.2/lib/rspec/core/runner.rb:102:in `setup'",
+      "/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>'"
+    ]
+    # rubocop:enable Metrics/LineLength
+  end
+
+  # rubocop:disable Naming/AccessorMethodName
+  def set_backtrace(backtrace)
+    @backtrace = backtrace
+  end
+  # rubocop:enable Naming/AccessorMethodName
+
+  def message
+    'App crashed!'
+  end
+end
+
+class JavaAirbrakeTestError < AirbrakeTestError
+  def initialize(*)
+    super
+    # rubocop:disable Metrics/LineLength
+    @backtrace = [
+      "org.jruby.java.invokers.InstanceMethodInvoker.call(InstanceMethodInvoker.java:26)",
+      "org.jruby.ir.interpreter.Interpreter.INTERPRET_EVAL(Interpreter.java:126)",
+      "org.jruby.RubyKernel$INVOKER$s$0$3$eval19.call(RubyKernel$INVOKER$s$0$3$eval19.gen)",
+      "org.jruby.RubyKernel$INVOKER$s$0$0$loop.call(RubyKernel$INVOKER$s$0$0$loop.gen)",
+      "org.jruby.runtime.IRBlockBody.doYield(IRBlockBody.java:139)",
+      "org.jruby.RubyKernel$INVOKER$s$rbCatch19.call(RubyKernel$INVOKER$s$rbCatch19.gen)",
+      "opt.rubies.jruby_minus_9_dot_0_dot_0_dot_0.bin.irb.invokeOther4:start(/opt/rubies/jruby-9.0.0.0/bin/irb)",
+      "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)"
+    ]
+    # rubocop:enable Metrics/LineLength
+  end
+
+  def is_a?(*)
+    true
+  end
+end
+
+class Ruby21Error < RuntimeError
+  attr_accessor :cause
+
+  def self.raise_error(msg)
+    ex = new(msg)
+    ex.cause = $ERROR_INFO
+
+    raise ex
+  end
+end

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

@@ -0,0 +1,47 @@
+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, 22, 0) }
+
+    before { subject.increment(start_time, end_time) }
+
+    its(:sum) { is_expected.to eq(2000) }
+  end
+
+  describe "#increment_ms" do
+    before { subject.increment_ms(1000) }
+
+    its(:count) { is_expected.to eq(1) }
+    its(:sum) { is_expected.to eq(1000) }
+    its(:sumsq) { is_expected.to eq(1000000) }
+
+    it "updates tdigest" do
+      expect(subject.tdigest.size).to eq(1)
+    end
+  end
+
+  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
+
+  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

@@ -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