airbrake-ruby 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3ab998a044375a07a36e730b7f1876fbb98c1dd
-  data.tar.gz: 0efc3b61148d9907a3a1e054a7193a1080348b78
+  metadata.gz: b51cb8b53a17fbe261374e06275f714d72dfe4c3
+  data.tar.gz: f3b407f5473a75890e56dde82fce32a2e13753c9
 SHA512:
-  metadata.gz: cae2f77310888cb6f70a1839842f23d3488c3c81baf75f53a5455e32dab313827b589ba70fd40f090803a1ac8cee677090721ebdfed8c46f78dcb3259bb92630
-  data.tar.gz: 9835f816359aeeab2bca4e234fa9c2156e1a37ddcbd6fd1eade10fc10f4f414ec2faf3f5b595abb445ca4f7e9c98f69b3dc9e76759a9f64d19a23998ee136bba
+  metadata.gz: 9778f6f6fcd5d027d78bd5b330c490648efe0af2fc9649dc4274d46e91c7eedd8e5fe31698a195f5246cd6113fdabcc4be986f4d1c150ae013a4fdc726d48c97
+  data.tar.gz: aedd2549376dc458b30511d2160b024f53f77b0836c5df66cd0f73330e5b49d5cbd2dc1f1e4ccc49c89618b392104a432eaf80c1fda6dc799dc2741df216cb9c

data/lib/airbrake-ruby.rb

@@ -10,6 +10,7 @@ require 'airbrake-ruby/config'
 require 'airbrake-ruby/sync_sender'
 require 'airbrake-ruby/async_sender'
 require 'airbrake-ruby/response'
+require 'airbrake-ruby/nested_exception'
 require 'airbrake-ruby/notice'
 require 'airbrake-ruby/backtrace'
 require 'airbrake-ruby/filter_chain'
@@ -279,6 +280,10 @@ module Airbrake
       if @notifiers.key?(notifier)
         @notifiers[notifier].__send__(method, *args, &block)
       else
+        # If we raise SystemExit, the Ruby process can gracefully quit without
+        # the unwanted Airbrake::Error.
+        raise args.first if args.first.class == SystemExit
+
         raise Airbrake::Error,
               "the '#{notifier}' notifier isn't configured"
       end
@@ -288,7 +293,5 @@ end
 
 # Notify of unhandled exceptions, if there were any, but ignore SystemExit.
 at_exit do
-  if $ERROR_INFO && $ERROR_INFO.class != SystemExit
-    Airbrake.notify_sync($ERROR_INFO)
-  end
+  Airbrake.notify_sync($ERROR_INFO) if $ERROR_INFO
 end

data/lib/airbrake-ruby/async_sender.rb

@@ -14,9 +14,7 @@ module Airbrake
       @sender = SyncSender.new(config)
       @closed = false
       @workers = ThreadGroup.new
-
-      (0...config.workers).each { @workers.add(spawn_worker) }
-      @workers.enclose
+      @pid = nil
     end
 
     ##
@@ -67,18 +65,33 @@ module Airbrake
     # went wrong.
     #
     # Workers are expected to crash when you +fork+ the process the workers are
-    # living in. Another possible scenario is when you close the instance on
-    # +at_exit+, but some other +at_exit+ hook prevents the process from
-    # exiting.
+    # living in. In this case we detect a +fork+ and try to revive them here.
+    #
+    # Another possible scenario that crashes workers is when you close the
+    # instance on +at_exit+, but some other +at_exit+ hook prevents the process
+    # from exiting.
     #
     # @return [Boolean] true if an instance wasn't closed, but has no workers
     # @see https://goo.gl/oydz8h Example of at_exit that prevents exit
     def has_workers?
+      return false if @closed
+
+      if @pid != Process.pid && @workers.list.empty?
+        @pid = Process.pid
+        spawn_workers
+      end
+
       !@closed && @workers.list.any?
     end
 
     private
 
+    def spawn_workers
+      @workers = ThreadGroup.new
+      @config.workers.times { @workers.add(spawn_worker) }
+      @workers.enclose
+    end
+
     def spawn_worker
       Thread.new do
         while (notice = @unsent.pop) != :stop

