bugsnag 6.12.1 → 6.15.0

data/lib/bugsnag/on_error_callbacks.rb

@@ -0,0 +1,33 @@
+module Bugsnag
+  # @api private
+  class OnErrorCallbacks
+    def initialize(next_middleware, callbacks)
+      @next_middleware = next_middleware
+      @callbacks = callbacks
+    end
+
+    ##
+    # @param report [Report]
+    def call(report)
+      @callbacks.each do |callback|
+        begin
+          should_continue = callback.call(report)
+        rescue StandardError => e
+          Bugsnag.configuration.warn("Error occurred in on_error callback: '#{e}'")
+          Bugsnag.configuration.warn("on_error callback stacktrace: #{e.backtrace.inspect}")
+        end
+
+        # If a callback returns false, we ignore the report and stop running callbacks
+        # Note that we explicitly check for 'false' so that callbacks don't need
+        # to return anything (i.e. can return 'nil') and we still continue
+        next unless should_continue == false
+
+        report.ignore!
+
+        break
+      end
+
+      @next_middleware.call(report)
+    end
+  end
+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
       {
@@ -192,7 +182,7 @@ module Bugsnag
         {
           errorClass: error_class(exception),
           message: exception.message,
-          stacktrace: Stacktrace.new(exception.backtrace, configuration).to_a
+          stacktrace: Stacktrace.process(exception.backtrace, configuration)
         }
       end
     end

data/lib/bugsnag/session_tracker.rb

@@ -1,11 +1,9 @@
 require 'thread'
 require 'time'
 require 'securerandom'
-require 'concurrent'
 
 module Bugsnag
   class SessionTracker
-
     THREAD_SESSION = "bugsnag_session"
     SESSION_PAYLOAD_VERSION = "1.0"
     MUTEX = Mutex.new
@@ -27,6 +25,8 @@ module Bugsnag
     ##
     # Initializes the session tracker.
     def initialize
+      require 'concurrent'
+
       @session_counts = Concurrent::Hash.new(0)
     end
 
@@ -139,4 +139,4 @@ module Bugsnag
       Bugsnag::Delivery[Bugsnag.configuration.delivery_method].deliver(Bugsnag.configuration.session_endpoint, payload, Bugsnag.configuration, options)
     end
   end
-end
+end

data/lib/bugsnag/stacktrace.rb

@@ -1,55 +1,51 @@
-module Bugsnag
-  class Stacktrace
+require_relative 'code_extractor'
 
+module Bugsnag
+  module Stacktrace
     # e.g. "org/jruby/RubyKernel.java:1264:in `catch'"
     BACKTRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/
 
     # 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.
-    def initialize(backtrace, configuration)
-      @configuration = configuration
+    #
+    # @param backtrace [Array, nil] If nil, 'caller' will be used instead
+    # @param configuration [Configuration]
+    # @return [Array]
+    def self.process(backtrace, configuration)
+      code_extractor = CodeExtractor.new(configuration)
 
       backtrace = caller if !backtrace || backtrace.empty?
 
-      @processed_backtrace = backtrace.map do |trace|
+      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?
+        next 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 = {}
-        trace_hash[:lineNumber] = line_str.to_i
+        trace_hash = { lineNumber: line_str.to_i }
 
-        if configuration.send_code
-          trace_hash[:code] = code(file, trace_hash[:lineNumber])
-        end
+        # Save a copy of the file path as we're about to modify it but need the
+        # raw version when extracting code (otherwise we can't open the file)
+        raw_file_path = file.dup
 
         # Clean up the file path in the stacktrace
-        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)
+        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(configuration.vendor_path)
         end
 
-
         # Strip common gem path prefixes
         if defined?(Gem)
           file = Gem.path.inject(file) {|line, path| line.sub(/#{path}\//, "") }
@@ -60,59 +56,16 @@ module Bugsnag
         # Add a method if we have it
         trace_hash[:method] = method if method && (method =~ /^__bind/).nil?
 
-        if trace_hash[:file] && !trace_hash[:file].empty?
-          trace_hash
-        else
-          nil
-        end
-      end.compact
-    end
-
-    ##
-    # Returns the processed backtrace
-    def to_a
-      @processed_backtrace
-    end
-
-    private
-
-    def code(file, line_number, num_lines = 7)
-      code_hash = {}
-
-      from_line = [line_number - num_lines, 1].max
-
-      # don't try and open '(irb)' or '-e'
-      return unless File.exist?(file)
-
-      # Populate code hash with line numbers and code lines
-      File.open(file) do |f|
-        current_line_number = 0
-        f.each_line do |line|
-          current_line_number += 1
+        # If we're going to send code then record the raw file path and the
+        # trace_hash, so we can extract from it later
+        code_extractor.add_file(raw_file_path, trace_hash) if configuration.send_code
 
-          next if current_line_number < from_line
-
-          code_hash[current_line_number] = line[0...200].rstrip
-
-          break if code_hash.length >= ( num_lines * 1.5 ).ceil
-        end
-      end
-
-      while code_hash.length > num_lines
-        last_line = code_hash.keys.max
-        first_line = code_hash.keys.min
+        trace_hash
+      end.compact
 
-        if (last_line - line_number) > (line_number - first_line)
-          code_hash.delete(last_line)
-        else
-          code_hash.delete(first_line)
-        end
-      end
+      code_extractor.extract! if configuration.send_code
 
-      code_hash
-    rescue
-      @configuration.warn("Error fetching code: #{$!.inspect}")
-      nil
+      processed_backtrace
     end
   end
 end

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" }