bugsnag 6.14.0 → 6.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37ddadee8c92423e803ed8d9be43b564c79110ea9ddf8dd4180a9a3b1080e575
-  data.tar.gz: 887d7017da4d23fe00515109c8c791c2e4d205e5968faaa3178d522ab5a7c51c
+  metadata.gz: 5a3825d21f3c5d15bfb0244584a4cf18032fae0c7432a829db961b8310f3c679
+  data.tar.gz: 0b6008183c0562e67c8a5ef1ae6c599645aad55313fbcc3aa6d7a7b2996ca98d
 SHA512:
-  metadata.gz: 0a4808f2f7f73728ebab03d434f3ddccc38ceb743d986adf56225725ebdeee84c9ec63c4a2334078fbef44aa084b362468ab6cc98f2bcf8bc6ada991db44099a
-  data.tar.gz: ad4ba7af2a2aae7360cf111507dbaec30e0a6e668b606c111e231fc75683556ff14e0376673c50f45231dbcec5f59ff0649cf2e89c85e8cedf7e14b9b4fc196d
+  metadata.gz: ffc195c3a00ecbf51f76974ac5281536ff406fa944030b6c36f907cdabceaa79a15720094c4f7f53347cbc760819cb0600cbd5ed9117d8e3d1d34e3f614e9eb3
+  data.tar.gz: ca216fbbf877e60007be16315bad08ce1d5b07a884e4dc83ef2c7e548cd4511b31e92f608cfe5ee7463adf0bad6e33710009a4679bab45089481ffa918fd44ec

data/.yardopts

@@ -0,0 +1,11 @@
+--charset UTF-8
+--fail-on-warning
+--hide-api private
+--no-private
+--protected
+--title "bugsnag-ruby API Documentation"
+lib/**/*.rb
+-
+README.md
+CONTRIBUTING.md
+CHANGELOG.md

data/CHANGELOG.md

@@ -1,6 +1,80 @@
 Changelog
 =========
 