data/lib/airbrake-ruby/backtrace.rb

@@ -19,7 +19,7 @@ module Airbrake
       :
       (?<line>\d+)      # Matches '43'
       :in\s
-      `(?<function>.+)' # Matches "`block (3 levels) in <top (required)>'"
+      `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
     \z}x
 
     ##
@@ -38,10 +38,10 @@ module Airbrake
     # @return [Regexp] the template that tries to assume what a generic stack
     #   frame might look like, when exception's backtrace is set manually.
     GENERIC_STACKFRAME_REGEXP = %r{\A
-      (?<file>.+)   # Matches '/foo/bar/baz.ext'
+      (?<file>.+)              # Matches '/foo/bar/baz.ext'
       :
-      (?<line>\d+)  # Matches '43'
-      (?<function>) # No-op
+      (?<line>\d+)?            # Matches '43' or nothing
+      (in\s`(?<function>.+)')? # Matches "in `func'" or nothing
     \z}x
 
     ##
@@ -51,13 +51,15 @@ module Airbrake
     #   parse
     # @return [Array<Hash{Symbol=>String,Integer}>] the parsed backtrace
     def self.parse(exception)
+      return [] if exception.backtrace.nil? || exception.backtrace.none?
+
       regexp = if java_exception?(exception)
                  JAVA_STACKFRAME_REGEXP
                else
                  RUBY_STACKFRAME_REGEXP
                end
 
-      (exception.backtrace || []).map do |stackframe|
+      exception.backtrace.map do |stackframe|
         stack_frame(match_frame(regexp, stackframe))
       end
     end
@@ -80,16 +82,16 @@ module Airbrake
           line: (Integer(match[:line]) if match[:line]),
           function: match[:function] }
       end
-    end
 
-    def self.match_frame(regexp, stackframe)
-      match = regexp.match(stackframe)
-      return match if match
+      def match_frame(regexp, stackframe)
+        match = regexp.match(stackframe)
+        return match if match
 
-      match = GENERIC_STACKFRAME_REGEXP.match(stackframe)
-      return match if match
+        match = GENERIC_STACKFRAME_REGEXP.match(stackframe)
+        return match if match
 
-      raise Airbrake::Error, "can't parse '#{stackframe}'"
+        raise Airbrake::Error, "can't parse '#{stackframe}'"
+      end
     end
   end
 end

data/lib/airbrake-ruby/filters/keys_filter.rb

@@ -47,8 +47,8 @@ module Airbrake
         hash.each_key do |key|
           if should_filter?(key)
             hash[key] = '[Filtered]'.freeze
-          else
-            filter_hash(hash[key]) if hash[key].is_a?(Hash)
+          elsif hash[key].is_a?(Hash)
+            filter_hash(hash[key])
           end
         end
       end

data/lib/airbrake-ruby/nested_exception.rb

@@ -0,0 +1,37 @@
+module Airbrake
+  ##
+  # A class that is capable of unwinding nested exceptions and representing them
+  # as JSON-like hash.
+  class NestedException
+    ##
+    # @return [Integer] the maximum number of nested exceptions that a notice
+    #   can unwrap. Exceptions that have a longer cause chain will be ignored
+    MAX_NESTED_EXCEPTIONS = 3
+
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def as_json
+      unwind_exceptions.map do |exception|
+        { type: exception.class.name,
+          message: exception.message,
+          backtrace: Backtrace.parse(exception) }
+      end
+    end
+
+    private
+
+    def unwind_exceptions
+      exception_list = []
+      exception = @exception
+
+      while exception && exception_list.size < MAX_NESTED_EXCEPTIONS
+        exception_list << exception
+        exception = (exception.cause if exception.respond_to?(:cause))
+      end
+
+      exception_list
+    end
+  end
+end

data/lib/airbrake-ruby/notice.rb

@@ -23,11 +23,6 @@ module Airbrake
     # @return [Integer] the maxium size of the JSON payload in bytes
     MAX_NOTICE_SIZE = 64000
 
