bugsnag 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ebe81525d5bc908bded68c8fe66f2148c827bf2
-  data.tar.gz: 5094f9cbca6d554b8ab8599dd8cf751824f39564
+  metadata.gz: 3feeeeef834abcd2676f54ed08468f35d2e61cec
+  data.tar.gz: fa7ff7ef9f2e1619d3d00142f6e7eb1c241c514e
 SHA512:
-  metadata.gz: 7893ddc4139330cddecddee79e8d25306385a2aa1d9d1e73d4d715af856aa03c9f534614b2747291136910df04fdab64416e15ef476bdec6b8b8b04363fc23e1
-  data.tar.gz: a48b1f8f0745b50ec99322f98d5fb7dd37f3df0b3b3fa46fb2e2894043a6afd484c1710ed346deb8f61461be9de1a293e4f67e83f4260fb3e30245f8799f36c1
+  metadata.gz: 08264576a36649e2850368e7f6d6c2190d9fe44d4489c963c464f7abcb4201a45a72b9d773a1d26eff2c98be41a0b18e953e295f06156ffe6e56de28a2601625
+  data.tar.gz: cd2424431cae73dea1e41f0b570e241834a063be6cf9c4a59964031467c77ed9089ab8ee312de9a11570a55de019e4bd109eae6e544f2355b1b09fa761948ea5

data/CHANGELOG.md

@@ -1,6 +1,27 @@
 Changelog
 =========
 