+## 6.19.0 (6 January 2021)
+
+### Enhancements
+
+* Exception messages will be truncated if they have a length greater than 3,072
+  | [#636](https://github.com/bugsnag/bugsnag-ruby/pull/636)
+  | [joshuapinter](https://github.com/joshuapinter)
+
+* Breadcrumb metadata can now contain any type
+  | [#648](https://github.com/bugsnag/bugsnag-ruby/pull/648)
+
+## 6.18.0 (27 October 2020)
+
+### Enhancements
+
+* Bugsnag should now report uncaught exceptions inside Bundler's 'friendly errors'
+  | [#634](https://github.com/bugsnag/bugsnag-ruby/pull/634)
+
+* Improve the display of breadrumbs in the Bugsnag app by including milliseconds in timestamps
+  | [#639](https://github.com/bugsnag/bugsnag-ruby/pull/639)
+
+## 6.17.0 (27 August 2020)
+
+### Enhancements
+
+* Sidekiq now uses `thread_queue` delivery by default
+  | [#626](https://github.com/bugsnag/bugsnag-ruby/pull/626)
+
+* Rescue now uses `thread_queue` delivery when `at_exit` hooks are enabled
+  | [#629](https://github.com/bugsnag/bugsnag-ruby/pull/629)
+
+## 6.16.0 (12 August 2020)
+
+### Enhancements
+
+* Set default Delayed Job error context to job class
+  | [#499](https://github.com/bugsnag/bugsnag-ruby/pull/499)
+  | [Mike Stewart](https://github.com/mike-stewart)
+
+* The `BUGSNAG_RELEASE_STAGE` environment variable can now be used to set the release stage. Previously this was only used in Rails applications
+  | [#613](https://github.com/bugsnag/bugsnag-ruby/pull/613)
+
+* Add support for runtime versions to Delayed Job, Mailman and Shoryuken integrations
+  | [#620](https://github.com/bugsnag/bugsnag-ruby/pull/620)
+
+* Reduce the size of the bundled gem
+  | [#571](https://github.com/bugsnag/bugsnag-ruby/pull/571)
+  | [t-richards](https://github.com/t-richards)
+
+* Move serialization of Reports onto the background thread when using the thread_queue delivery method
+  | [#623](https://github.com/bugsnag/bugsnag-ruby/pull/623)
+
+## Fixes
+
+* The `app_type` configuration option should no longer be overwritten by Bugsnag and integrations should set this more consistently
+  | [#619](https://github.com/bugsnag/bugsnag-ruby/pull/619)
+
+## 6.15.0 (27 July 2020)
+
+### Enhancements
+
+* Add `on_error` callbacks to replace `before_notify_callbacks`
+  | [#608](https://github.com/bugsnag/bugsnag-ruby/pull/608)
+
+* Improve performance when extracting code from files in stacktraces
+  | [#604](https://github.com/bugsnag/bugsnag-ruby/pull/604)
+
+* Reduce memory use when session tracking is disabled
+  | [#606](https://github.com/bugsnag/bugsnag-ruby/pull/606)
+
+### Deprecated
+
+* `before_notify_callbacks` have been deprecated in favour of `on_error` and will be removed in the next major release
+
 ## 6.14.0 (20 July 2020)
 
 ### Enhancements

data/VERSION

@@ -1 +1 @@
-6.14.0
+6.19.0

data/bugsnag.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/bugsnag/bugsnag-ruby"
   s.licenses = ["MIT"]
 
-  s.files = `git ls-files`.split("\n").reject {|file| file.start_with? "example/"}
+  s.files = `git ls-files -z lib bugsnag.gemspec VERSION .yardopts`.split("\x0")
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md",

data/lib/bugsnag.rb

@@ -25,7 +25,6 @@ require "bugsnag/middleware/rails3_request"
 require "bugsnag/middleware/sidekiq"
 require "bugsnag/middleware/mailman"
 require "bugsnag/middleware/rake"
-require "bugsnag/middleware/callbacks"
 require "bugsnag/middleware/classify_error"
 require "bugsnag/middleware/delayed_job"
 
@@ -44,10 +43,19 @@ module Bugsnag
     ##
     # Configure the Bugsnag notifier application-wide settings.
     #
-    # Yields a configuration object to use to set application settings.
+    # Yields a {Configuration} object to use to set application settings.
+    #
+    # @yieldparam configuration [Configuration]
+    # @return [void]
     def configure(validate_api_key=true)
       yield(configuration) if block_given?
 
+      # Create the session tracker if sessions are enabled to avoid the overhead
+      # of creating it on the first request. We skip this if we're not validating
+      # the API key as we use this internally before the user's configure block
+      # has run, so we don't know if sessions are enabled yet.
+      session_tracker if validate_api_key && configuration.auto_capture_sessions
+
       check_key_valid if validate_api_key
       check_endpoint_setup
 
@@ -119,13 +127,17 @@ module Bugsnag
     end
 
     ##
-    # Registers an at_exit function to automatically catch errors on exit
+    # Registers an at_exit function to automatically catch errors on exit.
+    #
+    # @return [void]
     def register_at_exit
       return if at_exit_handler_installed?
       @exit_handler_added = true
       at_exit do
         if $!
-          Bugsnag.notify($!, true) do |report|
+          exception = unwrap_bundler_exception($!)
+
+          Bugsnag.notify(exception, true) do |report|
             report.severity = 'error'
             report.severity_reason = {
               :type => Bugsnag::Report::UNHANDLED_EXCEPTION
@@ -136,14 +148,19 @@ module Bugsnag
     end
 
     ##
-    # Checks if an at_exit handler has been added
+    # Checks if an at_exit handler has been added.
+    #
+    # The {Bugsnag#configure} method will add this automatically, but it can be
+    # added manually using {Bugsnag#register_at_exit}.
+    #
+    # @return [Boolean]
     def at_exit_handler_installed?
       @exit_handler_added ||= false
     end
 
-    # Configuration getters
     ##
     # Returns the client's Configuration object, or creates one if not yet created.
+    #
     # @return [Configuration]
     def configuration
       @configuration = nil unless defined?(@configuration)
@@ -152,6 +169,8 @@ module Bugsnag
 
     ##
     # Returns the client's SessionTracker object, or creates one if not yet created.
+    #
+    # @return [SessionTracker]
     def session_tracker
       @session_tracker = nil unless defined?(@session_tracker)
       @session_tracker || LOCK.synchronize { @session_tracker ||= Bugsnag::SessionTracker.new}
@@ -169,11 +188,16 @@ module Bugsnag
     # Allow access to "before notify" callbacks as an array.
     #
     # These callbacks will be called whenever an error notification is being made.
+    #
+    # @deprecated Use {Bugsnag#add_on_error} instead
     def before_notify_callbacks
       Bugsnag.configuration.request_data[:before_callbacks] ||= []
     end
 
-    # Attempts to load all integrations through auto-discovery
+    ##
+    # Attempts to load all integrations through auto-discovery.
+    #
+    # @return [void]
     def load_integrations
       require "bugsnag/integrations/railtie" if defined?(Rails::Railtie)
       INTEGRATIONS.each do |integration|
@@ -184,7 +208,11 @@ module Bugsnag
       end
     end
 
-    # Load a specific integration
+    ##
+    # Load a specific integration.
+    #
+    # @param integration [Symbol] One of the integrations in {INTEGRATIONS}
+    # @return [void]
     def load_integration(integration)
       integration = :railtie if integration == :rails
       if INTEGRATIONS.include?(integration) || integration == :railtie
@@ -201,6 +229,7 @@ module Bugsnag
     # @param meta_data [Hash] String, Numeric, or Boolean meta data to attach
     # @param type [String] the breadcrumb type, from Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES
     # @param auto [Symbol] set to :auto if the breadcrumb is automatically created
+    # @return [void]
     def leave_breadcrumb(name, meta_data={}, type=Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE, auto=:manual)
       breadcrumb = Bugsnag::Breadcrumbs::Breadcrumb.new(name, type, meta_data, auto)
       validator = Bugsnag::Breadcrumbs::Validator.new(configuration)
@@ -227,6 +256,33 @@ module Bugsnag
       configuration.breadcrumbs << breadcrumb unless breadcrumb.ignore?
     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)
+      configuration.add_on_error(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
+    # {Bugsnag#add_on_error}, otherwise it will not be removed
+    #
+    # @param callback [Proc]
+    # @return [void]
+    def remove_on_error(callback)
+      configuration.remove_on_error(callback)
+    end
+
     ##
     # Returns the client's Cleaner object, or creates one if not yet created.
     #
@@ -268,15 +324,25 @@ module Bugsnag
     def deliver_notification(report)
       configuration.info("Notifying #{configuration.notify_endpoint} of #{report.exceptions.last[:errorClass]}")
 
-      payload = report_to_json(report)
-      options = {:headers => report.headers}
+      options = { headers: report.headers }
 
-      Bugsnag::Delivery[configuration.delivery_method].deliver(
-        configuration.notify_endpoint,
-        payload,
-        configuration,
-        options
-      )
+      delivery_method = Bugsnag::Delivery[configuration.delivery_method]
+
+      if delivery_method.respond_to?(:serialize_and_deliver)
+        delivery_method.serialize_and_deliver(
+          configuration.notify_endpoint,
+          proc { report_to_json(report) },
+          configuration,
+          options
+        )
+      else
+        delivery_method.deliver(
+          configuration.notify_endpoint,
+          report_to_json(report),
+          configuration,
+          options
+        )
+      end
 
       leave_breadcrumb(
         report.summary[:error_class],
@@ -318,13 +384,46 @@ module Bugsnag
     # encoding errors and redacting metadata according to "meta_data_filters"
     #
     # @param report [Report]
-    # @return string
+    # @return [String]
     def report_to_json(report)
       cleaned = cleaner.clean_object(report.as_json)
       trimmed = Bugsnag::Helpers.trim_if_needed(cleaned)
 
       ::JSON.dump(trimmed)
     end
+
+    ##
+    # When running a script with 'bundle exec', uncaught exceptions will be
+    # converted to "friendly errors" which has the side effect of wrapping them
+    # in a SystemExit
+    #
+    # By default we ignore SystemExit, so need to unwrap the original exception
+    # in order to avoid ignoring real errors
+    #
+    # @param exception [Exception]
+    # @return [Exception]
+    def unwrap_bundler_exception(exception)
+      running_in_bundler = ENV.include?('BUNDLE_BIN_PATH')
+
+      # See if this exception came from Bundler's 'with_friendly_errors' method
+      return exception unless running_in_bundler
+      return exception unless exception.is_a?(SystemExit)
+      return exception unless exception.respond_to?(:cause)
+      return exception unless exception.backtrace.first.include?('/bundler/friendly_errors.rb')
+      return exception if exception.cause.nil?
+
+      unwrapped = exception.cause
+
+      # We may need to unwrap another level if the exception came from running
+      # an executable file directly (i.e. 'bundle exec <file>'). In this case
+      # there can be a SystemExit from 'with_friendly_errors' _and_ a SystemExit
+      # from 'kernel_load'
+      return unwrapped unless unwrapped.is_a?(SystemExit)
+      return unwrapped unless unwrapped.backtrace.first.include?('/bundler/cli/exec.rb')
+      return unwrapped if unwrapped.cause.nil?
+
+      unwrapped.cause
+    end
   end
 end
 # rubocop:enable Metrics/ModuleLength

data/lib/bugsnag/breadcrumbs/breadcrumb.rb

@@ -69,7 +69,7 @@ module Bugsnag::Breadcrumbs
         :name => @name,
         :type => @type,
         :metaData => @meta_data,
-        :timestamp => @timestamp.iso8601
+        :timestamp => @timestamp.iso8601(3)
       }
     end
   end

data/lib/bugsnag/breadcrumbs/validator.rb

@@ -15,16 +15,6 @@ module Bugsnag::Breadcrumbs
     #
     # @param breadcrumb [Bugsnag::Breadcrumbs::Breadcrumb] the breadcrumb to be validated
     def validate(breadcrumb)
-      # Check meta_data hash doesn't contain complex values
-      breadcrumb.meta_data = breadcrumb.meta_data.select do |k, v|
-        if valid_meta_data_type?(v)
-          true
-        else
-          @configuration.debug("Breadcrumb #{breadcrumb.name} meta_data #{k}:#{v.class} has been dropped for having an invalid data type")
-          false
-        end
-      end
-
       # Check type is valid, set to manual otherwise
       unless Bugsnag::Breadcrumbs::VALID_BREADCRUMB_TYPES.include?(breadcrumb.type)
         @configuration.debug("Invalid type: #{breadcrumb.type} for breadcrumb: #{breadcrumb.name}, defaulting to #{Bugsnag::Breadcrumbs::MANUAL_BREADCRUMB_TYPE}")
@@ -37,17 +27,5 @@ module Bugsnag::Breadcrumbs
       @configuration.debug("Automatic breadcrumb of type #{breadcrumb.type} ignored: #{breadcrumb.name}")
       breadcrumb.ignore!
     end
-
-    private
-
-    ##
-    # Tests whether the meta_data types are non-complex objects.
-    #
-    # Acceptable types are String, Symbol, Numeric, TrueClass, FalseClass, and nil.
-    #
-    # @param value [Object] the object to be type checked
-    def valid_meta_data_type?(value)
-      value.nil? || value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value.is_a?(FalseClass) || value.is_a?(TrueClass)
-    end
   end
 end

data/lib/bugsnag/code_extractor.rb

@@ -0,0 +1,137 @@
+module Bugsnag
+  # @api private
+  class CodeExtractor
+    MAXIMUM_LINES_TO_KEEP = 7
+
+    ##
+    # @param configuration [Configuration]
+    def initialize(configuration)
+      @files = {}
+      @configuration = configuration
+    end
+
+    ##
+    # Add a file and its corresponding trace hash to be processed.
+    #
+    # @param path [String] The full path to the file
+    # @param trace [Hash]
+    # @return [void]
+    def add_file(path, trace)
+      # If the file doesn't exist we can't extract code from it, so we can skip
+      # this file entirely
+      unless File.exist?(path)
+        trace[:code] = nil
+
+        return
+      end
+
+      @files[path] ||= []
+      @files[path].push(trace)
+
+      # Record the line numbers we want to fetch for this trace
+      # We grab extra lines so that we can compensate if the error is on the
+      # first or last line of a file
+      first_line_number = trace[:lineNumber] - MAXIMUM_LINES_TO_KEEP
+
+      trace[:first_line_number] = first_line_number < 1 ? 1 : first_line_number
+      trace[:last_line_number] = trace[:lineNumber] + MAXIMUM_LINES_TO_KEEP
+    end
+
+    ##
+    # Add the code to the hashes that were given in {#add_file} by modifying
+    # them in-place. They will have a new ':code' key containing a hash of line
+    # number => string of code for that line
+    #
+    # @return [void]
+    def extract!
+      @files.each do |path, traces|
+        begin
+          line_numbers = Set.new
+
+          traces.each do |trace|
+            trace[:first_line_number].upto(trace[:last_line_number]) do |line_number|
+              line_numbers << line_number
+            end
+          end
+
+          extract_from(path, traces, line_numbers)
+        rescue StandardError => e
+          # Clean up after ourselves
+          traces.each do |trace|
+            trace[:code] ||= nil
+            trace.delete(:first_line_number)
+            trace.delete(:last_line_number)
+          end
+
+          @configuration.warn("Error extracting code: #{e.inspect}")
+        end
+      end
+    end
+
+    private
+
+    ##
+    # @param path [String]
+    # @param traces [Array<Hash>]
+    # @param line_numbers [Set<Integer>]
+    # @return [void]
+    def extract_from(path, traces, line_numbers)
+      code = {}
+
+      File.open(path) do |file|
+        current_line_number = 0
+
+        file.each_line do |line|
+          current_line_number += 1
+
+          next unless line_numbers.include?(current_line_number)
+
+          code[current_line_number] = line[0...200].rstrip
+        end
+      end
+
+      associate_code_with_trace(code, traces)
+    end
+
+    ##
+    # @param code [Hash{Integer => String}]
+    # @param traces [Array<Hash>]
+    # @return [void]
+    def associate_code_with_trace(code, traces)
+      traces.each do |trace|
+        trace[:code] = {}
+
+        code.each do |line_number, line|
+          # If we've gone past the last line we care about, we can stop iterating
+          break if line_number > trace[:last_line_number]
+
+          # Skip lines that aren't in the range we want
+          next unless line_number >= trace[:first_line_number]
+
+          trace[:code][line_number] = line
+        end
+
+        trim_excess_lines(trace[:code], trace[:lineNumber])
+        trace.delete(:first_line_number)
+        trace.delete(:last_line_number)
+      end
+    end
+
+    ##
+    # @param code [Hash{Integer => String}]
+    # @param line_number [Integer]
+    # @return [void]
+    def trim_excess_lines(code, line_number)
+      while code.length > MAXIMUM_LINES_TO_KEEP
+        last_line = code.keys.max
+        first_line = code.keys.min
+
+        if (last_line - line_number) > (line_number - first_line)
+          code.delete(last_line)
+        else
+          code.delete(first_line)
+        end
+      end
+    end
+  end
+end