-    ##
-    # @return [Integer] the maximum number of nested exceptions that a notice
-    #   can unwrap. Exceptions that have a longer cause chain will be ignored
-    MAX_NESTED_EXCEPTIONS = 3
-
     ##
     # @return [Integer] the maximum size of hashes, arrays and strings in the
     #   notice.
@@ -41,7 +36,7 @@ module Airbrake
       NotImplementedError,
       JSON::GeneratorError,
       Encoding::UndefinedConversionError
-    ]
+    ].freeze
 
     # @return [Array<Symbol>] the list of keys that can be be overwritten with
     #   {Airbrake::Notice#[]=}
@@ -51,7 +46,7 @@ module Airbrake
       :environment,
       :session,
       :params
-    ]
+    ].freeze
 
     def initialize(config, exception, params = {})
       @config = config
@@ -61,7 +56,7 @@ module Airbrake
       }.freeze
 
       @modifiable_payload = {
-        errors: errors(exception),
+        errors: NestedException.new(exception).as_json,
         context: context(params),
         environment: {},
         session: {},
@@ -155,7 +150,7 @@ module Airbrake
     end
 
     def raise_if_ignored
-      return unless self.ignored?
+      return unless ignored?
       raise Airbrake::Error, 'cannot access ignored notice'
     end
 
@@ -174,24 +169,6 @@ module Airbrake
       @modifiable_payload.merge(@private_payload)
     end
 
-    def errors(exception)
-      exception_list = []
-
-      while exception && exception_list.size < MAX_NESTED_EXCEPTIONS
-        exception_list << exception
-
-        exception = if exception.respond_to?(:cause) && exception.cause
-                      exception.cause
-                    end
-      end
-
-      exception_list.map do |e|
-        { type: e.class.name,
-          message: e.message,
-          backtrace: Backtrace.parse(e) }
-      end
-    end
-
     def truncate_payload
       @modifiable_payload[:errors].each do |error|
         @truncator.truncate_error(error)

data/lib/airbrake-ruby/notifier.rb

@@ -127,19 +127,23 @@ module Airbrake
     end
 
     def default_sender
-      if @async_sender.has_workers?
-        @async_sender
-      else
-        @config.logger.warn(
-          "#{LOG_LABEL} falling back to sync delivery because there are no " \
-          "running async workers"
-        )
-        @sync_sender
-      end
+      return @async_sender if @async_sender.has_workers?
+
+      @config.logger.warn(
+        "#{LOG_LABEL} falling back to sync delivery because there are no " \
+        "running async workers"
+      )
+      @sync_sender
     end
 
     def clean_backtrace
-      caller.drop_while { |frame| frame.include?('/lib/airbrake') }
+      caller_copy = Kernel.caller
+      clean_bt = caller_copy.drop_while { |frame| frame.include?('/lib/airbrake') }
+
+      # If true, then it's likely an internal library error. In this case return
+      # at least some backtrace to simplify debugging.
+      return caller_copy if clean_bt.empty?
+      clean_bt
     end
   end
 end

data/lib/airbrake-ruby/sync_sender.rb

@@ -18,7 +18,7 @@ module Airbrake
       Errno::ECONNREFUSED,
       EOFError,
       OpenSSL::SSL::SSLError
-    ]
+    ].freeze
 
     ##
     # @param [Airbrake::Config] config

data/lib/airbrake-ruby/version.rb

@@ -3,5 +3,5 @@
 module Airbrake
   ##
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '1.0.2'.freeze
+  AIRBRAKE_RUBY_VERSION = '1.0.3'.freeze
 end

data/spec/async_sender_spec.rb

@@ -3,52 +3,23 @@ require 'spec_helper'
 RSpec.describe Airbrake::AsyncSender do
   before do
     stub_request(:post, /.*/).to_return(status: 201, body: '{}')
-    @sender = described_class.new(Airbrake::Config.new)
-    @workers = @sender.instance_variable_get(:@workers)
   end
 
