bugsnag 6.7.3 → 6.8.0

data/lib/bugsnag/helpers.rb

@@ -6,8 +6,9 @@ require 'json'
 module Bugsnag
   module Helpers
     MAX_STRING_LENGTH = 3072
-    MAX_PAYLOAD_LENGTH = 256000
-    MAX_ARRAY_LENGTH = 40
+    MAX_PAYLOAD_LENGTH = 512000
+    MAX_ARRAY_LENGTH = 80
+    MAX_TRIM_STACK_FRAMES = 30
     RAW_DATA_TYPES = [Numeric, TrueClass, FalseClass]
 
     ##
@@ -15,13 +16,25 @@ module Bugsnag
     # accepted by Bugsnag
     def self.trim_if_needed(value)
       value = "" if value.nil?
+
+      # Sanitize object
       sanitized_value = Bugsnag::Cleaner.clean_object_encoding(value)
       return sanitized_value unless payload_too_long?(sanitized_value)
-      reduced_value = trim_strings_in_value(sanitized_value)
+
+      # Trim metadata
+      reduced_value = trim_metadata(sanitized_value)
       return reduced_value unless payload_too_long?(reduced_value)
-      reduced_value = truncate_arrays_in_value(reduced_value)
+
+      # Trim code from stacktrace
+      reduced_value = trim_stacktrace_code(reduced_value)
       return reduced_value unless payload_too_long?(reduced_value)
-      remove_metadata_from_events(reduced_value)
+
+      # Remove metadata
+      reduced_value = remove_metadata_from_events(reduced_value)
+      return reduced_value unless payload_too_long?(reduced_value)
+
+      # Remove oldest functions in stacktrace
+      trim_stacktrace_functions(reduced_value)
     end
 
     ##
@@ -60,6 +73,48 @@ module Bugsnag
 
     TRUNCATION_INFO = '[TRUNCATED]'
 
+    ##
+    # Remove all code from stacktraces
+    def self.trim_stacktrace_code(payload)
+      extract_exception(payload) do |exception|
+        exception[:stacktrace].each do |frame|
+          frame.delete(:code)
+        end
+      end
+      payload
+    end
+
+    ##
+    # Truncate stacktraces
+    def self.trim_stacktrace_functions(payload)
+      extract_exception(payload) do |exception|
+        stack = exception[:stacktrace]
+        exception[:stacktrace] = stack.take(MAX_TRIM_STACK_FRAMES)
+      end
+      payload
+    end
+
+    ##
+    # Wrapper for trimming stacktraces
+    def self.extract_exception(payload)
+      valid_payload = payload.is_a?(Hash) && payload[:events].respond_to?(:map)
+      return unless valid_payload && block_given?
+      payload[:events].each do |event|
+        event[:exceptions].each { |exception| yield exception }
+      end
+    end
+
+    ##
+    # Take the metadata from the events and trim it down
+    def self.trim_metadata(payload)
+      return payload unless payload.is_a?(Hash) and payload[:events].respond_to?(:map)
+      payload[:events].map do |event|
+        event[:metaData] = truncate_arrays_in_value(event[:metaData])
+        event[:metaData] = trim_strings_in_value(event[:metaData])
+      end
+      payload
+    end
+
     ##
     # Check if a value is a raw type which should not be trimmed, truncated
     # or converted to a string
@@ -67,6 +122,7 @@ module Bugsnag
       RAW_DATA_TYPES.detect {|klass| value.is_a?(klass)} != nil
     end
 
+    ##
     # Shorten array until it fits within the payload size limit when serialized
     def self.truncate_array(array)
       return [] unless array.respond_to?(:slice)
@@ -75,6 +131,7 @@ module Bugsnag
       end
     end
 
+    ##
     # Trim all strings to be less than the maximum allowed string length
     def self.trim_strings_in_value(value)
       return value if is_json_raw_type?(value)
@@ -88,13 +145,18 @@ module Bugsnag
       end
     end
 
+    ##
     # Validate that the serialized JSON string value is below maximum payload
     # length
     def self.payload_too_long?(value)
+      get_payload_length(value) >= MAX_PAYLOAD_LENGTH
+    end
+
+    def self.get_payload_length(value)
       if value.is_a?(String)
-        value.length >= MAX_PAYLOAD_LENGTH
+        value.length
       else
-        ::JSON.dump(value).length >= MAX_PAYLOAD_LENGTH
+        ::JSON.dump(value).length
       end
     end
 

data/lib/bugsnag/integrations/delayed_job.rb

@@ -30,9 +30,9 @@ unless defined? Delayed::Plugins::Bugsnag
               overrides[:job][:queue] = queue
             end
             if job.respond_to?(:attempts)