+## 4.0.1 (5 Apr 2016)
+
+### Fixes
+
+* Fix Sidekiq app type being overwritten by Rails
+  | [Luiz Felipe G. Pereira](https://github.com/Draiken)
+  | [#286](https://github.com/bugsnag/bugsnag-ruby/pull/286)
+
+* Fix report uploads being rejected due to payload size
+  | [Ben Ibinson](https://github.com/CodeHex)
+  | [Duncan Hewett](https://github.com/duncanhewett)
+  | [#288](https://github.com/bugsnag/bugsnag-ruby/pull/288)
+  | [#290](https://github.com/bugsnag/bugsnag-ruby/pull/290)
+
+* Fix a possible crash when parsing a URL for RackRequest
+  | [Max Schubert](https://github.com/perldork)
+  | [#289](https://github.com/bugsnag/bugsnag-ruby/pull/289)
+
+* Hide partial API key logged when loading Bugsnag
+  | [#283](https://github.com/bugsnag/bugsnag-ruby/issues/283)
+
 ## 4.0.0 (9 Mar 2016)
 
 This release includes general fixes as well as removing support

data/VERSION

@@ -1 +1 @@
-4.0.0
+4.0.1

data/lib/bugsnag.rb

@@ -47,7 +47,7 @@ module Bugsnag
       @logged_ready = false unless defined?(@logged_ready)
 
       if configuration.api_key && !@logged_ready
-        log "Bugsnag exception handler #{VERSION} ready, api_key=#{configuration.api_key}"
+        log "Bugsnag exception handler #{VERSION} ready"
         @logged_ready = true
       end
     end

data/lib/bugsnag/helpers.rb

@@ -1,24 +1,21 @@
 require 'uri'
+require 'set' unless defined?(Set)
+require 'json' unless defined?(JSON)
+
 
 module Bugsnag
   module Helpers
     MAX_STRING_LENGTH = 4096
+    MAX_PAYLOAD_LENGTH = 128000
+    MAX_ARRAY_LENGTH = 400
 
-    def self.reduce_hash_size(hash)
-      return {} unless hash.is_a?(Hash)
-      hash.inject({}) do |h, (k,v)|
-        if v.is_a?(Hash)
-          h[k] = reduce_hash_size(v)
-        elsif v.is_a?(Array) || v.is_a?(Set)
-          h[k] = v.map {|el| reduce_hash_size(el) }
-        else
-          val = v.to_s
-          val = val.slice(0, MAX_STRING_LENGTH) + "[TRUNCATED]" if val.length > MAX_STRING_LENGTH
-          h[k] = val
-        end
-
-        h
-      end
+    # Trim the size of value if the serialized JSON value is longer than is
+    # accepted by Bugsnag
+    def self.trim_if_needed(value)
+      return value unless payload_too_long?(value)
+      reduced_value = trim_strings_in_value(value)
+      return reduced_value unless payload_too_long?(reduced_value)
+      truncate_arrays_in_value(reduced_value)
     end
 
     def self.flatten_meta_data(overrides)
@@ -31,5 +28,95 @@ module Bugsnag
         overrides
       end
     end
+
+    private
+
+    TRUNCATION_INFO = '[TRUNCATED]'
+    RAW_DATA_TYPES = [Numeric, TrueClass, FalseClass]
+
+    # Shorten array until it fits within the payload size limit when serialized
+    def self.truncate_arrays(array)
+      return [] unless array.respond_to?(:slice)
+      array = array.slice(0, MAX_ARRAY_LENGTH)
+      while array.length > 0 and payload_too_long?(array)
+        array = array.slice(0, array.length - 1)
+      end
+      array
+    end
+
+    # Trim all strings to be less than the maximum allowed string length
+    def self.trim_strings_in_value(value, seen=[])
+      return value if is_json_raw_type?(value)
+      case value
+      when Hash
+        trim_strings_in_hash(value, seen)
+      when Array, Set
+        trim_strings_in_array(value, seen)
+      else
+        trim_as_string(value)
+      end
+    end
+
+    # Validate that the serialized JSON string value is below maximum payload
+    # length
+    def self.payload_too_long?(value)
+      ::JSON.dump(value).length >= MAX_PAYLOAD_LENGTH
+    end
+
+    # Check if a value is a raw type which should not be trimmed, truncated
+    # or converted to a string
+    def self.is_json_raw_type?(value)
+      RAW_DATA_TYPES.detect {|klass| value.is_a?(klass)} != nil
+    end
+
+    def self.trim_strings_in_hash(hash, seen=[])
+      return {} if seen.include?(hash) || !hash.is_a?(Hash)
+      result = hash.each_with_object({}) do |(key, value), reduced_hash|
+        if reduced_value = trim_strings_in_value(value, seen)
+          reduced_hash[key] = reduced_value
+        end
+      end
+      seen << hash
+      result
+    end
+
+    # If possible, convert the provided object to a string and trim to the
+    # maximum allowed string length
+    def self.trim_as_string(text)
+      return "" unless text.respond_to? :to_s
+      text = text.to_s
+      if text.length > MAX_STRING_LENGTH
+        length = MAX_STRING_LENGTH - TRUNCATION_INFO.length
+        text = text.slice(0, length) + TRUNCATION_INFO
+      end
+      text
+    end
+
+    def self.trim_strings_in_array(collection, seen=[])
+      return [] if seen.include?(collection) || !collection.respond_to?(:map)
+      result = collection.map {|value| trim_strings_in_value(value, seen)}
+      seen << collection
+      result
+    end
+
+    def self.truncate_arrays_in_value(value)
+      case value
+      when Hash
+        truncate_arrays_in_hash(value)
+      when Array, Set
+        truncate_arrays(value)
+      else
+        value
+      end
+    end
+
+    def self.truncate_arrays_in_hash(hash)
+      return {} unless hash.is_a?(Hash)
+      hash.each_with_object({}) do |(key, value), reduced_hash|
+        if reduced_value = truncate_arrays_in_value(value)
+          reduced_hash[key] = reduced_value
+        end
+      end
+    end
   end
 end

data/lib/bugsnag/middleware/rack_request.rb

@@ -23,7 +23,13 @@ module Bugsnag::Middleware
         # Build the clean url (hide the port if it is obvious)
         url = "#{request.scheme}://#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
-        url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
+
+        # If app is passed a bad URL, this code will crash attempting to clean it
+        begin
+          url << Bugsnag::Cleaner.new(notification.configuration.params_filters).clean_url(request.fullpath)
+        rescue StandardError => stde
+          Bugsnag.log "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
+        end
 
         headers = {}
 

data/lib/bugsnag/notification.rb

@@ -36,16 +36,9 @@ module Bugsnag
 
     class << self
       def deliver_exception_payload(url, payload, configuration=Bugsnag.configuration, delivery_method=nil)
-
-        # If the payload is going to be too long, we trim the hashes to send
-        # a minimal payload instead
-        payload_string = ::JSON.dump(payload)
-        if payload_string.length > 128000
-          payload[:events] = payload[:events].map {|e| Bugsnag::Helpers.reduce_hash_size(e)}
-          payload_string = ::JSON.dump(payload)
-        end
-
-        Bugsnag::Delivery[delivery_method || configuration.delivery_method].deliver(url, payload_string, configuration)
+        payload_string = ::JSON.dump(Bugsnag::Helpers.trim_if_needed(payload))
+        delivery_method = delivery_method || configuration.delivery_method
+        Bugsnag::Delivery[delivery_method].deliver(url, payload_string, configuration)
       end
     end
 

data/lib/bugsnag/railtie.rb

@@ -7,6 +7,8 @@ require "bugsnag/middleware/rack_request"
 
 module Bugsnag
   class Railtie < Rails::Railtie
+    cattr_accessor :running_as_dependency
+
     rake_tasks do
       require "bugsnag/rake"
       load "bugsnag/tasks/bugsnag.rake"
@@ -49,7 +51,7 @@ module Bugsnag
         ActiveRecord::Base.send(:include, Bugsnag::Rails::ActiveRecordRescue)
       end
 
-      Bugsnag.configuration.app_type = "rails"
+      Bugsnag.configuration.app_type = "rails" unless Bugsnag::Railtie.running_as_dependency
     end
 
     # Configure params_filters after initialization, so that rails initializers

data/lib/bugsnag/sidekiq.rb

@@ -36,3 +36,7 @@ end
 
 Bugsnag.configuration.internal_middleware.use(Bugsnag::Middleware::Sidekiq)
 Bugsnag.configuration.app_type = "sidekiq"
+
+if defined?(::Sidekiq::CLI) && defined?(Bugsnag::Railtie)
+  Bugsnag::Railtie.running_as_dependency = true
+end

data/spec/helper_spec.rb

@@ -1,30 +1,119 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'set'
 
 describe Bugsnag::Helpers do
-  it "reduces hash size correctly" do
-    meta_data = {
-      :key_one => "this should not be truncated",
-      :key_two => ""
-    }
 
-    1000.times {|i| meta_data[:key_two] += "this should be truncated " }
+  describe "trim_if_needed" do
 
-    expect(meta_data[:key_two].length).to be > 4096
+    context "payload length is less than allowed" do
 
-    meta_data_return = Bugsnag::Helpers.reduce_hash_size meta_data
+      it "does not change strings" do
+        value = SecureRandom.hex(4096)
+        expect(Bugsnag::Helpers.trim_if_needed(value)).to be value
+      end
 
-    expect(meta_data_return[:key_one].length).to eq(28)
-    expect(meta_data_return[:key_one]).to eq("this should not be truncated")
+      it "does not change arrays" do
+        value = 1000.times.map {|i| "#{i} - #{i + 1}" }
+        expect(Bugsnag::Helpers.trim_if_needed(value)).to be value
+      end
 
-    expect(meta_data_return[:key_two].length).to eq(4107)
-    expect(meta_data_return[:key_two].match(/\[TRUNCATED\]$/).nil?).to eq(false)
+      it "does not change hashes" do
+        value = Hash[*1000.times.map{|i| ["#{i}", i]}.flatten]
+        expect(Bugsnag::Helpers.trim_if_needed(value)).to be value
+      end
+    end
 
-    expect(meta_data[:key_two].length).to be > 4096
-    expect(meta_data[:key_two].match(/\[TRUNCATED\]$/).nil?).to eq(true)
+    context "payload length is greater than allowed" do
 
-    expect(meta_data[:key_one].length).to eq(28)
-    expect(meta_data[:key_one]).to eq("this should not be truncated")
+      context "value is a String" do
+        it "trims length" do
+          value = Bugsnag::Helpers.trim_if_needed(SecureRandom.hex(500_000/2))
+          expect(::JSON.dump(value.length).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
+      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
+      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
+      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) }
+          trimmed_value = Bugsnag::Helpers.trim_if_needed(value)
+          expect(trimmed_value.length).to be > 0
+          trimmed_value.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
+      end
+    end
   end
 end

data/spec/notification_spec.rb

@@ -289,6 +289,20 @@ describe Bugsnag::Notification do
     }
   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'")}
+    ex.set_backtrace(stacktrace)
+    Bugsnag.notify(ex)
+
+    expect(Bugsnag).to have_sent_notification{ |payload|
+      # 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
+    }
+  end
+
   it "accepts a severity in overrides" do
     Bugsnag.notify(BugsnagTestException.new("It crashed"), {
       :severity => "info"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bugsnag
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.1
 platform: ruby
 authors:
 - James Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-09 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake