airbrake-ruby 2.9.0 → 2.10.0

data/spec/async_sender_spec.rb

@@ -117,6 +117,15 @@ RSpec.describe Airbrake::AsyncSender do
       @sender.close
       expect(@sender).not_to have_workers
     end
+
+    it "respawns workers on fork()", skip: %w[jruby rbx].include?(RUBY_ENGINE) do
+      pid = fork do
+        expect(@sender).to have_workers
+      end
+      Process.wait(pid)
+      @sender.close
+      expect(@sender).not_to have_workers
+    end
   end
 
   describe "#spawn_workers" do

data/spec/config_spec.rb

@@ -25,6 +25,10 @@ RSpec.describe Airbrake::Config do
         expect(config.app_version).to be_nil
       end
 
+      it "sets the default versions" do
+        expect(config.versions).to be_empty
+      end
+
       it "sets the default host" do
         expect(config.host).to eq('https://airbrake.io')
       end

data/spec/filters/dependency_filter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Filters::DependencyFilter do
+  let(:notice) do
+    Airbrake::Notice.new(Airbrake::Config.new, AirbrakeTestError.new)
+  end
+
+  describe "#call" do
+    it "attaches loaded dependencies to context/versions/dependencies" do
+      subject.call(notice)
+      expect(notice[:context][:versions][:dependencies]).to include(
+        'airbrake-ruby' => Airbrake::AIRBRAKE_RUBY_VERSION
+      )
+    end
+  end
+end