-  describe "#new" do
-    context "workers_count parameter" do
-      let(:new_workers) { 5 }
-      let(:config) { Airbrake::Config.new(workers: new_workers) }
-
-      it "spawns alive threads in an enclosed ThreadGroup" do
-        expect(@workers).to be_a(ThreadGroup)
-        expect(@workers.list).to all(be_alive)
-        expect(@workers).to be_enclosed
-      end
-
-      it "controls the number of spawned threads" do
-        expect(@workers.list.size).to eq(1)
-
-        sender = described_class.new(config)
-        workers = sender.instance_variable_get(:@workers)
-
-        expect(workers.list.size).to eq(new_workers)
-        sender.close
-      end
-    end
-
-    context "queue" do
-      before do
-        @stdout = StringIO.new
-      end
-
-      let(:notices) { 1000 }
-
-      let(:config) do
-        Airbrake::Config.new(logger: Logger.new(@stdout), workers: 3, queue_size: 10)
-      end
-
-      it "limits the size of the queue, but still sends all notices" do
-        sender = described_class.new(config)
-
-        notices.times { |i| sender.send(i) }
-        sender.close
+  describe "#send" do
+    it "limits the size of the queue, but still sends all notices" do
+      stdout = StringIO.new
+      notices_count = 1000
+      config = Airbrake::Config.new(
+        logger: Logger.new(stdout), workers: 3, queue_size: 10
+      )
+      sender = described_class.new(config)
+      expect(sender).to have_workers
+
+      notices_count.times { |i| sender.send(i) }
+      sender.close
 
-        log = @stdout.string.split("\n")
-        expect(log.grep(/\*\*Airbrake: \{\}/).size).to eq(notices)
-      end
+      log = stdout.string.split("\n")
+      expect(log.grep(/\*\*Airbrake: \{\}/).size).to eq(notices_count)
     end
   end
 
@@ -57,14 +28,16 @@ RSpec.describe Airbrake::AsyncSender do
       @stderr = StringIO.new
       config = Airbrake::Config.new(logger: Logger.new(@stderr))
       @sender = described_class.new(config)
-      @workers = @sender.instance_variable_get(:@workers).list
+      expect(@sender).to have_workers
     end
 
     context "when there are no unsent notices" do
       it "joins the spawned thread" do
-        expect(@workers).to all(be_alive)
+        workers = @sender.instance_variable_get(:@workers).list
+
+        expect(workers).to all(be_alive)
         @sender.close
-        expect(@workers).to all(be_stop)
+        expect(workers).to all(be_stop)
       end
     end
 
@@ -91,31 +64,75 @@ RSpec.describe Airbrake::AsyncSender do
 
     context "when it was already closed" do
       it "doesn't increase the unsent queue size" do
-        @sender.close
+        begin
+          @sender.close
+        rescue Airbrake::Error
+          nil
+        end
+
         expect(@sender.instance_variable_get(:@unsent).size).to be_zero
+      end
 
+      it "raises error" do
+        @sender.close
+
+        expect(@sender).to be_closed
         expect { @sender.close }.
           to raise_error(Airbrake::Error, 'attempted to close already closed sender')
       end
     end
+
+    context "when workers were not spawned" do
+      it "correctly closes the notifier nevertheless" do
+        sender = described_class.new(Airbrake::Config.new)
+        sender.close
+
+        expect(sender).to be_closed
+      end
+    end
   end
 
   describe "#has_workers?" do
-    it "returns false when the sender is not closed, but has 0 workers" do
-      sender = described_class.new(Airbrake::Config.new)
-      expect(sender.has_workers?).to be_truthy
+    before do
+      @sender = described_class.new(Airbrake::Config.new)
+      expect(@sender).to have_workers
+    end
 
-      sender.instance_variable_get(:@workers).list.each(&:kill)
+    it "returns false when the sender is not closed, but has 0 workers" do
+      @sender.instance_variable_get(:@workers).list.each(&:kill)
       sleep 1
-      expect(sender.has_workers?).to be_falsey
+      expect(@sender).not_to have_workers
     end
 
     it "returns false when the sender is closed" do
