bugsnag 6.13.1 → 6.14.0

data/lib/bugsnag/configuration.rb

@@ -3,6 +3,7 @@ require "socket"
 require "logger"
 require "bugsnag/middleware_stack"
 require "bugsnag/middleware/callbacks"
+require "bugsnag/middleware/discard_error_class"
 require "bugsnag/middleware/exception_meta_data"
 require "bugsnag/middleware/ignore_error_class"
 require "bugsnag/middleware/suggestion_data"
@@ -35,9 +36,13 @@ module Bugsnag
     attr_accessor :timeout
     attr_accessor :hostname
     attr_accessor :runtime_versions
-    attr_accessor :ignore_classes
+    attr_accessor :discard_classes
     attr_accessor :auto_capture_sessions
 
+    ##
+    # @deprecated Use {#discard_classes} instead
+    attr_accessor :ignore_classes
+
     ##
     # @return [String] URL error notifications will be delivered to
     attr_reader :notify_endpoint
@@ -67,6 +72,10 @@ module Bugsnag
     # @return [Regexp] matching file paths out of project
     attr_accessor :vendor_path
 
+    ##
+    # @return [Array]
+    attr_reader :scopes_to_filter
+
     API_KEY_REGEX = /[0-9a-f]{32}/i
     THREAD_LOCAL_NAME = "bugsnag_req_data"
 
@@ -86,7 +95,9 @@ module Bugsnag
     DEFAULT_MAX_BREADCRUMBS = 25
 
     # Path to vendored code. Used to mark file paths as out of project.
-    DEFAULT_VENDOR_PATH = %r{^(vendor\/|\.bundle\/)}
+    DEFAULT_VENDOR_PATH = %r{^(vendor/|\.bundle/)}
+
+    DEFAULT_SCOPES_TO_FILTER = ['events.metaData', 'events.breadcrumbs.metaData'].freeze
 
     alias :track_sessions :auto_capture_sessions
     alias :track_sessions= :auto_capture_sessions=
@@ -99,6 +110,7 @@ module Bugsnag
       self.send_environment = false
       self.send_code = true
       self.meta_data_filters = Set.new(DEFAULT_META_DATA_FILTERS)
+      self.scopes_to_filter = DEFAULT_SCOPES_TO_FILTER
       self.hostname = default_hostname
       self.runtime_versions = {}
       self.runtime_versions["ruby"] = RUBY_VERSION
@@ -122,7 +134,10 @@ module Bugsnag
 
       # SystemExit and SignalException are common Exception types seen with
       # successful exits and are not automatically reported to Bugsnag
+      # TODO move these defaults into `discard_classes` when `ignore_classes`
+      #      is removed
       self.ignore_classes = Set.new([SystemExit, SignalException])
+      self.discard_classes = Set.new([])
 
       # Read the API key from the environment
       self.api_key = ENV["BUGSNAG_API_KEY"]
@@ -147,6 +162,7 @@ module Bugsnag
       # Configure the bugsnag middleware stack
       self.internal_middleware = Bugsnag::MiddlewareStack.new
       self.internal_middleware.use Bugsnag::Middleware::ExceptionMetaData
+      self.internal_middleware.use Bugsnag::Middleware::DiscardErrorClass
       self.internal_middleware.use Bugsnag::Middleware::IgnoreErrorClass
       self.internal_middleware.use Bugsnag::Middleware::SuggestionData
       self.internal_middleware.use Bugsnag::Middleware::ClassifyError
@@ -304,6 +320,8 @@ module Bugsnag
 
     private
 
+    attr_writer :scopes_to_filter
+
     PROG_NAME = "[Bugsnag]"
 
     def default_hostname

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

@@ -9,27 +9,25 @@ module Bugsnag
 
     ##
     # 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 = {}
@@ -64,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,7 +3,7 @@
 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'
@@ -134,6 +134,17 @@ describe Bugsnag::Cleaner do
       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"
@@ -156,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
@@ -187,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" }