bugsnag 6.19.0 → 6.26.0

data/lib/bugsnag/report.rb

@@ -1,9 +1,13 @@
 require "json"
 require "pathname"
+require "bugsnag/error"
 require "bugsnag/stacktrace"
 
 module Bugsnag
+  # rubocop:todo Metrics/ClassLength
   class Report
+    include Utility::FeatureDataStore
+
     NOTIFIER_NAME = "Ruby Bugsnag Notifier"
     NOTIFIER_VERSION = Bugsnag::VERSION
     NOTIFIER_URL = "https://www.bugsnag.com"
@@ -45,16 +49,13 @@ module Bugsnag
     # @return [Configuration]
     attr_accessor :configuration
 
-    # Additional context for this report
-    # @return [String, nil]
-    attr_accessor :context
-
     # The delivery method that will be used for this report
     # @see Configuration#delivery_method
     # @return [Symbol]
     attr_accessor :delivery_method
 
     # The list of exceptions in this report
+    # @deprecated Use {#errors} instead
     # @return [Array<Hash>]
     attr_accessor :exceptions
 
@@ -72,10 +73,12 @@ module Bugsnag
     attr_accessor :grouping_hash
 
     # Arbitrary metadata attached to this report
+    # @deprecated Use {#metadata} instead
     # @return [Hash]
     attr_accessor :meta_data
 
     # The raw Exception instances for this report
+    # @deprecated Use {#original_error} instead
     # @see #exceptions
     # @return [Array<Exception>]
     attr_accessor :raw_exceptions
@@ -102,31 +105,68 @@ module Bugsnag
     # @return [Hash]
     attr_accessor :user
 
+    # A list of errors in this report
+    # @return [Array<Error>]
+    attr_reader :errors
+
+    # The Exception instance this report was created for
+    # @return [Exception]
+    attr_reader :original_error
+
     ##
     # Initializes a new report from an exception.
     def initialize(exception, passed_configuration, auto_notify=false)
+      # store the creation time for use as device.time
+      @created_at = Time.now.utc.iso8601(3)
+
       @should_ignore = false
       @unhandled = auto_notify
+      @initial_unhandled = @unhandled
 
       self.configuration = passed_configuration
 
+      @original_error = exception
       self.raw_exceptions = generate_raw_exceptions(exception)
       self.exceptions = generate_exception_list
+      @errors = generate_error_list
 
       self.api_key = configuration.api_key
       self.app_type = configuration.app_type
       self.app_version = configuration.app_version
       self.breadcrumbs = []
+      self.context = configuration.context if configuration.context_set?
       self.delivery_method = configuration.delivery_method
       self.hostname = configuration.hostname
       self.runtime_versions = configuration.runtime_versions.dup
-      self.meta_data = {}
+      self.meta_data = Utility::Duplicator.duplicate(configuration.metadata)
       self.release_stage = configuration.release_stage
       self.severity = auto_notify ? "error" : "warning"
       self.severity_reason = auto_notify ? {:type => UNHANDLED_EXCEPTION} : {:type => HANDLED_EXCEPTION}
       self.user = {}
+
+      @metadata_delegate = Utility::MetadataDelegate.new
+      @feature_flag_delegate = Bugsnag.feature_flag_delegate.dup
     end
 
+    ##
+    # Additional context for this report
+    # @!attribute context
+    # @return [String, nil]
+    def context
+      return @context if defined?(@context)
+
+      @automatic_context
+    end
+
+    attr_writer :context
+
+    ##
+    # Context set automatically by Bugsnag uses this attribute, which prevents
+    # it from overwriting the user-supplied context
+    # @api private
+    # @return [String, nil]
+    attr_accessor :automatic_context
+
     ##
     # Add a new metadata tab to this notification.
     #
@@ -135,6 +175,8 @@ module Bugsnag
     #   exists, this will be merged with the existing values. If a Hash is not
     #   given, the value will be placed into the 'custom' tab
     # @return [void]
+    #
+    # @deprecated Use {#add_metadata} instead
     def add_tab(name, value)
       return if name.nil?
 
@@ -153,6 +195,8 @@ module Bugsnag
     #
     # @param name [String]
     # @return [void]
+    #
+    # @deprecated Use {#clear_metadata} instead
     def remove_tab(name)
       return if name.nil?
 
@@ -175,9 +219,11 @@ module Bugsnag
         context: context,
         device: {
           hostname: hostname,
-          runtimeVersions: runtime_versions
+          runtimeVersions: runtime_versions,
+          time: @created_at
         },
         exceptions: exceptions,
