bugsnag 6.12.0 → 6.14.0

data/lib/bugsnag/helpers.rb

@@ -17,12 +17,10 @@ module 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)
+      return value unless payload_too_long?(value)
 
       # Trim metadata
-      reduced_value = trim_metadata(sanitized_value)
+      reduced_value = trim_metadata(value)
       return reduced_value unless payload_too_long?(reduced_value)
 
       # Trim code from stacktrace

data/lib/bugsnag/integrations/que.rb

@@ -37,13 +37,16 @@ if defined?(::Que)
     end
   end
 
-  if Que.respond_to?(:error_notifier=)
-    Bugsnag.configuration.app_type ||= "que"
+  Bugsnag.configuration.app_type ||= "que"
+  if defined?(::Que::Version)
     Bugsnag.configuration.runtime_versions["que"] = ::Que::Version
+  elsif defined?(::Que::VERSION)
+    Bugsnag.configuration.runtime_versions["que"] = ::Que::VERSION
+  end
+
+  if Que.respond_to?(:error_notifier=)
     Que.error_notifier = handler
   elsif Que.respond_to?(:error_handler=)
-    Bugsnag.configuration.app_type ||= "que"
-    Bugsnag.configuration.runtime_versions["que"] = ::Que::Version
     Que.error_handler = handler
   end
 end

data/lib/bugsnag/integrations/railtie.rb

@@ -79,7 +79,7 @@ module Bugsnag
         filtered_data = data.slice(*event[:allowed_data])
         filtered_data[:event_name] = event[:id]
         filtered_data[:event_id] = event_id
-        if event[:id] == "sql.active_record"
+        if event[:id] == "sql.active_record" && data.key?(:binds)
           binds = data[:binds].each_with_object({}) { |bind, output| output[bind.name] = '?' if defined?(bind.name) }
           filtered_data[:binds] = JSON.dump(binds) unless binds.empty?
         end

data/lib/bugsnag/middleware/discard_error_class.rb

@@ -0,0 +1,30 @@
+module Bugsnag::Middleware
+  ##
+  # Determines if the exception should be ignored based on the configured
+  # `discard_classes`
+  class DiscardErrorClass
+    ##
+    # @param middleware [#call] The next middleware to call
+    def initialize(middleware)
+      @middleware = middleware
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      should_discard = report.raw_exceptions.any? do |ex|
+        report.configuration.discard_classes.any? do |to_ignore|
+          case to_ignore
+          when String then to_ignore == ex.class.name
+          when Regexp then to_ignore =~ ex.class.name
+          else false
+          end
+        end
+      end
+
+      report.ignore! if should_discard
+
+      @middleware.call(report)
+    end
+  end
+end

data/lib/bugsnag/middleware/exception_meta_data.rb

@@ -9,21 +9,27 @@ module Bugsnag::Middleware
     def call(report)
       # Apply the user's information attached to the exceptions
       report.raw_exceptions.each do |exception|
-        if exception.respond_to?(:bugsnag_user_id) && exception.bugsnag_user_id.is_a?(String)
-          report.user = {id: exception.bugsnag_user_id}
+        if exception.respond_to?(:bugsnag_user_id)
+          user_id = exception.bugsnag_user_id
+          report.user = {id: user_id} if user_id.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_context) && exception.bugsnag_context.is_a?(String)
-          report.context = exception.bugsnag_context
+        if exception.respond_to?(:bugsnag_context)
+          context = exception.bugsnag_context
+          report.context = context if context.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_grouping_hash) && exception.bugsnag_grouping_hash.is_a?(String)
-          report.grouping_hash = exception.bugsnag_grouping_hash
+        if exception.respond_to?(:bugsnag_grouping_hash)
+          group_hash = exception.bugsnag_grouping_hash
+          report.grouping_hash = group_hash if group_hash.is_a?(String)
         end
 
-        if exception.respond_to?(:bugsnag_meta_data) && exception.bugsnag_meta_data.is_a?(Hash)
-          exception.bugsnag_meta_data.each do |key, value|
-            report.add_tab key, value
+        if exception.respond_to?(:bugsnag_meta_data)
+          meta_data = exception.bugsnag_meta_data
+          if meta_data.is_a?(Hash)
+            meta_data.each do |key, value|
+              report.add_tab key, value
+            end
           end
         end
       end

data/lib/bugsnag/middleware/ignore_error_class.rb

@@ -2,6 +2,8 @@ module Bugsnag::Middleware
   ##
   # Determines if the exception should be ignored based on the configured
   # `ignore_classes`
+  #
+  # @deprecated Use {DiscardErrorClass} instead
   class IgnoreErrorClass
     def initialize(bugsnag)
       @bugsnag = bugsnag

data/lib/bugsnag/middleware/rack_request.rb

@@ -28,18 +28,16 @@ module Bugsnag::Middleware
         url = "#{request.scheme}://#{request.host}"
         url << ":#{request.port}" unless [80, 443].include?(request.port)
 
-        cleaner = Bugsnag::Cleaner.new(report.configuration.meta_data_filters)
-
         # If app is passed a bad URL, this code will crash attempting to clean it
         begin
-          url << cleaner.clean_url(request.fullpath)
+          url << Bugsnag.cleaner.clean_url(request.fullpath)
         rescue StandardError => stde
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.fullpath: #{stde}"
         end
 
         referer = nil
         begin
-          referer = cleaner.clean_url(request.referer) if request.referer
+          referer = Bugsnag.cleaner.clean_url(request.referer) if request.referer
         rescue StandardError => stde
           Bugsnag.configuration.warn "RackRequest - Rescued error while cleaning request.referer: #{stde}"
         end

data/lib/bugsnag/report.rb

@@ -97,6 +97,7 @@ module Bugsnag
           releaseStage: release_stage,
           type: app_type
         },
+        breadcrumbs: breadcrumbs.map(&:to_h),
         context: context,
         device: {
           hostname: hostname,
@@ -104,6 +105,7 @@ module Bugsnag
         },
         exceptions: exceptions,
         groupingHash: grouping_hash,
+        metaData: meta_data,
         session: session,
         severity: severity,
         severityReason: severity_reason,
@@ -111,19 +113,7 @@ module Bugsnag
         user: user
       }
 