+      @sender.close
+      expect(@sender).not_to have_workers
+    end
+  end
+
+  describe "#spawn_workers" do
+    it "spawns alive threads in an enclosed ThreadGroup" do
       sender = described_class.new(Airbrake::Config.new)
-      expect(sender.has_workers?).to be_truthy
+      expect(sender).to have_workers
+
+      workers = sender.instance_variable_get(:@workers)
+
+      expect(workers).to be_a(ThreadGroup)
+      expect(workers.list).to all(be_alive)
+      expect(workers).to be_enclosed
+
+      sender.close
+    end
+
+    it "spawns exactly config.workers workers" do
+      workers_count = 5
+      sender = described_class.new(Airbrake::Config.new(workers: workers_count))
+      expect(sender).to have_workers
+
+      workers = sender.instance_variable_get(:@workers)
 
+      expect(workers.list.size).to eq(workers_count)
       sender.close
-      expect(sender.has_workers?).to be_falsey
     end
   end
 end

data/spec/backtrace_spec.rb

@@ -75,26 +75,46 @@ RSpec.describe Airbrake::Backtrace do
     end
 
     context "generic backtrace" do
-      # rubocop:disable Metrics/LineLength
-      let(:generic_bt) do
-        ["/home/bingo/bango/assets/stylesheets/error_pages.scss:139:in `animation'",
-         "/home/bingo/bango/assets/stylesheets/error_pages.scss:139",
-         "/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb:349:in `block in visit_mixin'"]
+      context "when function is absent" do
+        # rubocop:disable Metrics/LineLength
+        let(:generic_bt) do
+          ["/home/bingo/bango/assets/stylesheets/error_pages.scss:139:in `animation'",
+           "/home/bingo/bango/assets/stylesheets/error_pages.scss:139",
+           "/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb:349:in `block in visit_mixin'"]
+        end
+        # rubocop:enable Metrics/LineLength
+
+        let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(generic_bt) } }
+
+        let(:parsed_backtrace) do
+          # rubocop:disable Metrics/LineLength, Style/HashSyntax, Style/SpaceInsideHashLiteralBraces, Style/SpaceAroundOperators
+          [{:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>"animation"},
+           {:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>nil},
+           {:file=>"/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb", :line=>349, :function=>"block in visit_mixin"}]
+          # rubocop:enable Metrics/LineLength, Style/HashSyntax, Style/SpaceInsideHashLiteralBraces, Style/SpaceAroundOperators
+        end
+
+        it "returns a properly formatted array of hashes" do
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
+        end
       end
-      # rubocop:enable Metrics/LineLength
 
-      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(generic_bt) } }
+      context "when line is absent" do
+        let(:generic_bt) do
+          ["/Users/grammakov/repositories/weintervene/config.ru:in `new'"]
+        end
 
-      let(:parsed_backtrace) do
-        # rubocop:disable Metrics/LineLength, Style/HashSyntax, Style/SpaceInsideHashLiteralBraces, Style/SpaceAroundOperators
-        [{:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>"animation"},
-         {:file=>"/home/bingo/bango/assets/stylesheets/error_pages.scss", :line=>139, :function=>""},
-         {:file=>"/home/bingo/.gem/ruby/2.2.2/gems/sass-3.4.20/lib/sass/tree/visitors/perform.rb", :line=>349, :function=>"block in visit_mixin"}]
-        # rubocop:enable Metrics/LineLength, Style/HashSyntax, Style/SpaceInsideHashLiteralBraces, Style/SpaceAroundOperators
-      end
+        let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(generic_bt) } }
 
-      it "returns a properly formatted array of hashes" do
-        expect(described_class.parse(ex)).to eq(parsed_backtrace)
+        let(:parsed_backtrace) do
+          [{ file: '/Users/grammakov/repositories/weintervene/config.ru',
+             line: nil,
+             function: 'new' }]
+        end
+
+        it "returns a properly formatted array of hashes" do
+          expect(described_class.parse(ex)).to eq(parsed_backtrace)
+        end
       end
     end
 