-              max_attempts = job.respond_to?(:max_attempts) ? job.max_attempts : Delayed::Worker.max_attempts
+              max_attempts = (job.respond_to?(:max_attempts) && job.max_attempts) || Delayed::Worker.max_attempts
               overrides[:job][:attempts] = "#{job.attempts + 1} / #{max_attempts}"
-              # +1 as "attempts" is really previous attempts AFAICT, certainly it starts at 0.
+              # +1 as "attempts" is zero-based and does not include the current failed attempt
             end
             if payload = job.payload_object
               p = {

data/lib/bugsnag/integrations/railtie.rb

@@ -17,23 +17,6 @@ module Bugsnag
       load "bugsnag/tasks/bugsnag.rake"
     end
 
-    # send notifications if a command fails in a 'rails runner' call
-    if self.respond_to? :runner
-      runner do
-        at_exit do
-          if $!
-            Bugsnag.notify($!, true) do |report|
-              report.severity = "error"
-              report.severity_reason = {
-                :type => Bugsnag::Report::UNHANDLED_EXCEPTION_MIDDLEWARE,
-                :attributes => FRAMEWORK_ATTRIBUTES
-              }
-            end
-          end
-        end
-      end
-    end
-
     config.before_initialize do
       # Configure bugsnag rails defaults
       # Skipping API key validation as the key may be set later in an

data/lib/bugsnag/stacktrace.rb

@@ -16,6 +16,7 @@ module Bugsnag
       @configuration = configuration
 
       backtrace = caller if !backtrace || backtrace.empty?
+
       @processed_backtrace = backtrace.map do |trace|
         if trace.match(BACKTRACE_LINE_REGEX)
           file, line_str, method = [$1, $2, $3]

data/spec/bugsnag_spec.rb

@@ -17,6 +17,62 @@ describe Bugsnag do
     end
   end
 
+  describe "add_exit_handler" do
+
+    before do
+      Bugsnag.instance_variable_set(:@exit_handler_added, false)
+    end
+
+    it "automatically adds an exit handler" do
+      expect(Bugsnag).to receive(:register_at_exit)
+      Bugsnag.configure do |conf|
+        conf.api_key = "TEST KEY"
+      end
+    end
+
+    it "calls at_exit when register_at_exit is called" do
+      expect(Bugsnag).to receive(:at_exit)
+      Bugsnag.register_at_exit
+    end
+
+    it "doesn't call at_exit on subsequent calls" do
+      expect(Bugsnag).to receive(:at_exit).once
+      Bugsnag.register_at_exit
+      Bugsnag.register_at_exit
+    end
+
+    context 'with aliased at_exit' do
+      before do
+        module Kernel
+          alias_method :old_at_exit, :at_exit
+          def at_exit
+            begin
+              raise BugsnagTestException.new("Oh no")
+            rescue
+              yield
+            end
+          end
+        end
+      end
+
+      it "sends an exception when at_exit is called" do
+        report_mock = double('report')
+        expect(report_mock).to receive(:severity=).with('error')
+        expect(report_mock).to receive(:severity_reason=).with({
+          :type => Bugsnag::Report::UNHANDLED_EXCEPTION
+        })
+        expect(Bugsnag).to receive(:notify).with(kind_of(BugsnagTestException), true).and_yield(report_mock)
+        Bugsnag.register_at_exit
+      end
+
+      after do
+        module Kernel
+          alias_method :at_exit, :old_at_exit
+        end
+      end
+    end
+  end
+
   describe 'loading integrations' do
     before do
       module Kernel

data/spec/configuration_spec.rb

@@ -221,4 +221,5 @@ describe Bugsnag::Configuration do
   it "should have exit exception classes ignored by default" do
     expect(subject.ignore_classes).to eq(Set.new([SystemExit, Interrupt]))
   end
+
 end

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

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'railties', '4.2.10', require: %w(action_controller rails)
+gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

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

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'railties', '4.2.10', require: %w(action_controller rails)
+gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

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

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'railties', '4.2.10', require: %w(action_controller rails)
+gem 'nokogiri', '1.6.8'
 gem 'bugsnag', path: '../../../..'

data/spec/helper_spec.rb

@@ -72,103 +72,89 @@ describe Bugsnag::Helpers do
 
     context "payload length is greater than allowed" do
 
-      context "value is a String" do
-        it "trims length" do
-          value = Bugsnag::Helpers.trim_if_needed(SecureRandom.hex(500_000/2))
-          expect(value.length).to be <= Bugsnag::Helpers::MAX_STRING_LENGTH
-        end
-      end
-
-      context "value is an Array" do
-        it "trims nested string contents" do
-          value = [[30.times.map {|i| SecureRandom.hex(8192) }]]
-          json = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(value))
-          expect(json.length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        end
-
-        it "trims string contents" do
-          value = 30.times.map {|i| SecureRandom.hex(8192) }
-          json = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(value))
-          expect(json.length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        end
+      it "trims metadata strings" do
+        payload = {
+          :events => [{
+            :metaData => 50000.times.map {|i| "should truncate" }.join(""),
+            :preserved => "Foo"
+          }]
+        }
+        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
+        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        expect(trimmed[:events][0][:metaData].length).to be <= Bugsnag::Helpers::MAX_STRING_LENGTH
+        expect(trimmed[:events][0][:preserved]).to eq("Foo")
       end
 
-      context "value is a Set" do
-        it "trims string contents" do
-          value = Set.new(30.times.map {|i| SecureRandom.hex(8192) })
-          json = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(value))
-          expect(json.length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        end
+      it "truncates metadata arrays" do
+        payload = {
+          :events => [{
+            :metaData => 50000.times.map {|i| "should truncate" },
+            :preserved => "Foo"
+          }]
+        }
+        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
+        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        expect(trimmed[:events][0][:metaData].length).to be <= Bugsnag::Helpers::MAX_ARRAY_LENGTH
+        expect(trimmed[:events][0][:preserved]).to eq("Foo")
       end
 
-      context "value can be converted to a String" do
-        it "converts to a string and trims" do
-          value = Set.new(30_000.times.map {|i| Bugsnag::Helpers })
-          json = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(value))
-          expect(json.length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        end
+      it "trims stacktrace code" do
+        payload = {
+          :events => [{
+            :exceptions => [{
+              :stacktrace => [
+                {
+                  :lineNumber => 1,
+                  :file => '/trace1',
+                  :code => 50.times.map {|i| SecureRandom.hex(3072) }
+                },
+                {
+                  :lineNumber => 2,
+                  :file => '/trace2',
+                  :code => 50.times.map {|i| SecureRandom.hex(3072) }
+                }
+              ]
+            }]
+          }]
+        }
+        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
+        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trace = trimmed[:events][0][:exceptions][0][:stacktrace]
+        expect(trace.length).to eq(2)
+        expect(trace[0][:lineNumber]).to eq(1)
+        expect(trace[0][:file]).to eq('/trace1')
+        expect(trace[0][:code]).to be_nil
+        expect(trace[1][:lineNumber]).to eq(2)
+        expect(trace[1][:file]).to eq('/trace2')
+        expect(trace[1][:code]).to be_nil
       end
 
-      context "value is a Hash" do
-
-        before(:each) do
-          @metadata = {
-            :short_string => "this should not be truncated",
-            :long_string => 10000.times.map {|i| "should truncate" }.join(""),
-            :long_string_ary => 30.times.map {|i| SecureRandom.hex(8192) }
-          }
-
-          @trimmed_metadata = Bugsnag::Helpers.trim_if_needed @metadata
-        end
-
-        it "does not trim short values" do
-          expect(@trimmed_metadata[:short_string]).to eq @metadata[:short_string]
-        end
-
-        it "trims long string values" do
-          expect(@trimmed_metadata[:long_string].length).to eq(Bugsnag::Helpers::MAX_STRING_LENGTH)
-          expect(@trimmed_metadata[:long_string].match(/\[TRUNCATED\]$/)).to_not be_nil
-        end
-
-        it "trims nested long string values" do
-          @trimmed_metadata[:long_string_ary].each do |str|
-            expect(str.match(/\[TRUNCATED\]$/)).to_not be_nil
-            expect(str.length).to eq(Bugsnag::Helpers::MAX_STRING_LENGTH)
-          end
-        end
-
-        it "does not change the argument value" do
-          expect(@metadata[:long_string].length).to be > Bugsnag::Helpers::MAX_STRING_LENGTH
-          expect(@metadata[:long_string].match(/\[TRUNCATED\]$/)).to be_nil
-          expect(@metadata[:short_string].length).to eq(28)
-          expect(@metadata[:short_string]).to eq("this should not be truncated")
-          expect(@trimmed_metadata[:long_string_ary].length).to eq(30)
-        end
-      end
-
-      context "and trimmed strings are not enough" do
-        it "truncates long arrays" do
-          value = [100.times.map {|i| SecureRandom.hex(8192) }, "a"]
-          trimmed_value = Bugsnag::Helpers.trim_if_needed(value)
-          expect(trimmed_value.length).to eq 2
-          expect(trimmed_value.first.length).to eq Bugsnag::Helpers::MAX_ARRAY_LENGTH
-          trimmed_value.first.each do |str|
-            expect(str.match(/\[TRUNCATED\]$/)).to_not be_nil
-            expect(str.length).to eq(Bugsnag::Helpers::MAX_STRING_LENGTH)
-          end
-
-          expect(::JSON.dump(trimmed_value).length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-        end
-
-        it "removes metadata from events" do
-          metadata = Hash[*20000.times.map {|i| [i,i+1]}.flatten]
-          frames = 100.times.map {|i| SecureRandom.hex(4096) }
-          value = {key:"abc", events:[{metaData: metadata, frames: frames, cake: "carrot"}]}
-          trimmed_value = Bugsnag::Helpers.trim_if_needed(value)
-          expect(::JSON.dump(trimmed_value).length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
-          expect(trimmed_value[:key]).to eq value[:key]
-          expect(trimmed_value[:events].first.keys.to_set).to eq [:frames, :cake].to_set
-          expect(trimmed_value[:events].first[:metaData]).to be_nil
+      it "trims stacktrace entries" do
+        payload = {
+          :events => [{
+            :exceptions => [{
+              :stacktrace => 18000.times.map do |index|
+                {
+                  :lineNumber => index,
+                  :file => "/path/to/item_#{index}.rb",
+                  :code => { "#{index}" => "puts 'code'" }
+                }
+              end
+            }]
+          }]
+        }
+        expect(::JSON.dump(payload).length).to be > Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trimmed = Bugsnag::Helpers.trim_if_needed(payload)
+        expect(::JSON.dump(trimmed).length).to be <= Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
+        trace = trimmed[:events][0][:exceptions][0][:stacktrace]
+        expect(trace.length).to eq(30)
+        30.times.map do |index|
+          expect(trace[index][:lineNumber]).to eq(index)
+          expect(trace[index][:file]).to eq("/path/to/item_#{index}.rb")
+          expect(trace[index][:code]).to be_nil
         end
       end
     end

data/spec/report_spec.rb

@@ -367,8 +367,8 @@ describe Bugsnag::Report do
     Bugsnag.notify(BugsnagTestException.new("It crashed")) do |report|
       report.meta_data.merge!({
         some_tab: {
-          giant: SecureRandom.hex(500_000/2),
-          mega: SecureRandom.hex(500_000/2)
+          giant: SecureRandom.hex(1_000_000/2),
+          mega: SecureRandom.hex(1_000_000/2)
         }
       })
     end
@@ -381,7 +381,7 @@ describe Bugsnag::Report do
   end
 
   it "truncates large messages before sending" do
-    Bugsnag.notify(BugsnagTestException.new(SecureRandom.hex(500_000))) do |report|
+    Bugsnag.notify(BugsnagTestException.new(SecureRandom.hex(250_000))) do |report|
       report.meta_data.merge!({
         some_tab: {
           giant: SecureRandom.hex(500_000/2),
@@ -391,23 +391,21 @@ describe Bugsnag::Report do
     end
 
     expect(Bugsnag).to have_sent_notification{ |payload, headers|
-      # Truncated body should be no bigger than
-      # 2 truncated hashes (4096*2) + rest of payload (20000)
-      expect(::JSON.dump(payload).length).to be < 4096*2 + 20000
+      expect(::JSON.dump(payload).length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
     }
   end
 
   it "truncate large stacktraces before sending" do
     ex = BugsnagTestException.new("It crashed")
     stacktrace = []
-    5000.times {|i| stacktrace.push("/Some/path/rspec/example.rb:113:in `instance_eval'")}
+    20000.times {|i| stacktrace.push("/Some/path/rspec/example.rb:113:in `instance_eval'")}
     ex.set_backtrace(stacktrace)
     Bugsnag.notify(ex)
 
     expect(Bugsnag).to have_sent_notification{ |payload, headers|
       # Truncated body should be no bigger than
       # 400 stacktrace lines * approx 60 chars per line + rest of payload (20000)
-      expect(::JSON.dump(payload).length).to be < 400*60 + 20000
+      expect(::JSON.dump(payload).length).to be < Bugsnag::Helpers::MAX_PAYLOAD_LENGTH
     }
   end
 
@@ -1054,10 +1052,10 @@ describe Bugsnag::Report do
       expect(exception["message"]).to eq("'nil' was notified as an exception")
 
       stacktrace = exception["stacktrace"][0]
-      expect(stacktrace["lineNumber"]).to eq(1049)
+      expect(stacktrace["lineNumber"]).to eq(1047)
       expect(stacktrace["file"]).to end_with("spec/report_spec.rb")
-      expect(stacktrace["code"]["1048"]).to eq("  it 'uses an appropriate message if nil is notified' do")
-      expect(stacktrace["code"]["1049"]).to eq("    Bugsnag.notify(nil)")
+      expect(stacktrace["code"]["1046"]).to eq("  it 'uses an appropriate message if nil is notified' do")
+      expect(stacktrace["code"]["1047"]).to eq("    Bugsnag.notify(nil)")
     }
   end