bugsnag 6.14.0 → 6.15.0

data/lib/bugsnag/configuration.rb

@@ -318,6 +318,33 @@ module Bugsnag
       @enable_sessions = false
     end
 
+    ##
+    # Add the given callback to the list of on_error callbacks
+    #
+    # The on_error callbacks will be called when an error is captured or reported
+    # and are passed a {Bugsnag::Report} object
+    #
+    # Returning false from an on_error callback will cause the error to be ignored
+    # and will prevent any remaining callbacks from being called
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def add_on_error(callback)
+      middleware.use(callback)
+    end
+
+    ##
+    # Remove the given callback from the list of on_error callbacks
+    #
+    # Note that this must be the same Proc instance that was passed to
+    # {#add_on_error}, otherwise it will not be removed
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def remove_on_error(callback)
+      middleware.remove(callback)
+    end
+
     private
 
     attr_writer :scopes_to_filter

data/lib/bugsnag/middleware_stack.rb

@@ -1,3 +1,5 @@
+require "bugsnag/on_error_callbacks"
+
 module Bugsnag
   class MiddlewareStack
     ##
@@ -65,11 +67,26 @@ module Bugsnag
       end
     end
 
+    ##
+    # Disable the given middleware. This removes them from the list of
+    # middleware and ensures they cannot be added again
+    #
+    # See also {#remove}
     def disable(*middlewares)
       @mutex.synchronize do
         @disabled_middleware += middlewares
 
-        @middlewares.delete_if {|m| @disabled_middleware.include?(m)}
+        @middlewares.delete_if {|m| @disabled_middleware.include?(m) }
+      end
+    end
+
+    ##
+    # Remove the given middleware from the list of middleware
+    #
+    # This is like {#disable} but allows the middleware to be added again
+    def remove(*middlewares)
+      @mutex.synchronize do
+        @middlewares.delete_if {|m| middlewares.include?(m) }
       end
     end
 
@@ -91,7 +108,7 @@ module Bugsnag
 
       begin
         # We reverse them, so we can call "call" on the first middleware
-        middleware_procs.reverse.inject(notify_lambda) { |n,e| e.call(n) }.call(report)
+        middleware_procs.reverse.inject(notify_lambda) {|n, e| e.call(n) }.call(report)
       rescue StandardError => e
         # KLUDGE: Since we don't re-raise middleware exceptions, this breaks rspec
         raise if e.class.to_s == "RSpec::Expectations::ExpectationNotMetError"
@@ -107,10 +124,28 @@ module Bugsnag
     end
 
     private
+
+    ##
     # Generates a list of middleware procs that are ready to be run
     # Pass each one a reference to the next in the queue
+    #
+    # @return [Array<Proc>]
     def middleware_procs
-      @middlewares.map{|middleware| proc { |next_middleware| middleware.new(next_middleware) } }
+      # Split the middleware into separate lists of Procs and Classes
+      procs, classes = @middlewares.partition {|middleware| middleware.is_a?(Proc) }
+
+      # Wrap the classes in a proc that, when called, news up the middleware and
+      # passes the next middleware in the queue
+      middleware_instances = classes.map do |middleware|
+        proc {|next_middleware| middleware.new(next_middleware) }
+      end
+
+      # Wrap the list of procs in a proc that, when called, wraps them in an
+      # 'OnErrorCallbacks' instance that also has a reference to the next middleware
+      wrapped_procs = proc {|next_middleware| OnErrorCallbacks.new(next_middleware, procs) }
+
+      # Return the combined middleware and wrapped procs
+      middleware_instances.push(wrapped_procs)
     end
   end
 end

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

