bugsnag 6.14.0 → 6.15.0

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

data/spec/report_spec.rb

@@ -1373,27 +1373,30 @@ describe Bugsnag::Report do
     notify_test_exception
     expect(Bugsnag).to have_sent_notification{ |payload, headers|
       exception = get_exception_from_payload(payload)
+
       bugsnag_count = 0
+
       exception["stacktrace"].each do |frame|
         if /.*lib\/bugsnag.*\.rb/.match(frame["file"])
           bugsnag_count += 1
           expect(frame["inProject"]).to be_nil
         end
       end
-      # 7 is used here as the called bugsnag frames for a `notify` call should be:
+
+      # 6 is used here as the called bugsnag frames for a `notify` call should be:
       # - Bugsnag.notify
       # - Report.new
       # - Report.initialize
       # - Report.generate_exceptions_list
       # - Report.generate_exceptions_list | raw_exceptions.map
       # - Report.generate_exceptions_list | raw_exceptions.map | block
-      # - Report.generate_exceptions_list | raw_exceptions.map | block | Stacktrace.new
-      # However, JRUBY does not include the two `new` frames, resulting in 5 bugsnag frames
+      # However, JRUBY does not include the `Report.new` frame, resulting in 5 bugsnag frames
       if defined?(JRUBY_VERSION)
         frame_count = 5
       else
-        frame_count = 7
+        frame_count = 6
       end
+
       expect(bugsnag_count).to equal frame_count
     }
   end

data/spec/spec_helper.rb

@@ -30,6 +30,14 @@ def get_exception_from_payload(payload)
   event["exceptions"].last
 end
 
+def get_code_from_payload(payload, index = 0)
+  exception = get_exception_from_payload(payload)
+
+  expect(exception["stacktrace"].size).to be > index
+
+  exception["stacktrace"][index]["code"]
+end
+
 def notify_test_exception(*args)
   Bugsnag.notify(RuntimeError.new("test message"), *args)
 end