airbrake-ruby 4.7.0

data/spec/notice_notifier_spec.rb

@@ -0,0 +1,356 @@
+RSpec.describe Airbrake::NoticeNotifier do
+  before do
+    Airbrake::Config.instance = Airbrake::Config.new(
+      project_id: 1,
+      project_key: 'abc',
+      logger: Logger.new('/dev/null'),
+      performance_stats: true
+    )
+  end
+
+  describe "#new" do
+    describe "default filter addition" do
+      before { allow_any_instance_of(Airbrake::FilterChain).to receive(:add_filter) }
+
+      it "appends the context filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ContextFilter))
+        subject
+      end
+
+      it "appends the exception attributes filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ExceptionAttributesFilter))
+        subject
+      end
+    end
+  end
+
+  describe "#notify" do
+    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }.to_json
+    end
+
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body) }
+
+    it "returns a promise" do
+      expect(subject.notify('ex')).to be_an(Airbrake::Promise)
+      sleep 1
+    end
+
+    it "refines the notice object" do
+      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = subject.build_notice('ex')
+      subject.notify(notice)
+      expect(notice[:params]).to eq(foo: 'bar')
+      sleep 1
+    end
+
+    context "when config is invalid" do
+      before { Airbrake::Config.instance.merge(project_id: nil) }
+
+      it "returns a rejected promise" do
+        promise = subject.notify({})
+        expect(promise).to be_rejected
+      end
+    end
+
+    context "when a notice is not ignored" do
+      it "yields the notice" do
+        expect { |b| subject.notify('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+        sleep 1
+      end
+    end
+
+    context "when a notice is ignored via a filter" do
+      before { subject.add_filter(&:ignore!) }
+
+      it "yields the notice" do
+        expect { |b| subject.notify('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+
+      it "returns a rejected promise" do
+        value = subject.notify('ex').value
+        expect(value['error']).to match(/was marked as ignored/)
+      end
+    end
+
+    context "when a notice is ignored via an inline filter" do
+      before { subject.add_filter { raise AirbrakeTestError } }
+
+      it "doesn't invoke regular filters" do
+        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+      end
+    end
+
+    context "when async sender has workers" do
+      it "sends an exception asynchronously" do
+        expect_any_instance_of(Airbrake::AsyncSender).to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+    end
+
+    context "when async sender doesn't have workers" do
+      it "sends an exception synchronously" do
+        expect_any_instance_of(Airbrake::AsyncSender)
+          .to receive(:has_workers?).and_return(false)
+        expect_any_instance_of(Airbrake::SyncSender).to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+    end
+
+    context "when the provided environment is ignored" do
+      before do
+        Airbrake::Config.instance.merge(
+          environment: 'test',
+          ignore_environments: %w[test]
+        )
+      end
+
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::AsyncSender).not_to receive(:send)
+        subject.notify('foo', bingo: 'bango')
+      end
+
+      it "returns a rejected promise" do
+        promise = subject.notify('foo', bingo: 'bango')
+        expect(promise.value).to eq('error' => "current environment 'test' is ignored")
+      end
+    end
+  end
+
+  describe "#notify_sync" do
+    let(:endpoint) { 'https://api.airbrake.io/api/v3/projects/1/notices' }
+
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }
+    end
+
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body.to_json) }
+
+    it "returns a reponse hash" do
+      expect(subject.notify_sync('ex')).to eq(body)
+    end
+
+    it "refines the notice object" do
+      subject.add_filter { |n| n[:params] = { foo: 'bar' } }
+      notice = subject.build_notice('ex')
+      subject.notify_sync(notice)
+      expect(notice[:params]).to eq(foo: 'bar')
+    end
+
+    it "sends an exception synchronously" do
+      subject.notify_sync('foo', bingo: 'bango')
+      expect(
+        a_request(:post, endpoint).with(
+          body: /"params":{.*"bingo":"bango".*}/
+        )
+      ).to have_been_made.once
+    end
+
+    context "when a notice is not ignored" do
+      it "yields the notice" do
+        expect { |b| subject.notify_sync('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+    end
+
+    context "when a notice is ignored via a filter" do
+      before { subject.add_filter(&:ignore!) }
+
+      it "yields the notice" do
+        expect { |b| subject.notify_sync('ex', &b) }
+          .to yield_with_args(Airbrake::Notice)
+      end
+
+      it "returns an error hash" do
+        response = subject.notify_sync('ex')
+        expect(response['error']).to match(/was marked as ignored/)
+      end
+    end
+
+    context "when a notice is ignored via an inline filter" do
+      before { subject.add_filter { raise AirbrakeTestError } }
+
+      it "doesn't invoke regular filters" do
+        expect { subject.notify('ex', &:ignore!) }.not_to raise_error
+      end
+    end
+
+    context "when the provided environment is ignored" do
+      before do
+        Airbrake::Config.instance.merge(
+          environment: 'test', ignore_environments: %w[test]
+        )
+      end
+
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::SyncSender).not_to receive(:send)
+        subject.notify_sync('foo', bingo: 'bango')
+      end
+
+      it "returns an error hash" do
+        expect(subject.notify_sync('foo'))
+          .to eq('error' => "current environment 'test' is ignored")
+      end
+    end
+  end
+
+  describe "#add_filter" do
+    context "given a block" do
+      it "appends a new filter to the filter chain" do
+        notifier = subject
+        b = proc {}
+        expect_any_instance_of(Airbrake::FilterChain)
+          .to receive(:add_filter) { |*args| expect(args.last).to be(b) }
+        notifier.add_filter(&b)
+      end
+    end
+
+    context "given a class" do
+      it "appends a new filter to the filter chain" do
+        notifier = subject
+        klass = Class.new
+        expect_any_instance_of(Airbrake::FilterChain)
+          .to receive(:add_filter).with(klass)
+        notifier.add_filter(klass)
+      end
+    end
+  end
+
+  describe "#build_notice" do
+    context "when given exception is another notice" do
+      it "merges params with the notice" do
+        notice = subject.build_notice('ex')
+        other = subject.build_notice(notice, foo: 'bar')
+        expect(other[:params]).to eq(foo: 'bar')
+      end
+
+      it "it returns the provided notice" do
+        notice = subject.build_notice('ex')
+        other = subject.build_notice(notice, foo: 'bar')
+        expect(other).to eq(notice)
+      end
+    end
+
+    context "when given exception is an Exception" do
+      it "prevents mutation of passed-in params hash" do
+        params = { immutable: true }
+        notice = subject.build_notice('ex', params)
+        notice[:params][:mutable] = true
+        expect(params).to eq(immutable: true)
+      end
+
+      context "and also when it doesn't have own backtrace" do
+        context "and when the generated backtrace consists only of library frames" do
+          it "returns the full generated backtrace" do
+            backtrace = [
+              "/lib/airbrake-ruby/a.rb:84:in `build_notice'",
+              "/lib/airbrake-ruby/b.rb:124:in `send_notice'"
+            ]
+            allow(Kernel).to receive(:caller).and_return(backtrace)
+
+            notice = subject.build_notice(Exception.new)
+
+            expect(notice[:errors].first[:backtrace]).to eq(
+              [
+                { file: '/lib/airbrake-ruby/a.rb', line: 84, function: 'build_notice' },
+                { file: '/lib/airbrake-ruby/b.rb', line: 124, function: 'send_notice' }
+              ]
+            )
+          end
+        end
+
+        context "and when the generated backtrace consists of mixed frames" do
+          it "returns the filtered backtrace" do
+            backtrace = [
+              "/airbrake-ruby/lib/airbrake-ruby/a.rb:84:in `b'",
+              "/airbrake-ruby/lib/foo/b.rb:84:in `build'",
+              "/airbrake-ruby/lib/bar/c.rb:124:in `send'"
+            ]
+            allow(Kernel).to receive(:caller).and_return(backtrace)
+
+            notice = subject.build_notice(Exception.new)
+
+            expect(notice[:errors].first[:backtrace]).to eq(
+              [
+                { file: '/airbrake-ruby/lib/foo/b.rb', line: 84, function: 'build' },
+                { file: '/airbrake-ruby/lib/bar/c.rb', line: 124, function: 'send' }
+              ]
+            )
+          end
+        end
+      end
+    end
+
+    # TODO: this seems to be bugged. Fix later.
+    context "when given exception is a Java exception", skip: true do
+      before do
+        expect(Airbrake::Backtrace).to receive(:java_exception?).and_return(true)
+      end
+
+      it "automatically generates the backtrace" do
+        backtrace = [
+          "org/jruby/RubyKernel.java:998:in `eval'",
+          "/ruby/stdlib/irb/workspace.rb:87:in `evaluate'",
+          "/ruby/stdlib/irb.rb:489:in `block in eval_input'"
+        ]
+        allow(Kernel).to receive(:caller).and_return(backtrace)
+
+        notice = subject.build_notice(Exception.new)
+
+        # rubocop:disable Metrics/LineLength
+        expect(notice[:errors].first[:backtrace]).to eq(
+          [
+            { file: 'org/jruby/RubyKernel.java', line: 998, function: 'eval' },
+            { file: '/ruby/stdlib/irb/workspace.rb', line: 87, function: 'evaluate' },
+            { file: '/ruby/stdlib/irb.rb:489', line: 489, function: 'block in eval_input' }
+          ]
+        )
+        # rubocop:enable Metrics/LineLength
+      end
+    end
+
+    context "when async sender is closed" do
+      before do
+        expect_any_instance_of(Airbrake::AsyncSender)
+          .to receive(:closed?).and_return(true)
+      end
+
+      it "raises error" do
+        expect { subject.build_notice(Exception.new) }.to raise_error(
+          Airbrake::Error,
+          'attempted to build Exception with closed Airbrake instance'
+        )
+      end
+    end
+  end
+
+  describe "#close" do
+    it "sends the close message to async sender" do
+      expect_any_instance_of(Airbrake::AsyncSender).to receive(:close)
+      subject.close
+    end
+  end
+
+  describe "#configured?" do
+    it { is_expected.to be_configured }
+  end
+
+  describe "#merge_context" do
+    it "merges the provided context with the notice object" do
+      expect_any_instance_of(Hash).to receive(:merge!).with(apples: 'oranges')
+      subject.merge_context(apples: 'oranges')
+    end
+  end
+end

data/spec/notice_spec.rb

@@ -0,0 +1,296 @@
+RSpec.describe Airbrake::Notice do
+  let(:notice) { described_class.new(AirbrakeTestError.new, bingo: '1') }
+
+  describe "#to_json" do
+    context "app_version" do
+      context "when missing" do
+        before { Airbrake::Config.instance.merge(app_version: nil) }
+
+        it "doesn't include app_version" do
+          expect(notice.to_json).not_to match(/"context":{"version":"1.2.3"/)
+        end
+      end
+
+      context "when present" do
+        let(:notice) { described_class.new(AirbrakeTestError.new) }
+
+        before do
+          Airbrake::Config.instance.merge(
+            app_version: "1.2.3",
+            root_directory: "/one/two"
+          )
+        end
+
+        it "includes app_version" do
+          expect(notice.to_json).to match(/"context":{"version":"1.2.3"/)
+        end
+
+        it "includes root_directory" do
+          expect(notice.to_json).to match(%r{"rootDirectory":"/one/two"})
+        end
+      end
+    end
+
+    context "when versions is empty" do
+      it "doesn't set the 'versions' payload" do
+        expect(notice.to_json).not_to match(
+          /"context":{"versions":{"dep":"1.2.3"}}/
+        )
+      end
+    end
+
+    context "when versions is not empty" do
+      it "sets the 'versions' payload" do
+        notice[:context][:versions] = { 'dep' => '1.2.3' }
+        expect(notice.to_json).to match(
+          /"context":{.*"versions":{"dep":"1.2.3"}.*}/
+        )
+      end
+    end
+
+    context "truncation" do
+      shared_examples 'payloads' do |size, msg|
+        it msg do
+          ex = AirbrakeTestError.new
+
+          backtrace = []
+          size.times { backtrace << "bin/rails:3:in `<main>'" }
+          ex.set_backtrace(backtrace)
+
+          notice = described_class.new(ex)
+
+          expect(notice.to_json.bytesize).to be < 64000
+        end
+      end
+
+      max_msg = 'truncates to the max allowed size'
+
+      context "with an extremely huge payload" do
+        include_examples 'payloads', 200_000, max_msg
+      end
+
+      context "with a big payload" do
+        include_examples 'payloads', 50_000, max_msg
+      end
+
+      small_msg = "doesn't truncate it"
+
+      context "with a small payload" do
+        include_examples 'payloads', 1000, small_msg
+      end
+
+      context "with a tiny payload" do
+        include_examples 'payloads', 300, small_msg
+      end
+
+      context "when truncation failed" do
+        it "returns nil" 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 = described_class.new(ex)
+          expect(notice.to_json).to be_nil
+        end
+      end
+
+      describe "object replacement with its string version" do
+        let(:klass) { Class.new {} }
+        let(:ex) { AirbrakeTestError.new }
+        let(:params) { { bingo: [Object.new, klass.new] } }
+        let(:notice) { described_class.new(ex, params) }
+
+        before do
+          backtrace = []
+          backtrace_size.times { backtrace << "bin/rails:3:in `<main>'" }
+          ex.set_backtrace(backtrace)
+        end
+
+        context "with payload within the limits" do
+          let(:backtrace_size) { 1000 }
+
+          it "doesn't happen" do
+            expect(notice.to_json)
+              .to match(/bingo":\["#<Object:.+>","#<#<Class:.+>:.+>"/)
+          end
+        end
+
+        context "with payload bigger than the limit" do
+          context "with payload within the limits" do
+            let(:backtrace_size) { 50_000 }
+
+            it "happens" do
+              expect(notice.to_json)
+                .to match(/bingo":\[".+Object.+",".+Class.+"/)
+            end
+          end
+        end
+      end
+    end
+
+    context "given a closed IO object" do
+      context "and when it is not monkey-patched by ActiveSupport" do
+        it "is not getting truncated" do
+          notice[:params] = { obj: IO.new(0).tap(&:close) }
+          expect(notice.to_json).to match(/"obj":"#<IO:0x.+>"/)
+        end
+      end
+
+      context "and when it is monkey-patched by ActiveSupport" do
+        # Instances of this class contain a closed IO object assigned to an
+        # instance variable. Normally, the JSON gem, which we depend on can
+        # parse closed IO objects. However, because ActiveSupport monkey-patches
+        # #to_json and calls #to_a on them, they raise IOError when we try to
+        # serialize them.
+        #
+        # @see https://goo.gl/0A3xNC
+        class ObjectWithIoIvars
+          def initialize
+            @bongo = Tempfile.new('bongo').tap(&:close)
+          end
+
+          # @raise [NotImplementedError] when inside a Rails environment
+          def to_json(*)
+            raise NotImplementedError
+          end
+        end
+
+        # @see ObjectWithIoIvars
+        class ObjectWithNestedIoIvars
+          def initialize
+            @bish = ObjectWithIoIvars.new
+          end
+
+          # @see ObjectWithIoIvars#to_json
+          def to_json(*)
+            raise NotImplementedError
+          end
+        end
+
+        context "and also when it's a closed Tempfile" do
+          it "doesn't fail" do
+            notice[:params] = { obj: Tempfile.new('bongo').tap(&:close) }
+            expect(notice.to_json).to match(/"obj":"#<(Temp)?file:0x.+>"/i)
+          end
+        end
+
+        context "and also when it's an IO ivar" do
+          it "doesn't fail" do
+            notice[:params] = { obj: ObjectWithIoIvars.new }
+            expect(notice.to_json).to match(/"obj":".+ObjectWithIoIvars.+"/)
+          end
+
+          context "and when it's deeply nested inside a hash" do
+            it "doesn't fail" do
+              notice[:params] = { a: { b: { c: ObjectWithIoIvars.new } } }
+              expect(notice.to_json).to match(
+                /"params":{"a":{"b":{"c":".+ObjectWithIoIvars.+"}}.*}/
+              )
+            end
+          end
+
+          context "and when it's deeply nested inside an array" do
+            it "doesn't fail" do
+              notice[:params] = { a: [[ObjectWithIoIvars.new]] }
+              expect(notice.to_json).to match(
+                /"params":{"a":\[\[".+ObjectWithIoIvars.+"\]\].*}/
+              )
+            end
+          end
+        end
+
+        context "and also when it's a non-IO ivar, which contains an IO ivar itself" do
+          it "doesn't fail" do
+            notice[:params] = { obj: ObjectWithNestedIoIvars.new }
+            expect(notice.to_json).to match(/"obj":".+ObjectWithNested.+"/)
+          end
+        end
+      end
+    end
+
+    it "overwrites the 'notifier' payload with the default values" do
+      notice[:notifier] = { name: 'bingo', bango: 'bongo' }
+
+      expect(notice.to_json)
+        .to match(/"notifier":{"name":"airbrake-ruby","version":".+","url":".+"}/)
+    end
+
+    it "always contains context/hostname" do
+      expect(notice.to_json)
+        .to match(/"context":{.*"hostname":".+".*}/)
+    end
+
+    it "defaults to the error severity" do
+      expect(notice.to_json).to match(/"context":{.*"severity":"error".*}/)
+    end
+
+    it "always contains environment/program_name" do
+      expect(notice.to_json)
+        .to match(%r|"environment":{"program_name":.+/rspec.*|)
+    end
+
+    it "contains errors" do
+      expect(notice.to_json)
+        .to match(/"errors":\[{"type":"AirbrakeTestError","message":"App crash/)
+    end
+
+    it "contains a backtrace" do
+      expect(notice.to_json)
+        .to match(%r|"backtrace":\[{"file":"/home/.+/spec/spec_helper.rb"|)
+    end
+
+    it "contains params" do
+      expect(notice.to_json).to match(/"params":{"bingo":"1"}/)
+    end
+  end
+
+  describe "#[]" do
+    it "accesses payload" do
+      expect(notice[:params]).to eq(bingo: '1')
+    end
+
+    it "raises error if notice is ignored" do
+      notice.ignore!
+      expect { notice[:params] }
+        .to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
+    end
+  end
+
+  describe "#[]=" do
+    it "sets a payload value" do
+      hash = { bingo: 'bango' }
+      notice[:params] = hash
+      expect(notice[:params]).to equal(hash)
+    end
+
+    it "raises error if notice is ignored" do
+      notice.ignore!
+      expect { notice[:params] = {} }
+        .to raise_error(Airbrake::Error, 'cannot access ignored Airbrake::Notice')
+    end
+
+    it "raises error when trying to assign unrecognized key" do
+      expect { notice[:bingo] = 1 }
+        .to raise_error(Airbrake::Error, /:bingo is not recognized among/)
+    end
+
+    it "raises when setting non-hash objects as the value" do
+      expect { notice[:params] = Object.new }
+        .to raise_error(Airbrake::Error, 'Got Object value, wanted a Hash')
+    end
+  end
+
+  describe "#stash" do
+    subject { described_class.new(AirbrakeTestError.new) }
+
+    it { is_expected.to respond_to(:stash) }
+  end
+end