-      # cleanup character encodings
-      payload_event = Bugsnag::Cleaner.clean_object_encoding(payload_event)
-
-      # filter out sensitive values in (and cleanup encodings) metaData
-      filter_cleaner = Bugsnag::Cleaner.new(configuration.meta_data_filters)
-      payload_event[:metaData] = filter_cleaner.clean_object(meta_data)
-      payload_event[:breadcrumbs] = breadcrumbs.map do |breadcrumb|
-        breadcrumb_hash = breadcrumb.to_h
-        breadcrumb_hash[:metaData] = filter_cleaner.clean_object(breadcrumb_hash[:metaData])
-        breadcrumb_hash
-      end
-
-      payload_event.reject! {|k,v| v.nil? }
+      payload_event.reject! {|k, v| v.nil? }
 
       # return the payload hash
       {

data/lib/bugsnag/stacktrace.rb

@@ -7,32 +7,27 @@ module Bugsnag
     # e.g. "org.jruby.Ruby.runScript(Ruby.java:807)"
     JAVA_BACKTRACE_REGEX = /^(.*)\((.*)(?::([0-9]+))?\)$/
 
-    # Path to vendored code. Used to mark file paths as out of project.
-    VENDOR_PATH = /^(vendor\/|\.bundle\/)/
-
     ##
     # Process a backtrace and the configuration into a parsed stacktrace.
+    #
+    # rubocop:todo Metrics/CyclomaticComplexity
     def initialize(backtrace, configuration)
       @configuration = configuration
 
       backtrace = caller if !backtrace || backtrace.empty?
 
       @processed_backtrace = backtrace.map do |trace|
+        # Parse the stacktrace line
         if trace.match(BACKTRACE_LINE_REGEX)
           file, line_str, method = [$1, $2, $3]
         elsif trace.match(JAVA_BACKTRACE_REGEX)
           method, file, line_str = [$1, $2, $3]
         end
 
-        # Parse the stacktrace line
-
         next(nil) if file.nil?
 
         # Expand relative paths
-        p = Pathname.new(file)
-        if p.relative?
-          file = p.realpath.to_s rescue file
-        end
+        file = File.realpath(file) rescue file
 
         # Generate the stacktrace line hash
         trace_hash = {}
@@ -46,7 +41,7 @@ module Bugsnag
         if defined?(@configuration.project_root) && @configuration.project_root.to_s != ''
           trace_hash[:inProject] = true if file.start_with?(@configuration.project_root.to_s)
           file.sub!(/#{@configuration.project_root}\//, "")
-          trace_hash.delete(:inProject) if file.match(VENDOR_PATH)
+          trace_hash.delete(:inProject) if file.match(@configuration.vendor_path)
         end
 
 
@@ -67,6 +62,7 @@ module Bugsnag
         end
       end.compact
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     ##
     # Returns the processed backtrace

data/spec/breadcrumbs/breadcrumb_spec.rb

@@ -90,4 +90,4 @@ RSpec.describe Bugsnag::Breadcrumbs::Breadcrumb do
       )
     end
   end
-end
+end

data/spec/breadcrumbs/validator_spec.rb

@@ -31,31 +31,6 @@ RSpec.describe Bugsnag::Breadcrumbs::Validator do
       validator.validate(breadcrumb)
     end
 
-    it "trims long messages to length and warns" do
-      config = instance_double(Bugsnag::Configuration)
-      allow(config).to receive(:enabled_automatic_breadcrumb_types).and_return(enabled_automatic_breadcrumb_types)
-      validator = Bugsnag::Breadcrumbs::Validator.new(config)
-
-      name = "1234567890123456789012345678901234567890"
-
-      breadcrumb = instance_double(Bugsnag::Breadcrumbs::Breadcrumb, {
-        :auto => auto,
-        :name => name,
-        :type => type,
-        :meta_data => meta_data,
-        :meta_data= => nil
-      })
-
-      expect(breadcrumb).to_not receive(:ignore!)
-      expect(breadcrumb).to receive(:name=).with("123456789012345678901234567890")
-      expected_string = "Breadcrumb name trimmed to length 30.  Original name: #{name}"
-      expect(config).to receive(:debug).with(expected_string)
-
-      validator.validate(breadcrumb)
-      # Check the original message has not been modified
-      expect(name).to eq("1234567890123456789012345678901234567890")
-    end
-
     describe "tests meta_data types" do
       it "accepts Strings, Numerics, Booleans, & nil" do
         config = instance_double(Bugsnag::Configuration)
@@ -198,4 +173,4 @@ RSpec.describe Bugsnag::Breadcrumbs::Validator do
       end
     end
   end
-end
+end

data/spec/bugsnag_spec.rb

@@ -268,7 +268,7 @@ describe Bugsnag do
       )
       expect(breadcrumbs.to_a.size).to eq(1)
       expect(breadcrumbs.first.to_h).to match({
-        :name => "123123123123123123123123123123",
+        :name => "123123123123123123123123123123456456456456456456456456456456",
         :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
         :metaData => {
           :a => 1
@@ -311,7 +311,7 @@ describe Bugsnag do
       Bugsnag.leave_breadcrumb("TestName")
       expect(breadcrumbs.to_a.size).to eq(1)
       expect(breadcrumbs.first.to_h).to match({
-        :name => "123123123123123123123123123123",
+        :name => "123123123123123123123123123123456456456456456",
         :type => Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE,
         :metaData => {
           :int => 1

data/spec/cleaner_spec.rb

@@ -3,15 +3,87 @@
 require 'spec_helper'
 
 describe Bugsnag::Cleaner do
-  subject { described_class.new(nil) }
+  subject { Bugsnag::Cleaner.new(Bugsnag::Configuration.new) }
 
   describe "#clean_object" do
+    is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
     it "cleans up recursive hashes" do
       a = {:a => {}}
       a[:a][:b] = a
       expect(subject.clean_object(a)).to eq({:a => {:b => "[RECURSION]"}})
     end
 
+    it "cleans up hashes when keys infinitely recurse in to_s" do
+      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
+
+      class RecursiveHashKey
+        def to_s
+          to_s
+        end
+      end
+
+      key = RecursiveHashKey.new
+
+      a = {}
+      a[key] = 1
+
+      expect(subject.clean_object(a)).to eq({ "[RECURSION]" => "[FILTERED]" })
+    end
+
+    it "cleans up hashes when a nested key infinitely recurse in to_s" do
+      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
+
+      class RecursiveHashKey
+        def to_s
+          to_s
+        end
+      end
+
+      key = RecursiveHashKey.new
+
+      a = {}
+      a[:b] = {}
+      a[:b][key] = 1
+
+      expected = { :b => { "[RECURSION]" => "[FILTERED]" } }
+
+      expect(subject.clean_object(a)).to eq(expected)
+    end
+
+    it "cleans up hashes when keys raise in to_s" do
+      class RaisingHashKey
+        def to_s
+          raise "hey!"
+        end
+      end
+
+      key = RaisingHashKey.new
+
+      a = {}
+      a[key] = 1
+
+      expect(subject.clean_object(a)).to eq({ "[RAISED]" => "[FILTERED]" })
+    end
+
+    it "cleans up hashes when nested keys raise in to_s" do
+      class RaisingHashKey
+        def to_s
+          raise "hey!"
+        end
+      end
+
+      key = RaisingHashKey.new
+
+      a = {}
+      a[:b] = {}
+      a[:b][key] = 1
+
+      expected = { :b => { "[RAISED]" => "[FILTERED]" } }
+
+      expect(subject.clean_object(a)).to eq(expected)
+    end
+
     it "cleans up recursive arrays" do
       a = []
       a << a
@@ -48,6 +120,31 @@ describe Bugsnag::Cleaner do
       expect(subject.clean_object(a)).to eq('[OBJECT]')
     end
 
+    it "cleans custom objects when they infinitely recurse" do
+      skip "JRuby doesn't allow recovery from SystemStackErrors" if is_jruby
+
+      class RecursiveObject
+        def to_s
+          to_s
+        end
+      end
+
+      object = RecursiveObject.new
+
+      expect(subject.clean_object(object)).to eq("[RECURSION]")
+    end
+
+    it "cleans custom objects to show the id of the object if object responds to id method" do
+      class MacaronWithId
+        def id
+          10
+        end
+      end
+
+      a = MacaronWithId.new
+      expect(subject.clean_object(a)).to eq("[OBJECT]: [Class]: #{a.class.name} [ID]: #{a.id}")
+    end
+
     it "cleans up binary strings properly" do
       if RUBY_VERSION > "1.9"
         obj = "Andr\xc7\xff"
@@ -70,23 +167,113 @@ describe Bugsnag::Cleaner do
     end
 
     it "filters by string inclusion" do
-      expect(described_class.new(['f']).clean_object({ :foo => 'bar' })).to eq({ :foo => '[FILTERED]' })
-      expect(described_class.new(['b']).clean_object({ :foo => 'bar' })).to eq({ :foo => 'bar' })
+      object = { events: { metaData: { foo: 'bar' } } }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = ['f']
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: '[FILTERED]' } } })
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = ['b']
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: 'bar' } } })
     end
 
     it "filters by regular expression" do