data/spec/filters/exception_attributes_filter_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::Filters::ExceptionAttributesFilter do
+  describe "#call" do
+    let(:out) { StringIO.new }
+    let(:notice) { Airbrake::Notice.new(Airbrake::Config.new, ex) }
+
+    subject { described_class.new(Logger.new(out)) }
+
+    context "when #to_airbrake returns a non-Hash object" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            Object.new
+          end
+        end.new
+      end
+
+      it "doesn't raise" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(notice[:params]).to be_empty
+      end
+
+      it "logs the error" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(out.string).to match(/wanted Hash, got Object/)
+      end
+    end
+
+    context "when #to_airbrake errors out" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            1 / 0
+          end
+        end.new
+      end
+
+      it "doesn't raise" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(notice[:params]).to be_empty
+      end
+
+      it "logs the error" do
+        expect { subject.call(notice) }.not_to raise_error
+        expect(out.string).to match(/#to_airbrake failed.+ZeroDivisionError/)
+      end
+    end
+
+    context "when #to_airbrake returns a hash" do
+      let(:ex) do
+        Class.new(AirbrakeTestError) do
+          def to_airbrake
+            { params: { foo: '1' } }
+          end
+        end.new
+      end
+
+      it "merges parameters with the notice" do
+        subject.call(notice)
+        expect(notice[:params]).to eq(foo: '1')
+      end
+    end
+  end
+end

data/spec/filters/keys_whitelist_spec.rb

@@ -146,31 +146,25 @@ RSpec.describe Airbrake::Filters::KeysWhitelist do
     end
 
     context "and it is recursive" do
-      let(:patterns) { %w[bingo bango] }
-
-      it "errors when nested hashes are not filtered" do
-        bongo = { bingo: {} }
-        bongo[:bingo][:bango] = bongo
+      let(:patterns) { ['bingo'] }
+
+      it "raises error (MRI)", skip: (
+        # MRI 2.3 & 2.4 may segfault on Circle CI. Example build:
+        # https://circleci.com/workflow-run/c112358c-e7bf-4789-9eb2-4891ea84da68
+        RUBY_ENGINE == 'ruby' && RUBY_VERSION =~ /\A2\.[34]\.\d+\z/
+      ) do
+        bongo = {}
+        bongo[:bingo] = bongo
         notice[:params] = bongo
 
-        if RUBY_ENGINE == 'jruby'
-          # JRuby might raise two different exceptions, which represent the
-          # same thing. One is a Java exception, the other is a Ruby
-          # exception. It's probably a JRuby bug:
-          # https://github.com/jruby/jruby/issues/1903
-          begin
-            expect do
-              subject.call(notice)
-            end.to raise_error(SystemStackError)
-          rescue RSpec::Expectations::ExpectationNotMetError
-            expect do
-              subject.call(notice)
-            end.to raise_error(java.lang.StackOverflowError)
-          end
-        else
-          expect do
-            subject.call(notice)
-          end.to raise_error(SystemStackError)
+        begin
+          expect { subject.call(notice) }.to raise_error(SystemStackError)
+        rescue RSpec::Expectations::ExpectationNotMetError => ex
+          # JRuby might raise two different exceptions, which represent the same
+          # thing. One is a Java exception, the other is a Ruby exception.
+          # Likely a bug: https://github.com/jruby/jruby/issues/1903
+          raise ex unless RUBY_ENGINE == 'jruby'
+          expect { subject.call(notice) }.to raise_error(java.lang.StackOverflowError)
         end
       end
     end

data/spec/notice_spec.rb

@@ -5,75 +5,6 @@ RSpec.describe Airbrake::Notice do
     described_class.new(Airbrake::Config.new, AirbrakeTestError.new, bingo: '1')
   end
 
-  describe "#new" do
-    let(:params) do
-      { bingo: 'bango', bongo: 'bish' }
-    end
-
-    let(:ex) { airbrake_exception_class.new(params) }
-
-    context "given an exception class, which supports #to_airbrake" do
-      context "and when #to_airbrake returns a non-Hash object" do
-        let(:airbrake_exception_class) do
-          Class.new(AirbrakeTestError) do
-            def to_airbrake
-              Object.new
-            end
-          end
-        end
-
-        it "rescues the error, logs it and doesn't modify the payload" do
-          out = StringIO.new
-          config = Airbrake::Config.new(logger: Logger.new(out))
-          notice = nil
-
-          expect { notice = described_class.new(config, ex) }.not_to raise_error
-          expect(out.string).to match(/#to_airbrake failed:.+Object.+must be a Hash/)
-          expect(notice[:params]).to be_empty
-        end
-      end
-
-      context "and when #to_airbrake errors out" do
-        let(:airbrake_exception_class) do
-          Class.new(AirbrakeTestError) do
-            def to_airbrake
-              1 / 0
-            end
-          end
-        end
-
-        it "rescues the error, logs it and doesn't modify the payload" do
-          out = StringIO.new
-          config = Airbrake::Config.new(logger: Logger.new(out))
-          notice = nil
-
-          expect { notice = described_class.new(config, ex) }.not_to raise_error
-          expect(out.string).to match(/#to_airbrake failed: ZeroDivisionError/)
-          expect(notice[:params]).to be_empty
-        end
-      end
-
-      context "and when #to_airbrake succeeds" do
-        let(:airbrake_exception_class) do
-          Class.new(AirbrakeTestError) do
-            def initialize(params)
-              @params = params
-            end
-
-            def to_airbrake
-              { params: @params }
-            end
-          end
-        end
-
-        it "merges the parameters with the notice" do
-          notice = described_class.new(Airbrake::Config.new, ex)
-          expect(notice[:params]).to eq(params)
-        end
-      end
-    end
-  end
-
   describe "#to_json" do
     context "app_version" do
       context "when missing" do
@@ -99,6 +30,23 @@ RSpec.describe Airbrake::Notice do
       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
@@ -189,6 +137,86 @@ RSpec.describe Airbrake::Notice do
       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' }
 
@@ -209,6 +237,20 @@ RSpec.describe Airbrake::Notice 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

data/spec/notifier_spec.rb

@@ -1,628 +1,437 @@
 require 'spec_helper'
 
+# rubocop:disable Layout/DotPosition
 RSpec.describe Airbrake::Notifier do
-  def expect_a_request_with_body(body)
-    expect(a_request(:post, endpoint).with(body: body)).to have_been_made.once
+  let(:user_params) do
+    { project_id: 1, project_key: 'abc', logger: Logger.new('/dev/null') }
   end
 
-  let(:project_id) { 105138 }
-  let(:project_key) { 'fd04e13d806a90f96614ad8e529b2822' }
-  let(:localhost) { 'http://localhost:8080' }
-  let(:endpoint) { "https://airbrake.io/api/v3/projects/#{project_id}/notices" }
-
-  let(:airbrake_params) do
-    { project_id: project_id,
-      project_key: project_key,
-      logger: Logger.new(StringIO.new) }
-  end
-
-  let(:ex) { AirbrakeTestError.new }
-
-  before do
-    # rubocop:disable Metrics/LineLength
-    body = '{"id":"00054414-b147-6ffa-85d6-1524d83362a6","url":"http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6"}'
-    # rubocop:enable Metrics/LineLength
-    stub_request(:post, endpoint).to_return(status: 201, body: body)
-    @airbrake = described_class.new(airbrake_params)
-  end
+  subject { described_class.new(user_params) }
 
   describe "#new" do
-    context "raises error if" do
-      example ":project_id is not provided" do
-        expect { described_class.new(project_key: project_key) }.
-          to raise_error(Airbrake::Error, ':project_id is required')
-      end
+    describe "default filter addition" do
+      before { allow_any_instance_of(Airbrake::FilterChain).to receive(:add_filter) }
 
-      example ":project_key is not provided" do
-        expect { described_class.new(project_id: project_id) }.
-          to raise_error(Airbrake::Error, ':project_key is required')
+      it "appends the context filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ContextFilter))
+        described_class.new(user_params)
       end
 
-      example "neither :project_id nor :project_key are provided" do
-        expect { described_class.new({}) }.
-          to raise_error(Airbrake::Error, ':project_id is required')
+      it "appends the exception attributes filter" do
+        expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+          .with(instance_of(Airbrake::Filters::ExceptionAttributesFilter))
+        described_class.new(user_params)
       end
-    end
-
-    context "when the argument is Airbrake::Config" do
-      it "uses it instead of the hash" do
-        airbrake = described_class.new(
-          Airbrake::Config.new(project_id: 123, project_key: '321')
-        )
-        config = airbrake.instance_variable_get(:@config)
-        expect(config.project_id).to eq(123)
-        expect(config.project_key).to eq('321')
-      end
-    end
-  end
 
-  describe "#notify_sync" do
-    it "returns a hash with error id & url" do
-      expect(@airbrake.notify_sync(ex)).to(
-        eq(
-          'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
-          'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
-        )
-      )
-    end
-
-    describe "first argument" do
-      context "when it is a Notice" do
-        it "sends the argument" do
-          notice = @airbrake.build_notice(ex)
-          @airbrake.notify_sync(notice)
-
-          # rubocop:disable Metrics/LineLength
-          expected_body = %r|
-            {"errors":\[{"type":"AirbrakeTestError","message":"App\scrashed!","backtrace":\[
-            {"file":"[\w/-]+/spec/spec_helper.rb","line":\d+,"function":"<top\s\(required\)>"},
-            {"file":"[\w/\-\.]+/rubygems/core_ext/kernel_require\.rb","line":\d+,"function":"require"},
-            {"file":"[\w/\-\.]+/rubygems/core_ext/kernel_require\.rb","line":\d+,"function":"require"}
-          |x
-          # rubocop:enable Metrics/LineLength
-
-          expect(
-            a_request(:post, endpoint).
-            with(body: expected_body)
-          ).to have_been_made.once
+      context "when user config has some whitelist keys" do
+        it "appends the whitelist filter" do
+          expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::KeysWhitelist))
+          described_class.new(user_params.merge(whitelist_keys: ['foo']))
         end
-
-        it "appends provided params to the notice" do
-          notice = @airbrake.build_notice(ex)
-          @airbrake.notify_sync(notice, bingo: 'bango')
-
-          expect_a_request_with_body(/"params":{.*"bingo":"bango".*}/)
-        end
-      end
-    end
-
-    describe "request" do
-      before do
-        @airbrake.notify_sync(ex, bingo: ['bango'], bongo: 'bish')
       end
 
-      it "is being made over HTTPS" do
-        expect(
-          a_request(:post, endpoint).
-          with { |req| req.uri.port == 443 }
-        ).to have_been_made.once
-      end
-
-      describe "headers" do
-        def expect_a_request_with_headers(headers)
-          expect(
-            a_request(:post, endpoint).
-            with(headers: headers)
-          ).to have_been_made.once
-        end
-
-        it "POSTs JSON to Airbrake" do
-          expect_a_request_with_headers('Content-Type' => 'application/json')
-        end
-
-        it "sets User-Agent" do
-          ua = "airbrake-ruby/#{Airbrake::AIRBRAKE_RUBY_VERSION} Ruby/#{RUBY_VERSION}"
-          expect_a_request_with_headers('User-Agent' => ua)
+      context "when user config doesn't have any whitelist keys" do
+        it "doesn't append the whitelist filter" do
+          expect_any_instance_of(Airbrake::FilterChain).not_to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::KeysWhitelist))
+          described_class.new(user_params)
         end
       end
 
-      describe "body" do
-        it "features 'notifier'" do
-          expect_a_request_with_body(/"notifier":{"name":"airbrake-ruby"/)
-        end
-
-        it "features 'context'" do
-          expect_a_request_with_body(/"context":{.*"os":"[\.\w-]+"/)
-        end
-
-        it "features 'errors'" do
-          expect_a_request_with_body(
-            /"errors":\[{"type":"AirbrakeTestError","message":"App crash/
-          )
-        end
-
-        it "features 'backtrace'" do
-          expect_a_request_with_body(
-            %r|"backtrace":\[{"file":"/home/.+/spec/spec_helper.rb"|
-          )
+      context "when user config has some blacklist keys" do
+        it "appends the blacklist filter" do
+          expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::KeysBlacklist))
+          described_class.new(user_params.merge(blacklist_keys: ['bar']))
         end
-
-        it "features 'params'" do
-          expect_a_request_with_body(
-            /"params":{"bingo":\["bango"\],"bongo":"bish".*}/
-          )
-        end
-      end
-    end
-
-    describe "response body when it is" do
-      before do
-        @stdout = StringIO.new
-        params = {
-          logger: Logger.new(@stdout).tap { |l| l.level = Logger::DEBUG }
-        }
-        @airbrake = described_class.new(airbrake_params.merge(params))
       end
 
-      shared_examples "HTTP codes" do |code, body, expected_output|
-        it "logs error #{code}" do
-          stub_request(:post, endpoint).to_return(status: code, body: body)
-
-          expect(@stdout.string).to be_empty
-
-          response = @airbrake.notify_sync(ex)
-
-          expect(@stdout.string).to match(expected_output)
-          expect(response).to be_a Hash
-
-          if response['message']
-            expect(response['message']).to satisfy do |error|
-              error.is_a?(Exception) || error.is_a?(String)
-            end
-          end
+      context "when user config doesn't have any blacklist keys" do
+        it "doesn't append the blacklist filter" do
+          expect_any_instance_of(Airbrake::FilterChain).not_to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::KeysBlacklist))
+          described_class.new(user_params)
         end
       end
 
-      context "a hash with response and invalid status" do
-        include_examples 'HTTP codes', 200,
-                         '{"id":"1","url":"https://airbrake.io/locate/1"}',
-                         %r{unexpected code \(200\). Body: .+url":"https://airbrake.+}
-      end
-
-      context "an empty page" do
-        include_examples 'HTTP codes', 200, '',
-                         /ERROR -- : .+ unexpected code \(200\). Body: \[EMPTY_BODY\]/
+      context "when user config specifies a root directory" do
+        it "appends the root directory filter" do
+          expect_any_instance_of(Airbrake::FilterChain).to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::RootDirectoryFilter))
+          described_class.new(user_params.merge(root_directory: '/foo'))
+        end
       end
 
-      context "a valid body with code 201" do
-        include_examples 'HTTP codes', 201,
-                         '{"id":"1","url":"https://airbrake.io/locate/1"}',
-                         %r|DEBUG -- : .+url"=>"https://airbrake.io/locate/1"}|
+      context "when user config doesn't specify a root directory" do
+        it "doesn't append the root directory filter" do
+          expect_any_instance_of(Airbrake::Config).to receive(:root_directory)
+            .and_return(nil)
+          expect_any_instance_of(Airbrake::FilterChain).not_to receive(:add_filter)
+            .with(instance_of(Airbrake::Filters::RootDirectoryFilter))
+          described_class.new(user_params)
+        end
       end
+    end
 
-      context "a non-parseable page" do
-        include_examples 'HTTP codes', 400, 'bingo bango bongo',
-                         /ERROR -- : .+unexpected token at 'bingo.+'\)\. Body: bingo.+/
-      end
+    context "when user config doesn't contain a project id" do
+      let(:user_config) { { project_id: nil } }
 
-      context "error 400" do
-        include_examples 'HTTP codes', 400, '{"message": "Invalid Content-Type header."}',
-                         /ERROR -- : .+ Invalid Content-Type header\./
+      it "raises error" do
+        expect { described_class.new(user_config) }
+          .to raise_error(Airbrake::Error, ':project_id is required')
       end
+    end
 
-      context "error 401" do
-        include_examples 'HTTP codes', 401,
-                         '{"message":"Project not found or access denied."}',
-                         /ERROR -- : .+ Project not found or access denied./
-      end
+    context "when user config doesn't contain a project key" do
+      let(:user_config) { { project_id: 1, project_key: nil } }
 
-      context "error 420" do
-        include_examples 'HTTP codes', 420,
-                         '{"message":"Project is rate limited."}',
-                         /ERROR -- : .+ Project is rate limited./
+      it "raises error" do
+        expect { described_class.new(user_config) }
+          .to raise_error(Airbrake::Error, ':project_key is required')
       end
+    end
+  end
 
-      context "the IP rate limit message" do
-        include_examples 'HTTP codes', 429, '{"message": "IP is rate limited"}',
-                         /ERROR -- : .+ IP is rate limited/
-      end
+  describe "#notify" do
+    let(:endpoint) { 'https://airbrake.io/api/v3/projects/1/notices' }
 
-      context "the internal server error" do
-        include_examples 'HTTP codes', 500, 'Internal Server Error',
-                         /ERROR -- : .+ unexpected code \(500\). Body: Internal.+ Error/
-      end
+    subject { described_class.new(user_params) }
 
-      context "too long it truncates it and" do
-        include_examples 'HTTP codes', 123, '123 ' * 1000,
-                         /ERROR -- : .+ unexpected code \(123\). Body: .+ 123 123 1\.\.\./
-      end
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }.to_json
     end
 
-    describe "connection timeout" do
-      it "logs the error when it occurs" do
-        stub_request(:post, endpoint).to_timeout
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body) }
 
-        stderr = StringIO.new
-        params = airbrake_params.merge(logger: Logger.new(stderr))
-        airbrake = described_class.new(params)
+    it "returns a promise" do
+      expect(subject.notify('ex')).to be_an(Airbrake::Promise)
+      sleep 1
+    end
 
-        airbrake.notify_sync(ex)
+    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
 
-        expect(stderr.string).
-          to match(/ERROR -- : .+ HTTP error: execution expired/)
+    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
 
-    describe "unicode payload" do
-      context "with valid strings" do
-        it "works correctly" do
-          @airbrake.notify_sync(ex, unicode: "ü ö ä Ä Ü Ö ß привет €25.00 한글")
+    context "when a notice is ignored" do
+      before { subject.add_filter(&:ignore!) }
 
-          expect(
-            a_request(:post, endpoint).
-            with(body: /"unicode":"ü ö ä Ä Ü Ö ß привет €25.00 한글"/)
-          ).to have_been_made.once
-        end
+      it "doesn't yield the notice" do
+        expect { |b| subject.notify('ex', &b) }
+          .not_to yield_with_args(Airbrake::Notice)
       end
 
-      context "with invalid strings" do
-        it "doesn't raise error when string has invalid encoding" do
-          expect do
-            @airbrake.notify_sync('bingo', bongo: "bango\xAE")
-          end.not_to raise_error
-        end
-
-        it "doesn't raise error when string has valid encoding, but invalid characters" do
-          # Shenanigans to get a bad ASCII-8BIT string. Direct conversion raises error.
-          encoded = Base64.encode64("\xD3\xE6\xBC\x9D\xBA").encode!('ASCII-8BIT')
-          bad_string = Base64.decode64(encoded)
-
-          expect do
-            @airbrake.notify_sync('bingo', bongo: bad_string)
-          end.not_to raise_error
-        end
+      it "returns a rejected promise" do
+        value = subject.notify('ex').value
+        expect(value['error']).to match(/was marked as ignored/)
       end
     end
 
-    describe "a closed IO object" do
-      context "outside of the Rails environment" do
-        it "is not getting truncated" do
-          @airbrake.notify_sync(ex, bingo: IO.new(0).tap(&:close))
-
-          expect(
-            a_request(:post, endpoint).with(body: /"bingo":"#<IO:0x.+>"/)
-          ).to have_been_made.once
-        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 "inside the Rails environment" 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
-
-        shared_examples 'truncation' do |params, expected|
-          it "filters it out" do
-            @airbrake.notify_sync(ex, params)
-
-            expect(
-              a_request(:post, endpoint).with(body: expected)
-            ).to have_been_made.once
-          end
-        end
-
-        context "which is an instance of" do
-          context "Tempfile" do
-            params = { bango: Tempfile.new('bongo').tap(&:close) }
-            include_examples 'truncation', params, /"bango":"#<(Temp)?file:0x.+>"/i
-          end
-
-          context "a non-IO class but with" do
-            context "IO ivars" do
-              params = { bongo: ObjectWithIoIvars.new }
-              include_examples 'truncation', params, /"bongo":".+ObjectWithIoIvars.+"/
-            end
-
-            context "a non-IO ivar, which contains an IO ivar itself" do
-              params = { bish: ObjectWithNestedIoIvars.new }
-              include_examples 'truncation', params, /"bish":".+ObjectWithNested.+"/
-            end
-          end
-        end
-
-        context "which is deeply nested inside a hash" do
-          params = { bingo: { bango: { bongo: ObjectWithIoIvars.new } } }
-          include_examples(
-            'truncation',
-            params,
-            /"params":{"bingo":{"bango":{"bongo":".+ObjectWithIoIvars.+"}}.*}/
-          )
-        end
-
-        context "which is deeply nested inside an array" do
-          params = { bingo: [[ObjectWithIoIvars.new]] }
-          include_examples(
-            'truncation',
-            params,
-            /"params":{"bingo":\[\[".+ObjectWithIoIvars.+"\]\].*}/
-          )
-        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
 