@@ -108,5 +128,23 @@ RSpec.describe Airbrake::Backtrace do
           to raise_error(Airbrake::Error, /can't parse/)
       end
     end
+
+    context "given a backtrace with an empty function" do
+      let(:bt) do
+        ["/airbrake-ruby/vendor/jruby/1.9/gems/rspec-core-3.4.1/exe/rspec:3:in `'"]
+      end
+
+      let(:ex) { AirbrakeTestError.new.tap { |e| e.set_backtrace(bt) } }
+
+      let(:parsed_backtrace) do
+        [{ file: '/airbrake-ruby/vendor/jruby/1.9/gems/rspec-core-3.4.1/exe/rspec',
+           line: 3,
+           function: '' }]
+      end
+
+      it "returns a properly formatted array of hashes" do
+        expect(described_class.parse(ex)).to eq(parsed_backtrace)
+      end
+    end
   end
 end

data/spec/nested_exception_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake::NestedException do
+  let(:config) { Airbrake::Config.new }
+
+  describe "#as_json" do
+    context "given exceptions with backtraces" do
+      it "unwinds nested exceptions" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError
+            Ruby21Error.raise_error('bingo')
+          end
+        rescue Ruby21Error => ex
+          nested_exception = described_class.new(ex)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(2)
+          expect(exceptions[0][:message]).to eq('bingo')
+          expect(exceptions[1][:message]).to eq('App crashed!')
+          expect(exceptions[0][:backtrace]).not_to be_empty
+          expect(exceptions[1][:backtrace]).not_to be_empty
+        end
+      end
+
+      it "unwinds no more than 3 nested exceptions" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError
+            begin
+              Ruby21Error.raise_error('bongo')
+            rescue Ruby21Error
+              begin
+                Ruby21Error.raise_error('bango')
+              rescue Ruby21Error
+                Ruby21Error.raise_error('bingo')
+              end
+            end
+          end
+        rescue Ruby21Error => ex
+          nested_exception = described_class.new(ex)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(3)
+          expect(exceptions[0][:message]).to eq('bingo')
+          expect(exceptions[1][:message]).to eq('bango')
+          expect(exceptions[2][:message]).to eq('bongo')
+          expect(exceptions[0][:backtrace]).not_to be_empty
+          expect(exceptions[1][:backtrace]).not_to be_empty
+        end
+      end
+    end
+
+    context "given exceptions without backtraces" do
+      it "sets backtrace to nil" do
+        begin
+          begin
+            raise AirbrakeTestError
+          rescue AirbrakeTestError => ex2
+            ex2.set_backtrace([])
+            Ruby21Error.raise_error('bingo')
+          end
+        rescue Ruby21Error => ex1
+          ex1.set_backtrace([])
+          nested_exception = described_class.new(ex1)
+          exceptions = nested_exception.as_json
+
+          expect(exceptions.size).to eq(2)
+          expect(exceptions[0][:backtrace]).to be_empty
+          expect(exceptions[1][:backtrace]).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/notice_spec.rb

@@ -5,51 +5,6 @@ RSpec.describe Airbrake::Notice do
     described_class.new(Airbrake::Config.new, AirbrakeTestError.new, bingo: '1')
   end
 
-  describe "#new" do
-    context "nested exceptions" do
-      it "unwinds nested exceptions" do
-        begin
-          begin
-            raise AirbrakeTestError
-          rescue AirbrakeTestError
-            Ruby21Error.raise_error('bingo')
-          end
-        rescue Ruby21Error => ex
-          notice = described_class.new(Airbrake::Config.new, ex)
-
-          expect(notice[:errors].size).to eq(2)
-          expect(notice[:errors][0][:message]).to eq('bingo')
-          expect(notice[:errors][1][:message]).to eq('App crashed!')
-        end
-      end
-
-      it "unwinds no more than 3 nested exceptions" do
-        begin
-          begin
-            raise AirbrakeTestError
-          rescue AirbrakeTestError
-            begin
-              Ruby21Error.raise_error('bongo')
-            rescue Ruby21Error
-              begin
-                Ruby21Error.raise_error('bango')
-              rescue Ruby21Error
-                Ruby21Error.raise_error('bingo')
-              end
-            end
-          end
-        rescue Ruby21Error => ex
-          notice = described_class.new(Airbrake::Config.new, ex)
-
-          expect(notice[:errors].size).to eq(3)
-          expect(notice[:errors][0][:message]).to eq('bingo')
-          expect(notice[:errors][1][:message]).to eq('bango')
-          expect(notice[:errors][2][:message]).to eq('bongo')
-        end
-      end
-    end
-  end
-
   describe "#to_json" do
     context "app_version" do
       context "when missing" do

data/spec/notifier_spec.rb

@@ -375,18 +375,40 @@ RSpec.describe Airbrake::Notifier do
 
     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)
 
-      airbrake = described_class.new(airbrake_params.merge(logger: Logger.new(out)))
-      airbrake.
-        instance_variable_get(:@async_sender).
-        instance_variable_get(:@workers).
-        list.
-        each(&:kill)
-
+      expect(async_sender).to have_workers
+      async_sender.instance_variable_get(:@workers).list.each(&:kill)
       sleep 1
+      expect(async_sender).not_to have_workers
 
-      expect(airbrake.notify('bingo')).to be_nil
+      notifier.notify('bango')
       expect(out.string).to match(/falling back to sync delivery/)
+
+      notifier.close
+    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
     end
   end
 
@@ -645,28 +667,42 @@ RSpec.describe Airbrake::Notifier do
     it "builds a notice from exception" do
       expect(@airbrake.build_notice(ex)).to be_an Airbrake::Notice
     end
+
+    context "given a non-exception with calculated internal frames only" do
+      it "returns the internal frames nevertheless" 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'"
+        ]
+
+        # 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' }
+        ]
+        # 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
-    shared_examples 'close' do |method|
+    context "when using #notify on a closed notifier" do
       it "raises error" do
-        @airbrake.close
-        expect { method.call(@airbrake) }.
+        notifier = described_class.new(airbrake_params)
+        notifier.close
+
+        expect { notifier.notify(AirbrakeTestError.new) }.
           to raise_error(Airbrake::Error, /closed Airbrake instance/)
       end
     end
 
-    context "when using #notify" do
-      include_examples 'close', proc { |a| a.notify(AirbrakeTestError.new) }
-    end
-
-    context "when using #send_notice" do
-      include_examples 'close', proc { |a|
-        notice = a.build_notice(AirbrakeTestError.new)
-        a.send_notice(notice)
-      }
-    end
-
     context "at program exit when it was closed manually" do
       it "doesn't raise error", skip: RUBY_ENGINE == 'jruby' do
         expect do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airbrake-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Airbrake Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-03 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -104,6 +104,7 @@ files:
 - lib/airbrake-ruby/filters/keys_blacklist.rb
 - lib/airbrake-ruby/filters/keys_filter.rb
 - lib/airbrake-ruby/filters/keys_whitelist.rb
+- lib/airbrake-ruby/nested_exception.rb
 - lib/airbrake-ruby/notice.rb
 - lib/airbrake-ruby/notifier.rb
 - lib/airbrake-ruby/payload_truncator.rb
@@ -115,6 +116,7 @@ files:
 - spec/backtrace_spec.rb
 - spec/config_spec.rb
 - spec/filter_chain_spec.rb
+- spec/nested_exception_spec.rb
 - spec/notice_spec.rb
 - spec/notifier_spec.rb
 - spec/notifier_spec/options_spec.rb
@@ -140,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby notifier for https://airbrake.io
@@ -152,7 +154,7 @@ test_files:
 - spec/payload_truncator_spec.rb
 - spec/airbrake_spec.rb
 - spec/backtrace_spec.rb
+- spec/nested_exception_spec.rb
 - spec/notice_spec.rb
 - spec/config_spec.rb
 - spec/filter_chain_spec.rb
-has_rdoc: