bugsnag 6.12.1 → 6.15.0

data/spec/code_extractor_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Bugsnag::CodeExtractor do
+  it "extracts code from a file and adds it to the given hash" do
+    file1_hash = { lineNumber: 5 }
+    file2_hash = { lineNumber: 7 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({
+      lineNumber: 5,
+      code: {
+        2 => "",
+        3 => "module File1",
+        4 => "  def self.foo1",
+        5 => "    File2.foo2",
+        6 => "  end",
+        7 => "",
+        8 => "  def self.bar1"
+      }
+    })
+
+    expect(file2_hash).to eq({
+      lineNumber: 7,
+      code: {
+        4 => "  end",
+        5 => "",
+        6 => "  def self.bar2",
+        7 => "    File1.baz1",
+        8 => "  end",
+        9 => "",
+        10 => "  def self.baz2"
+      }
+    })
+  end
+
+  it "handles extracting code from the first & last line in a file" do
+    file1_hash = { lineNumber: 1 }
+    file2_hash = { lineNumber: 25 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({
+      lineNumber: 1,
+      code: {
+        1 => "require_relative 'file2'",
+        2 => "",
+        3 => "module File1",
+        4 => "  def self.foo1",
+        5 => "    File2.foo2",
+        6 => "  end",
+        7 => ""
+      }
+    })
+
+    expect(file2_hash).to eq({
+      lineNumber: 25,
+      code: {
+        19 => "    puts 'abcdef2'",
+        20 => "  end",
+        21 => "",
+        22 => "  def self.abcdefghi2",
+        23 => "    puts 'abcdefghi2'",
+        24 => "  end",
+        25 => "end"
+      }
+    })
+  end
+
+  it "truncates lines to a maximum of 200 characters" do
+    hash = { lineNumber: 4 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file_with_long_lines.rb", hash)
+
+    code_extractor.extract!
+
+    # rubocop:disable Layout/LineLength
+    expect(hash).to eq({
+      lineNumber: 4,
+      code: {
+        1 => "# rubocop:disable Layout/LineLength",
+        2 => "def a_super_long_function_name_that_would_be_really_impractical_to_use_but_luckily_this_is_just_for_a_test_to_prove_we_can_handle_really_long_lines_of_code_that_go_over_200_characters_and_some_more_pa",
+        3 => "  puts 'This is a shorter string'",
+        4 => "  puts 'A more realistic example of when a line would be really long is long strings such as this one, which extends over the 200 character limit by containing a lot of excess words for padding its le",
+        5 => "  puts 'and another shorter string for comparison'",
+        6 => "end",
+        7 => "# rubocop:enable Layout/LineLength",
+      }
+    })
+    # rubocop:enable Layout/LineLength
+  end
+
+  it "rescues exceptions raised in extract!" do
+    file1_hash = { lineNumber: 1 }
+    file2_hash = { lineNumber: 25 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    file1_hash[:first_line_number] = nil
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({ lineNumber: 1, code: nil })
+
+    expect(file2_hash).to eq({
+      lineNumber: 25,
+      code: {
+        19 => "    puts 'abcdef2'",
+        20 => "  end",
+        21 => "",
+        22 => "  def self.abcdefghi2",
+        23 => "    puts 'abcdefghi2'",
+        24 => "  end",
+        25 => "end"
+      }
+    })
+  end
+end

data/spec/configuration_spec.rb

@@ -332,10 +332,14 @@ describe Bugsnag::Configuration do
     end
   end
 
-  it "should have exit exception classes ignored by default" do
+  it "should have exit exception classes in ignore_classes by default" do
     expect(subject.ignore_classes).to eq(Set.new([SystemExit, SignalException]))
   end
 
+  it "should have nothing in discard_classes by default" do
+    expect(subject.discard_classes).to eq(Set.new([]))
+  end
+
   describe "#breadcrumbs" do
     it "first returns a new circular buffer" do
       buffer = subject.breadcrumbs
@@ -427,4 +431,15 @@ describe Bugsnag::Configuration do
       expect(second_array).to eq([1, 2])
     end
   end
+
+  describe "#vendor_path" do
+    it "returns the default vendor path" do
+      expect(subject.vendor_path).to eq(Bugsnag::Configuration::DEFAULT_VENDOR_PATH)
+    end
+
+    it "returns the defined vendor path" do
+      subject.vendor_path = /foo/
+      expect(subject.vendor_path).to eq(/foo/)
+    end
+  end
 end

data/spec/fixtures/apps/rails-initializer-config/Gemfile

@@ -1,5 +1,9 @@
 source 'https://rubygems.org'
 
-gem 'railties', '4.2.10', require: %w(action_controller rails)
+ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+
+gem 'railties', ruby_version <= Gem::Version.new('2.6') ? '4.2.10' : '~> 6.0.2', require: %w(action_controller rails)
+gem 'rake', ruby_version <= Gem::Version.new('1.9.3') ? '~> 11.3.0' : '~> 12.3.0'
+gem 'minitest', ruby_version <= Gem::Version.new('2.2') ? '5.11.3' : '~> 5.13.0'
 gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

data/spec/fixtures/apps/rails-invalid-initializer-config/Gemfile

@@ -1,5 +1,9 @@
 source 'https://rubygems.org'
 
-gem 'railties', '4.2.10', require: %w(action_controller rails)
+ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+
+gem 'railties', ruby_version <= Gem::Version.new('2.6') ? '4.2.10' : '~> 6.0.2', require: %w(action_controller rails)
+gem 'rake', ruby_version <= Gem::Version.new('1.9.3') ? '~> 11.3.0' : '~> 12.3.0'
+gem 'minitest', ruby_version <= Gem::Version.new('2.2') ? '5.11.3' : '~> 5.13.0'
 gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

data/spec/fixtures/apps/rails-no-config/Gemfile

@@ -1,5 +1,9 @@
 source 'https://rubygems.org'
 
-gem 'railties', '4.2.10', require: %w(action_controller rails)
+ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+
+gem 'railties', ruby_version <= Gem::Version.new('2.6') ? '4.2.10' : '~> 6.0.2', require: %w(action_controller rails)
+gem 'rake', ruby_version <= Gem::Version.new('1.9.3') ? '~> 11.3.0' : '~> 12.3.0'
+gem 'minitest', ruby_version <= Gem::Version.new('2.2') ? '5.11.3' : '~> 5.13.0'
 gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

data/spec/fixtures/crashes/file1.rb

@@ -0,0 +1,29 @@
+require_relative 'file2'
+
+module File1
+  def self.foo1
+    File2.foo2
+  end
+
+  def self.bar1
+    File2.bar2
+  end
+
+  def self.baz1
+    File2.baz2
+  end
+
+  def self.abc1
+    puts 'abc'
+  end
+
+  def self.abcdef1
+    puts 'abcdef1'
+  end
+
+  def self.abcdefghi1
+    puts 'abcdefghi1'
+  end
+end
+
+File1.foo1

data/spec/fixtures/crashes/file2.rb

@@ -0,0 +1,25 @@
+module File2
+  def self.foo2
+    File1.bar1
+  end
+
+  def self.bar2
+    File1.baz1
+  end
+
+  def self.baz2
+    raise 'uh oh'
+  end
+
+  def self.abc2
+    puts 'abc'
+  end
+
+  def self.abcdef2
+    puts 'abcdef2'
+  end
+
+  def self.abcdefghi2
+    puts 'abcdefghi2'
+  end
+end

data/spec/fixtures/crashes/file_with_long_lines.rb

@@ -0,0 +1,7 @@
+# rubocop:disable Layout/LineLength
+def a_super_long_function_name_that_would_be_really_impractical_to_use_but_luckily_this_is_just_for_a_test_to_prove_we_can_handle_really_long_lines_of_code_that_go_over_200_characters_and_some_more_padding
+  puts 'This is a shorter string'
+  puts 'A more realistic example of when a line would be really long is long strings such as this one, which extends over the 200 character limit by containing a lot of excess words for padding its length so that it is super long'
+  puts 'and another shorter string for comparison'
+end
+# rubocop:enable Layout/LineLength

data/spec/fixtures/crashes/functions.rb

@@ -0,0 +1,29 @@
+def foo
+  bar
+end
+
+def bar
+  baz
+end
+
+def baz
+  xyz
+end
+
+def xyz
+  raise 'uh oh'
+end
+
+def abc
+  puts 'abc'
+end
+
+def abcdef
+  puts 'abcdef'
+end
+
+def abcdefghi
+  puts 'abcdefghi'
+end
+
+foo

data/spec/fixtures/crashes/short_file.rb

@@ -1 +1,3 @@
+#
 raise 'hell'
+#

data/spec/helper_spec.rb

@@ -4,23 +4,7 @@ require 'spec_helper'
 require 'set'
 
 describe Bugsnag::Helpers do
-
   describe "trim_if_needed" do
-
-    it "breaks recursion" do
-      a = [1, 2, 3]
-      b = [2, a]
-      a << b
-      value = Bugsnag::Helpers.trim_if_needed(a)
-      expect(value).to eq([1, 2, 3, [2, "[RECURSION]"]])
-    end
-
-    it "does not break equal objects without recursion" do
-      data = [1, [1, 2], [1, 2], "a"]
-      value = Bugsnag::Helpers.trim_if_needed(data)
-      expect(value).to eq data
-    end
-
     it "preserves bool types" do
       value = Bugsnag::Helpers.trim_if_needed([1, 3, true, "NO", "2", false])
       expect(value[2]).to be_a(TrueClass)
@@ -39,21 +23,7 @@ describe Bugsnag::Helpers do
       expect(value[4]).to be_a(String)
     end
 
-    context "an object will throw if `to_s` is called" do
-      class StringRaiser
-        def to_s
-          raise 'Oh no you do not!'
-        end
-      end
-
-      it "uses the string '[RAISED]' instead" do
-        value = Bugsnag::Helpers.trim_if_needed([1, 3, StringRaiser.new])
-        expect(value[2]).to eq "[RAISED]"
-      end
-    end
-
     context "payload length is less than allowed" do
-
       it "does not change strings" do
         value = SecureRandom.hex(4096)
         expect(Bugsnag::Helpers.trim_if_needed(value)).to eq value
@@ -71,7 +41,6 @@ describe Bugsnag::Helpers do
     end
 
     context "payload length is greater than allowed" do
-
       it "trims metadata strings" do
         payload = {
           :events => [{

data/spec/integrations/logger_spec.rb

@@ -61,7 +61,7 @@ describe 'Configuration.logger' do
       end
     end
 
-    context 'sets an invalid API key using the BUGSNAG_API_KEY env var' do
+    context 'when the API key is invalid in the bugsnag initializer' do
       it 'logs a warning' do
         skip "Incompatible with Ruby <2.0 and JRuby" if incompatible
         output = run_app('rails-invalid-initializer-config')

data/spec/integrations/rack_spec.rb

@@ -127,9 +127,10 @@ describe Bugsnag::Rack do
       expect(report).to receive(:context=).with("TEST /TEST_PATH")
       expect(report).to receive(:user).and_return({})
 
-      config = double
-      allow(config).to receive(:send_environment).and_return(true)
-      allow(config).to receive(:meta_data_filters).and_return(['email'])
+      config = Bugsnag.configuration
+      config.send_environment = true
+      config.meta_data_filters = ['email']
+
       allow(report).to receive(:configuration).and_return(config)
       expect(report).to receive(:add_tab).once.with(:request, {
         :url => "http://test_host/TEST_PATH?email=[FILTERED]&another_param=thing",
@@ -187,9 +188,10 @@ describe Bugsnag::Rack do
       expect(report).to receive(:context=).with("TEST /TEST_PATH")
       expect(report).to receive(:user).and_return({})
 
-      config = double
-      allow(config).to receive(:send_environment).and_return(true)
-      allow(config).to receive(:meta_data_filters).and_return(nil)
+      config = Bugsnag.configuration
+      config.send_environment = true
+      config.meta_data_filters = []
+
       allow(report).to receive(:configuration).and_return(config)
       expect(report).to receive(:add_tab).once.with(:environment, rack_env)
       expect(report).to receive(:add_tab).once.with(:request, {

data/spec/integrations/rake_spec.rb

@@ -58,7 +58,7 @@ describe "Bugsnag Rake integration" do
       ENV['BUGSNAG_TEST_SERVER_PORT'] = server.config[:Port].to_s
       task_fixtures_path = File.join(File.dirname(__FILE__), '../fixtures', 'tasks')
       Dir.chdir(task_fixtures_path) do
-        system("bundle exec rake test:crash > /dev/null 2>&1")
+        system("../../../bin/rake test:crash")
       end
 
       result = request()

data/spec/on_error_spec.rb

@@ -0,0 +1,332 @@
+require "spec_helper"
+
+describe "on_error callbacks" do
+  it "runs callbacks on notify" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+    end)
+  end
+
+  it "can add callbacks in a configure block" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.configure do |config|
+      config.add_on_error(callback1)
+      config.add_on_error(callback2)
+    end
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+    end)
+  end
+
+  it "can remove an already registered callback" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+
+    Bugsnag.remove_on_error(callback1)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to be_nil
+      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+    end)
+  end
+
+  it "can remove all registered callbacks" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+
+    Bugsnag.remove_on_error(callback2)
+    Bugsnag.remove_on_error(callback1)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to be_nil
+      expect(event["metaData"]["significant"]).to be_nil
+    end)
+  end
+
+  it "does not remove an identical callback if it is not the same Proc" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback1_duplicate = proc {|report| report.add_tab(:important, { hello: "world" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.remove_on_error(callback1_duplicate)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+    end)
+  end
+
+  it "can re-add callbacks that have previously been removed" do
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+
+    Bugsnag.remove_on_error(callback1)
+
+    Bugsnag.add_on_error(callback1)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+    end)
+  end
+
+  it "will only add a callback once" do
+    called_count = 0
+
+    callback = proc do |report|
+      called_count += 1
+
+      report.add_tab(:important, { called: called_count })
+    end
+
+    1.upto(10) do |i|
+      Bugsnag.add_on_error(callback)
+    end
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(called_count).to be(1)
+      expect(event["metaData"]["important"]).to eq({ "called" => 1 })
+    end)
+  end
+
+  it "will ignore the report and stop calling callbacks if one returns false" do
+    logger = spy('logger')
+    Bugsnag.configuration.logger = logger
+
+    called_count = 0
+
+    callback1 = proc { called_count += 1 }
+    callback2 = proc { called_count += 1 }
+    callback3 = proc { false }
+    callback4 = proc { called_count += 1 }
+    callback5 = proc { called_count += 1 }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+    Bugsnag.add_on_error(callback3)
+    Bugsnag.add_on_error(callback4)
+    Bugsnag.add_on_error(callback5)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).not_to have_sent_notification
+    expect(called_count).to be(2)
+
+    expect(logger).to have_received(:debug).with("[Bugsnag]") do |&block|
+      expect(block.call).to eq("Not notifying RuntimeError due to ignore being signified in user provided middleware")
+    end
+  end
+
+  it "callbacks are called in the same order they are added (FIFO)" do
+    callback1 = proc do |report|
+      expect(report.meta_data[:important]).to be_nil
+
+      report.add_tab(:important, { magic_number: 9 })
+    end
+
+    callback2 = proc do |report|
+      expect(report.meta_data[:important]).to eq({ magic_number: 9 })
+
+      report.add_tab(:important, { magic_number: 99 })
+    end
+
+    callback3 = proc do |report|
+      expect(report.meta_data[:important]).to eq({ magic_number: 99 })
+
+      report.add_tab(:important, { magic_number: 999 })
+    end
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+    Bugsnag.add_on_error(callback3)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "magic_number" => 999 })
+    end)
+  end
+
+  it "callbacks continue being called after a callback raises" do
+    logger = spy('logger')
+    Bugsnag.configuration.logger = logger
+
+    callback1 = proc {|report| report.add_tab(:important, { a: "b" }) }
+    callback2 = proc {|_report| raise "bad things" }
+    callback3 = proc {|report| report.add_tab(:important, { c: "d" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+    Bugsnag.add_on_error(callback3)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "a" => "b", "c" => "d" })
+    end)
+
+    message_index = 0
+    expected_messages = [
+      /^Error occurred in on_error callback: 'bad things'$/,
+      /^on_error callback stacktrace:/
+    ]
+
+    expect(logger).to have_received(:warn).with("[Bugsnag]").twice do |&block|
+      expect(block.call).to match(expected_messages[message_index])
+      message_index += 1
+    end
+  end
+
+  it "runs callbacks even if no other middleware is registered" do
+    # Reset the middleware stack so any default middleware are removed
+    Bugsnag.configuration.middleware = Bugsnag::MiddlewareStack.new
+
+    callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+    callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+    Bugsnag.add_on_error(callback1)
+    Bugsnag.add_on_error(callback2)
+
+    Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+    expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+      event = get_event_from_payload(payload)
+
+      expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+      expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+    end)
+  end
+
+  describe "using callbacks across threads" do
+    it "runs callbacks that are added in different threads" do
+      callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+      callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+      callback3 = proc {|report| report.add_tab(:crucial, { magic_number: 999 }) }
+
+      Bugsnag.add_on_error(callback1)
+
+      threads = [
+        Thread.new { Bugsnag.add_on_error(callback2) },
+        Thread.new { Bugsnag.add_on_error(callback3) }
+      ]
+
+      threads.each(&:join)
+
+      Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+        event = get_event_from_payload(payload)
+
+        expect(event["metaData"]["important"]).to eq({ "hello" => "world" })
+        expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+        expect(event["metaData"]["crucial"]).to eq({ "magic_number" => 999 })
+      end)
+    end
+
+    it "can remove callbacks that are added in different threads" do
+      callback1 = proc {|report| report.add_tab(:important, { hello: "world" }) }
+      callback2 = proc {|report| report.add_tab(:significant, { hey: "earth" }) }
+
+      # We need to create & join these one at a time so that callback1 has
+      # definitely been added before it is removed, otherwise this test will fail
+      # at random
+      Thread.new { Bugsnag.add_on_error(callback1) }.join
+      Thread.new { Bugsnag.remove_on_error(callback1) }.join
+      Thread.new { Bugsnag.add_on_error(callback2) }.join
+
+      Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+        event = get_event_from_payload(payload)
+
+        expect(event["metaData"]["important"]).to be_nil
+        expect(event["metaData"]["significant"]).to eq({ "hey" => "earth" })
+      end)
+    end
+
+    it "callbacks are called in FIFO order when added in separate threads" do
+      callback1 = proc do |report|
+        expect(report.meta_data[:important]).to be_nil
+
+        report.add_tab(:important, { magic_number: 9 })
+      end
+
+      callback2 = proc do |report|
+        expect(report.meta_data[:important]).to eq({ magic_number: 9 })
+
+        report.add_tab(:important, { magic_number: 99 })
+      end
+
+      callback3 = proc do |report|
+        expect(report.meta_data[:important]).to eq({ magic_number: 99 })
+
+        report.add_tab(:important, { magic_number: 999 })
+      end
+
+      # As above, we need to create & join these one at a time so that each
+      # callback is added in sequence
+      Thread.new { Bugsnag.add_on_error(callback1) }.join
+      Thread.new { Bugsnag.add_on_error(callback2) }.join
+      Thread.new { Bugsnag.add_on_error(callback3) }.join
+
+      Bugsnag.notify(RuntimeError.new("Oh no!"))
+
+      expect(Bugsnag).to(have_sent_notification do |payload, _headers|
+        event = get_event_from_payload(payload)
+
+        expect(event["metaData"]["important"]).to eq({ "magic_number" => 999 })
+      end)
+    end
+  end
+end