-    describe "block argument" do
-      context "when a notice is not ignored" do
-        it "yields the notice" do
-          @airbrake.notify_sync(ex) { |notice| notice[:params][:bingo] = :bango }
-          expect_a_request_with_body(/params":{.*"bingo":"bango".*}/)
-        end
+    context "when the provided environment is ignored" do
+      subject do
+        described_class.new(
+          user_params.merge(environment: 'test', ignore_environments: ['test'])
+        )
       end
 
-      context "when a notice is ignored before entering the block" do
-        it "doesn't call the given block" do
-          @airbrake.add_filter(&:ignore!)
-          @airbrake.notify_sync(ex) { |n| n[:params][:bingo] = :bango }
-          expect(
-            a_request(:post, endpoint).
-            with(body: /params":{.*"bingo":"bango".*}/)
-          ).not_to have_been_made
-        end
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::AsyncSender).not_to receive(:send)
+        subject.notify('foo', bingo: 'bango')
       end
 
-      context "and when a notice is ignored inside the block" do
-        it "doesn't send the notice" do
-          @airbrake.notify_sync(ex, &:ignore!)
-          expect(a_request(:post, endpoint)).not_to have_been_made
-        end
+      it "returns a rejected promise" do
+        promise = subject.notify('foo', bingo: 'bango')
+        expect(promise.value).to eq('error' => "The 'test' environment is ignored")
       end
     end
   end
 
-  describe "#notify" do
-    it "sends an exception asynchronously" do
-      @airbrake.notify(ex, bingo: 'bango')
-
-      sleep 1
+  describe "#notify_sync" do
+    let(:endpoint) { 'https://airbrake.io/api/v3/projects/1/notices' }
 
-      expect_a_request_with_body(/params":{"bingo":"bango".*}/)
+    let(:user_params) do
+      { project_id: 1, project_key: 'abc', logger: Logger.new('/dev/null') }
     end
 
-    it "returns a promise" do
-      expect(@airbrake.notify(ex)).to be_an(Airbrake::Promise)
-      sleep 1
+    let(:body) do
+      {
+        'id' => '00054414-b147-6ffa-85d6-1524d83362a6',
+        'url' => 'http://localhost/locate/00054414-b147-6ffa-85d6-1524d83362a6'
+      }
     end
 
-    it "falls back to synchronous delivery when the async sender is dead" do
-      out = StringIO.new
-      notifier = described_class.new(airbrake_params.merge(logger: Logger.new(out)))
-      async_sender = notifier.instance_variable_get(:@async_sender)
+    before { stub_request(:post, endpoint).to_return(status: 201, body: body.to_json) }
 
-      expect(async_sender).to have_workers
-      async_sender.instance_variable_get(:@workers).list.each(&:kill)
-      sleep 1
-      expect(async_sender).not_to have_workers
-
-      notifier.notify('bango')
-      expect(out.string).to match(/falling back to sync delivery/)
-
-      notifier.close
+    it "returns a reponse hash" do
+      expect(subject.notify_sync('ex')).to eq(body)
     end
 
-    it "respawns workers on fork()", skip: %w[jruby rbx].include?(RUBY_ENGINE) do
-      out = StringIO.new
-      notifier = described_class.new(airbrake_params.merge(logger: Logger.new(out)))
-
-      notifier.notify('bingo', bingo: 'bango')
-      sleep 1
-      expect(out.string).not_to match(/falling back to sync delivery/)
-      expect_a_request_with_body(/"bingo":"bango"/)
-
-      pid = fork do
-        expect(notifier.instance_variable_get(:@async_sender)).to have_workers
-        notifier.notify('bango', bongo: 'bish')
-        sleep 1
-        expect(out.string).not_to match(/falling back to sync delivery/)
-        expect_a_request_with_body(/"bingo":"bango"/)
-      end
-
-      Process.wait(pid)
-      notifier.close
-      expect(notifier.instance_variable_get(:@async_sender)).not_to have_workers
+    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
-  end
-
-  describe "#add_filter" do
-    it "filters notices" do
-      @airbrake.add_filter do |notice|
-        notice[:params][:password] = '[Filtered]'.freeze if notice[:params][:password]
-      end
-
-      @airbrake.notify_sync(ex, password: 's4kr4t')
 
+    it "sends an exception synchronously" do
+      subject.notify_sync('foo', bingo: 'bango')
       expect(
-        a_request(:post, endpoint).
-        with(body: /params":{"password":"\[Filtered\]".*}/)
+        a_request(:post, endpoint).with(
+          body: /"params":{.*"bingo":"bango".*}/
+        )
       ).to have_been_made.once
     end
 
-    it "accepts multiple filters" do
-      %i[bingo bongo bash].each do |key|
-        @airbrake.add_filter do |notice|
-          notice[:params][key] = '[Filtered]'.freeze if notice[:params][key]
-        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
-
-      @airbrake.notify_sync(ex, bingo: ['bango'], bongo: 'bish', bash: 'bosh')
-
-      # rubocop:disable Metrics/LineLength
-      body = /"params":{"bingo":"\[Filtered\]","bongo":"\[Filtered\]","bash":"\[Filtered\]".*}/
-      # rubocop:enable Metrics/LineLength
-
-      expect(
-        a_request(:post, endpoint).
-        with(body: body)
-      ).to have_been_made.once
     end
 
-    it "ignores all notices" do
-      @airbrake.add_filter(&:ignore!)
+    context "when a notice is ignored" do
+      before { subject.add_filter(&:ignore!) }
 
-      @airbrake.notify_sync(ex)
+      it "doesn't yield the notice" do
+        expect { |b| subject.notify_sync('ex', &b) }
+          .not_to yield_with_args(Airbrake::Notice)
+      end
 
-      expect(a_request(:post, endpoint)).not_to have_been_made
+      it "returns an error hash" do
+        response = subject.notify_sync('ex')
+        expect(response['error']).to match(/was marked as ignored/)
+      end
     end
 
-    it "ignores specific notices" do
-      @airbrake.add_filter do |notice|
-        notice.ignore! if notice[:errors][0][:type] == 'RuntimeError'
+    context "when the provided environment is ignored" do
+      subject do
+        described_class.new(
+          user_params.merge(environment: 'test', ignore_environments: ['test'])
+        )
       end
 
-      @airbrake.notify_sync(RuntimeError.new('Not caring!'))
-      expect(a_request(:post, endpoint)).not_to have_been_made
+      it "doesn't send an notice" do
+        expect_any_instance_of(Airbrake::SyncSender).not_to receive(:send)
+        subject.notify_sync('foo', bingo: 'bango')
+      end
 
-      @airbrake.notify_sync(ex)
-      expect(a_request(:post, endpoint)).to have_been_made.once
+      it "returns an error hash" do
+        expect(subject.notify_sync('foo'))
+          .to eq('error' => "The 'test' environment is ignored")
+      end
     end
+  end
 
-    it "ignores descendant classes" do
-      descendant = Class.new(AirbrakeTestError)
-
-      @airbrake.add_filter do |notice|
-        notice.ignore! if notice.stash[:exception].is_a?(AirbrakeTestError)
+  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
 
-      @airbrake.notify_sync(descendant.new('Not caring!'))
-      expect(a_request(:post, endpoint)).not_to have_been_made
-
-      @airbrake.notify_sync(RuntimeError.new('Catch me if you can!'))
-      expect(a_request(:post, endpoint)).to have_been_made.once
+    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
-    it "builds a notice from exception" do
-      expect(@airbrake.build_notice(ex)).to be_an Airbrake::Notice
+    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 "given a non-exception with calculated internal frames only" do
+    context "when given exception is an Exception" do
       it "prevents mutation of passed-in params hash" do
-        params = { only_this_item: true }
-        notice = @airbrake.build_notice(RuntimeError.new('bingo'), params)
-        notice[:params][:extra_item] = :not_in_original_params
-        expect(params).to eq(only_this_item: true)
+        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 "returns the internal frames nevertheless" do
+      it "automatically generates the backtrace" do
         backtrace = [
-          "/airbrake-ruby/lib/airbrake-ruby/notifier.rb:84:in `build_notice'",
-          "/airbrake-ruby/lib/airbrake-ruby/notifier.rb:124:in `send_notice'",
-          "/airbrake-ruby/lib/airbrake-ruby/notifier.rb:52:in `notify_sync'"
+          "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
-        parsed_backtrace = [
-          { file: '/airbrake-ruby/lib/airbrake-ruby/notifier.rb', line: 84, function: 'build_notice' },
-          { file: '/airbrake-ruby/lib/airbrake-ruby/notifier.rb', line: 124, function: 'send_notice' },
-          { file: '/airbrake-ruby/lib/airbrake-ruby/notifier.rb', line: 52, function: 'notify_sync' }
-        ]
+        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
-
-        allow(Kernel).to receive(:caller).and_return(backtrace)
-
-        notice = @airbrake.build_notice('bingo')
-        expect(notice[:errors][0][:backtrace]).to eq(parsed_backtrace)
       end
     end
-  end
-
-  describe "#close" do
-    context "when using #notify on a closed notifier" do
-      it "raises error" do
-        notifier = described_class.new(airbrake_params)
-        notifier.close
 
-        expect { notifier.notify(AirbrakeTestError.new) }.
-          to raise_error(Airbrake::Error, /closed Airbrake instance/)
+    context "when async sender is closed" do
+      before do
+        expect_any_instance_of(Airbrake::AsyncSender)
+          .to receive(:closed?).and_return(true)
       end
-    end
 
-    context "at program exit when it was closed manually" do
-      it "doesn't raise error", skip: RUBY_ENGINE == 'jruby' do
-        expect do
-          Process.wait(fork { described_class.new(airbrake_params) })
-        end.not_to raise_error
+      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 "#create_deploy" do
-    let(:deploy_endpoint) do
-      "https://airbrake.io/api/v4/projects/#{project_id}/deploys?key=#{project_key}"
-    end
-
-    before do
-      stub_request(:post, deploy_endpoint).to_return(status: 201, body: '{"id":"123"}')
+  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
 
-    it "sends a request to the deploy API" do
-      @airbrake.create_deploy({})
-      expect(a_request(:post, deploy_endpoint)).to have_been_made.once
+  describe "#create_deploy" do
+    it "returns a promise" do
+      stub_request(:post, "https://airbrake.io/api/v4/projects/1/deploys?key=abc")
+        .to_return(status: 201, body: '')
+      expect(subject.create_deploy({})).to be_an(Airbrake::Promise)
     end
 
-    context "when a host contains paths" do
-      let(:deploy_host) { "https://example.net/errbit/" }
-
-      let(:deploy_endpoint) do
-        "#{deploy_host}api/v4/projects/#{project_id}/deploys?key=#{project_key}"
+    context "when environment is configured" do
+      it "prefers the passed environment to the config env" do
+        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
+          { environment: 'barenv' },
+          instance_of(Airbrake::Promise),
+          URI('https://airbrake.io/api/v4/projects/1/deploys?key=abc')
+        )
+        described_class.new(
+          user_params.merge(environment: 'fooenv')
+        ).create_deploy(environment: 'barenv')
       end
+    end
 
-      it "sends a request to the deploy API" do
-        airbrake = described_class.new(airbrake_params.merge(host: deploy_host))
-        airbrake.create_deploy({})
-        expect(a_request(:post, deploy_endpoint)).to have_been_made.once
+    context "when environment is not configured" do
+      it "sets the environment from the config" do
+        expect_any_instance_of(Airbrake::SyncSender).to receive(:send).with(
+          { environment: 'fooenv' },
+          instance_of(Airbrake::Promise),
+          URI('https://airbrake.io/api/v4/projects/1/deploys?key=abc')
+        )
+        subject.create_deploy(environment: 'fooenv')
       end
     end
   end
 
   describe "#configured?" do
-    subject { described_class.new(airbrake_params) }
     it { is_expected.to be_configured }
   end
 
   describe "#merge_context" do
     it "merges the provided context with the notice object" do
-      @airbrake.merge_context(apples: 'oranges')
-      @airbrake.notify_sync('oops')
-      expect(
-        a_request(:post, endpoint).
-        with(body: /"params":{"airbrake_context":{"apples":"oranges"}/)
-      ).to have_been_made.once
+      expect_any_instance_of(Hash).to receive(:merge!).with(apples: 'oranges')
+      subject.merge_context(apples: 'oranges')
     end
   end
 end
+# rubocop:enable Layout/DotPosition