-      expect(described_class.new([/fb?/]).clean_object({ :foo => 'bar' })).to eq({ :foo => '[FILTERED]' })
-      expect(described_class.new([/fb+/]).clean_object({ :foo => 'bar' })).to eq({ :foo => 'bar' })
+      object = { events: { metaData: { foo: 'bar' } } }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/fb?/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: '[FILTERED]' } } })
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/fb+/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+      expect(cleaner.clean_object(object)).to eq({ events: { metaData: { foo: 'bar' } } })
     end
 
     it "filters deeply nested keys" do
-      params = {:foo => {:bar => "baz"}}
-      expect(described_class.new([/^foo\.bar/]).clean_object(params)).to eq({:foo => {:bar => '[FILTERED]'}})
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/^foo\.bar/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      params = { events: { metaData: { foo: { bar: 'baz' } } } }
+      expect(cleaner.clean_object(params)).to eq({ events: { metaData: { foo: { bar: '[FILTERED]' } } } })
     end
 
     it "filters deeply nested request parameters" do
-      params = {:request => {:params => {:foo => {:bar => "baz"}}}}
-      expect(described_class.new([/^foo\.bar/]).clean_object(params)).to eq({:request => {:params => {:foo => {:bar => '[FILTERED]'}}}})
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/^foo\.bar/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      params = { events: { metaData: { request: { params: { foo: { bar: 'baz' } } } } } }
+      expect(cleaner.clean_object(params)).to eq({ events: { metaData: { request: { params: { foo: { bar: '[FILTERED]' } } } } } })
+    end
+
+    it "doesn't filter by string inclusion when the scope is not in 'scopes_to_filter'" do
+      object = { foo: 'bar' }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = ['f']
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = ['b']
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
+    end
+
+    it "doesn't filter by regular expression when the scope is not in 'scopes_to_filter'" do
+      object = { foo: 'bar' }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/fb?/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/fb+/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(object)).to eq({ foo: 'bar' })
+    end
+
+    it "doesn't filter deeply nested keys when the scope is not in 'scopes_to_filter'" do
+      params = { foo: { bar: 'baz' } }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/^foo\.bar/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(params)).to eq({ foo: { bar: 'baz' } })
+    end
+
+    it "doesn't filter deeply nested request parameters when the scope is not in 'scopes_to_filter'" do
+      params = { request: { params: { foo: { bar: 'baz' } } } }
+
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = [/^foo\.bar/]
+
+      cleaner = Bugsnag::Cleaner.new(configuration)
+
+      expect(cleaner.clean_object(params)).to eq({ request: { params: { foo: { bar: 'baz' } } } })
     end
 
     it "filters objects which can't be stringified" do
@@ -101,7 +288,12 @@ describe Bugsnag::Cleaner do
 
   describe "#clean_url" do
     let(:filters) { [] }
-    subject { described_class.new(filters).clean_url(url) }
+
+    subject do
+      configuration = Bugsnag::Configuration.new
+      configuration.meta_data_filters = filters
+      described_class.new(configuration).clean_url(url)
+    end
 
     context "with no filters configured" do
       let(:url) { "/dir/page?param1=value1&param2=value2" }