@@ -182,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,6 +1,7 @@
-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 `([^']+)')?$/
 
@@ -10,13 +11,15 @@ module Bugsnag
     ##
     # Process a backtrace and the configuration into a parsed stacktrace.
     #
-    # rubocop:todo Metrics/CyclomaticComplexity
-    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]
@@ -24,27 +27,25 @@ module Bugsnag
           method, file, line_str = [$1, $2, $3]
         end
 
-        next(nil) if file.nil?
+        next if file.nil?
 
         # Expand relative paths
         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(@configuration.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}\//, "") }
@@ -55,60 +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
-    # rubocop:enable Metrics/CyclomaticComplexity
-
-    ##
-    # Returns the processed backtrace
-    def to_a
-      @processed_backtrace
-    end
-
-    private
+        # 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
 
-    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
-
-          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/code_extractor_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Bugsnag::CodeExtractor do
+  it "extracts code from a file and adds it to the given hash" do
+    file1_hash = { lineNumber: 5 }
+    file2_hash = { lineNumber: 7 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({
+      lineNumber: 5,
+      code: {
+        2 => "",
+        3 => "module File1",
+        4 => "  def self.foo1",
+        5 => "    File2.foo2",
+        6 => "  end",
+        7 => "",
+        8 => "  def self.bar1"
+      }
+    })
+
+    expect(file2_hash).to eq({
+      lineNumber: 7,
+      code: {
+        4 => "  end",
+        5 => "",
+        6 => "  def self.bar2",
+        7 => "    File1.baz1",
+        8 => "  end",
+        9 => "",
+        10 => "  def self.baz2"
+      }
+    })
+  end
+
+  it "handles extracting code from the first & last line in a file" do
+    file1_hash = { lineNumber: 1 }
+    file2_hash = { lineNumber: 25 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({
+      lineNumber: 1,
+      code: {
+        1 => "require_relative 'file2'",
+        2 => "",
+        3 => "module File1",
+        4 => "  def self.foo1",
+        5 => "    File2.foo2",
+        6 => "  end",
+        7 => ""
+      }
+    })
+
+    expect(file2_hash).to eq({
+      lineNumber: 25,
+      code: {
+        19 => "    puts 'abcdef2'",
+        20 => "  end",
+        21 => "",
+        22 => "  def self.abcdefghi2",
+        23 => "    puts 'abcdefghi2'",
+        24 => "  end",
+        25 => "end"
+      }
+    })
+  end
+
+  it "truncates lines to a maximum of 200 characters" do
+    hash = { lineNumber: 4 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file_with_long_lines.rb", hash)
+
+    code_extractor.extract!
+
+    # rubocop:disable Layout/LineLength
+    expect(hash).to eq({
+      lineNumber: 4,
+      code: {
+        1 => "# rubocop:disable Layout/LineLength",
+        2 => "def a_super_long_function_name_that_would_be_really_impractical_to_use_but_luckily_this_is_just_for_a_test_to_prove_we_can_handle_really_long_lines_of_code_that_go_over_200_characters_and_some_more_pa",
+        3 => "  puts 'This is a shorter string'",
+        4 => "  puts 'A more realistic example of when a line would be really long is long strings such as this one, which extends over the 200 character limit by containing a lot of excess words for padding its le",
+        5 => "  puts 'and another shorter string for comparison'",
+        6 => "end",
+        7 => "# rubocop:enable Layout/LineLength",
+      }
+    })
+    # rubocop:enable Layout/LineLength
+  end
+
+  it "rescues exceptions raised in extract!" do
+    file1_hash = { lineNumber: 1 }
+    file2_hash = { lineNumber: 25 }
+
+    code_extractor = Bugsnag::CodeExtractor.new(Bugsnag::Configuration.new)
+    code_extractor.add_file("spec/fixtures/crashes/file1.rb", file1_hash)
+    code_extractor.add_file("spec/fixtures/crashes/file2.rb", file2_hash)
+
+    file1_hash[:first_line_number] = nil
+
+    code_extractor.extract!
+
+    expect(file1_hash).to eq({ lineNumber: 1, code: nil })
+
+    expect(file2_hash).to eq({
+      lineNumber: 25,
+      code: {
+        19 => "    puts 'abcdef2'",
+        20 => "  end",
+        21 => "",
+        22 => "  def self.abcdefghi2",
+        23 => "    puts 'abcdefghi2'",
+        24 => "  end",
+        25 => "end"
+      }
+    })
+  end
+end

data/spec/fixtures/crashes/file1.rb

@@ -0,0 +1,29 @@
+require_relative 'file2'
+
+module File1
+  def self.foo1
+    File2.foo2
+  end
+
+  def self.bar1
+    File2.bar2
+  end
+
+  def self.baz1
+    File2.baz2
+  end
+
+  def self.abc1
+    puts 'abc'
+  end
+
+  def self.abcdef1
+    puts 'abcdef1'
+  end
+
+  def self.abcdefghi1
+    puts 'abcdefghi1'
+  end
+end
+
+File1.foo1