+        featureFlags: @feature_flag_delegate.as_json,
         groupingHash: grouping_hash,
         metaData: meta_data,
         session: session,
@@ -197,6 +243,7 @@ module Bugsnag
           :version => NOTIFIER_VERSION,
           :url => NOTIFIER_URL
         },
+        :payloadVersion => CURRENT_PAYLOAD_VERSION,
         :events => [payload_event]
       }
     end
@@ -257,24 +304,172 @@ module Bugsnag
       end
     end
 
+    # A Hash containing arbitrary metadata
+    # @!attribute metadata
+    # @return [Hash]
+    def metadata
+      @meta_data
+    end
+
+    # @param metadata [Hash]
+    # @return [void]
+    def metadata=(metadata)
+      @meta_data = metadata
+    end
+
+    ##
+    # Data from the current HTTP request. May be nil if no data has been recorded
+    #
+    # @return [Hash, nil]
+    def request
+      @meta_data[:request]
+    end
+
+    ##
+    # Add values to metadata
+    #
+    # @overload add_metadata(section, data)
+    #   Merges data into the given section of metadata
+    #   @param section [String, Symbol]
+    #   @param data [Hash]
+    #
+    # @overload add_metadata(section, key, value)
+    #   Sets key to value in the given section of metadata. If the value is nil
+    #   the key will be deleted
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #   @param value
+    #
+    # @return [void]
+    def add_metadata(section, key_or_data, *args)
+      @metadata_delegate.add_metadata(@meta_data, section, key_or_data, *args)
+    end
+
+    ##
+    # Clear values from metadata
+    #
+    # @overload clear_metadata(section)
+    #   Clears the given section of metadata
+    #   @param section [String, Symbol]
+    #
+    # @overload clear_metadata(section, key)
+    #   Clears the key in the given section of metadata
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #
+    # @return [void]
+    def clear_metadata(section, *args)
+      @metadata_delegate.clear_metadata(@meta_data, section, *args)
+    end
+
+    # Get the array of stored feature flags
+    #
+    # @return [Array<Bugsnag::FeatureFlag>]
+    def feature_flags
+      @feature_flag_delegate.to_a
+    end
+
+    ##
+    # Set information about the current user
+    #
+    # Additional user fields can be added as metadata in a "user" section
+    #
+    # Setting a field to 'nil' will remove it from the user data
+    #
+    # @param id [String, nil]
+    # @param email [String, nil]
+    # @param name [String, nil]
+    # @return [void]
+    def set_user(id = nil, email = nil, name = nil)
+      new_user = { id: id, email: email, name: name }
+      new_user.reject! { |key, value| value.nil? }
+
+      @user = new_user
+    end
+
+    def unhandled=(new_unhandled)
+      # fix the handled/unhandled counts in the current session
+      update_handled_counts(new_unhandled, @unhandled)
+
+      @unhandled = new_unhandled
+    end
+
+    ##
+    # Returns true if the unhandled flag has been changed from its initial value
+    #
+    # @api private
+    # @return [Boolean]
+    def unhandled_overridden?
+      @unhandled != @initial_unhandled
+    end
+
     private
 
+    attr_reader :feature_flag_delegate
+
+    def update_handled_counts(is_unhandled, was_unhandled)
+      # do nothing if there is no session to update
+      return if @session.nil?
+
+      # increment the counts for the current unhandled value
+      if is_unhandled
+        @session[:events][:unhandled] += 1
+      else
+        @session[:events][:handled] += 1
+      end
+
+      # decrement the counts for the previous unhandled value
+      if was_unhandled
+        @session[:events][:unhandled] -= 1
+      else
+        @session[:events][:handled] -= 1
+      end
+    end
+
     def generate_exception_list
       raw_exceptions.map do |exception|
+        class_name = error_class(exception)
+
         {
-          errorClass: error_class(exception),
-          message: exception.message,
+          errorClass: class_name,
+          message: error_message(exception, class_name),
           stacktrace: Stacktrace.process(exception.backtrace, configuration)
         }
       end
     end
 
+    def generate_error_list
+      exceptions.map do |exception|
+        Error.new(exception[:errorClass], exception[:message], exception[:stacktrace])
+      end
+    end
+
     def error_class(exception)
       # The "Class" check is for some strange exceptions like Timeout::Error
       # which throw the error class instead of an instance
       (exception.is_a? Class) ? exception.name : exception.class.name
     end
 
+    def error_message(exception, class_name)
+      # Ruby 3.2 added Exception#detailed_message for Gems like "Did you mean"
+      # to annotate an exception's message
+      return exception.message unless exception.respond_to?(:detailed_message)
+
+      # the "highlight" argument may add terminal escape codes to the output,
+      # which we don't want to include
+      # it _should_ always be present but it's possible to forget to add it or
+      # to have implemented this method before Ruby 3.2
+      message =
+        begin
+          exception.detailed_message(highlight: false)
+        rescue ArgumentError
+          exception.detailed_message
+        end
+
+      # remove the class name to be consistent with Exception#message
+      message.sub(" (#{class_name})", '')
+    end
+
     def generate_raw_exceptions(exception)
       exceptions = []
 
@@ -311,4 +506,5 @@ module Bugsnag
       exceptions
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/bugsnag/session_tracker.rb

@@ -34,16 +34,20 @@ module Bugsnag
     # Starts a new session, storing it on the current thread.
     #
     # This allows Bugsnag to track error rates for a release.
+    #
+    # @return [void]
     def start_session
-      return unless Bugsnag.configuration.enable_sessions
+      return unless Bugsnag.configuration.enable_sessions && Bugsnag.configuration.should_notify_release_stage?
+
       start_delivery_thread
       start_time = Time.now().utc().strftime('%Y-%m-%dT%H:%M:00')
       new_session = {
-        :id => SecureRandom.uuid,
-        :startedAt => start_time,
-        :events => {
-          :handled => 0,
-          :unhandled => 0
+        id: SecureRandom.uuid,
+        startedAt: start_time,
+        paused?: false,
+        events: {
+          handled: 0,
+          unhandled: 0
         }
       }
       SessionTracker.set_current_session(new_session)
@@ -52,6 +56,47 @@ module Bugsnag
 
     alias_method :create_session, :start_session
 
+    ##
+    # Stop any events being attributed to the current session until it is
+    # resumed or a new session is started
+    #
+    # @see resume_session
+    #
+    # @return [void]
+    def pause_session
+      current_session = SessionTracker.get_current_session
+
+      return unless current_session
+
+      current_session[:paused?] = true
+    end
+
+    ##
+    # Resume the current session if it was previously paused. If there is no
+    # current session, a new session will be started
+    #
+    # @see pause_session
+    #
+    # @return [Boolean] true if a paused session was resumed
+    def resume_session
+      current_session = SessionTracker.get_current_session
+
+      if current_session
+        # if the session is paused then resume it, otherwise we don't need to
+        # do anything
+        if current_session[:paused?]
+          current_session[:paused?] = false
+
+          return true
+        end
+      else
+        # if there's no current session, start a new one
+        start_session
+      end
+
+      false
+    end
+
     ##
     # Delivers the current session_counts lists to the session endpoint.
     def send_sessions
@@ -83,7 +128,7 @@ module Bugsnag
             end
           end
         end
-        @delivery_thread = Concurrent::TimerTask.execute(execution_interval: 30) do
+        @delivery_thread = Concurrent::TimerTask.execute(execution_interval: 10) do
           if @session_counts.size > 0
             send_sessions
           end
@@ -106,11 +151,6 @@ module Bugsnag
         return
       end
 
-      if !Bugsnag.configuration.should_notify_release_stage?
-        Bugsnag.configuration.debug("Not delivering sessions due to notify_release_stages :#{Bugsnag.configuration.notify_release_stages.inspect}")
-        return
-      end
-
       body = {
         :notifier => {
           :name => Bugsnag::Report::NOTIFIER_NAME,

data/lib/bugsnag/stacktrace.rb

@@ -43,12 +43,14 @@ 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(configuration.vendor_path)
+          trace_hash.delete(:inProject) if vendor_path?(configuration, file)
         end
 
         # Strip common gem path prefixes
         if defined?(Gem)
-          file = Gem.path.inject(file) {|line, path| line.sub(/#{path}\//, "") }
+          Gem.path.each do |path|
+            file.sub!("#{path}/", "")
+          end
         end
 
         trace_hash[:file] = file
@@ -67,5 +69,14 @@ module Bugsnag
 
       processed_backtrace
     end
+
+    # @api private
+    def self.vendor_path?(configuration, file_path)
+      return true if configuration.vendor_path && file_path.match(configuration.vendor_path)
+
+      configuration.vendor_paths.any? do |vendor_path|
+        file_path.start_with?("#{vendor_path.sub(/\/$/, '')}/")
+      end
+    end
   end
 end

data/lib/bugsnag/tasks/bugsnag.rake

@@ -7,7 +7,7 @@ namespace :bugsnag do
       raise RuntimeError.new("Bugsnag test exception")
     rescue => e
       Bugsnag.notify(e) do |report|
-        report.context = "rake#test_exception"
+        report.automatic_context = "rake#test_exception"
       end
     end
   end

data/lib/bugsnag/utility/duplicator.rb

@@ -0,0 +1,124 @@
+module Bugsnag::Utility
+  # @api private
+  class Duplicator
+    class << self
+      ##
+      # Duplicate (deep clone) the given object
+      #
+      # @param object [Object]
+      # @param seen_objects [Hash<String, Object>]
+      # @return [Object]
+      def duplicate(object, seen_objects = {})
+        case object
+        # return immutable & non-duplicatable objects as-is
+        when Symbol, Numeric, Method, TrueClass, FalseClass, NilClass
+          object
+        when Array
+          duplicate_array(object, seen_objects)
+        when Hash
+          duplicate_hash(object, seen_objects)
+        when Range
+          duplicate_range(object, seen_objects)
+        when Struct
+          duplicate_struct(object, seen_objects)
+        else
+          duplicate_generic_object(object, seen_objects)
+        end
+      rescue StandardError
+        object
+      end
+
+      private
+
+      def duplicate_array(array, seen_objects)
+        id = array.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = array.dup
+        seen_objects[id] = copy
+
+        copy.map! do |value|
+          duplicate(value, seen_objects)
+        end
+
+        copy
+      end
+
+      def duplicate_hash(hash, seen_objects)
+        id = hash.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = {}
+        seen_objects[id] = copy
+
+        hash.each do |key, value|
+          copy[duplicate(key, seen_objects)] = duplicate(value, seen_objects)
+        end
+
+        copy
+      end
+
+      ##
+      # Ranges are immutable but the values they contain may not be
+      #
+      # For example, a range of "a".."z" can be mutated: range.first.upcase!
+      def duplicate_range(range, seen_objects)
+        id = range.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        begin
+          copy = range.class.new(
+            duplicate(range.first, seen_objects),
+            duplicate(range.last, seen_objects),
+            range.exclude_end?
+          )
+        rescue StandardError
+          copy = range.dup
+        end
+
+        seen_objects[id] = copy
+      end
+
+      def duplicate_struct(struct, seen_objects)
+        id = struct.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = struct.dup
+        seen_objects[id] = copy
+
+        struct.each_pair do |attribute, value|
+          begin
+            copy.send("#{attribute}=", duplicate(value, seen_objects))
+          rescue StandardError # rubocop:todo Lint/SuppressedException
+          end
+        end
+
+        copy
+      end
+
+      def duplicate_generic_object(object, seen_objects)
+        id = object.object_id
+
+        return seen_objects[id] if seen_objects.key?(id)
+
+        copy = object.dup
+        seen_objects[id] = copy
+
+        begin
+          copy.instance_variables.each do |variable|
+            value = copy.instance_variable_get(variable)
+
+            copy.instance_variable_set(variable, duplicate(value, seen_objects))
+          end
+        rescue StandardError # rubocop:todo Lint/SuppressedException
+        end
+
+        copy
+      end
+    end
+  end
+end

data/lib/bugsnag/utility/feature_data_store.rb

@@ -0,0 +1,41 @@
+module Bugsnag::Utility
+  # @abstract Requires a #feature_flag_delegate method returning a
+  #   {Bugsnag::Utility::FeatureFlagDelegate}
+  module FeatureDataStore
+    # Add a feature flag with the given name & variant
+    #
+    # @param name [String]
+    # @param variant [String, nil]
+    # @return [void]
+    def add_feature_flag(name, variant = nil)
+      feature_flag_delegate.add(name, variant)
+    end
+
+    # Merge the given array of FeatureFlag instances into the stored feature
+    # flags
+    #
+    # New flags will be appended to the array. Flags with the same name will be
+    # overwritten, but their position in the array will not change
+    #
+    # @param feature_flags [Array<Bugsnag::FeatureFlag>]
+    # @return [void]
+    def add_feature_flags(feature_flags)
+      feature_flag_delegate.merge(feature_flags)
+    end
+
+    # Remove the stored flag with the given name
+    #
+    # @param name [String]
+    # @return [void]
+    def clear_feature_flag(name)
+      feature_flag_delegate.remove(name)
+    end
+
+    # Remove all the stored flags
+    #
+    # @return [void]
+    def clear_feature_flags
+      feature_flag_delegate.clear
+    end
+  end
+end