bugsnag 6.15.0 → 6.27.1

data/lib/bugsnag/report.rb

@@ -1,9 +1,12 @@
-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"
@@ -19,53 +22,160 @@ module Bugsnag
 
     CURRENT_PAYLOAD_VERSION = "4.0"
 
-    attr_reader   :unhandled
+    # Whether this report is for a handled or unhandled error
+    # @return [Boolean]
+    attr_reader :unhandled
+
+    # Your Integration API Key
+    # @see Configuration#api_key
+    # @return [String, nil]
     attr_accessor :api_key
+
+    # The type of application executing the current code
+    # @see Configuration#app_type
+    # @return [String, nil]
     attr_accessor :app_type
+
+    # The current version of your application
+    # @return [String, nil]
     attr_accessor :app_version
+
+    # The list of breadcrumbs attached to this report
+    # @return [Array<Breadcrumb>]
     attr_accessor :breadcrumbs
+
+    # @api private
+    # @return [Configuration]
     attr_accessor :configuration
-    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
+
+    # @see Configuration#hostname
+    # @return [String]
     attr_accessor :hostname
+
+    # @api private
+    # @see Configuration#runtime_versions
+    # @return [Hash{String => String}]
     attr_accessor :runtime_versions
+
+    # All errors with the same grouping hash will be grouped in the Bugsnag app
+    # @return [String]
     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
+
+    # The current stage of the release process, e.g. 'development', production'
+    # @see Configuration#release_stage
+    # @return [String, nil]
     attr_accessor :release_stage
+
+    # The session that active when this report was generated
+    # @see SessionTracker#get_current_session
+    # @return [Hash]
     attr_accessor :session
+
+    # The severity of this report, e.g. 'error', 'warning'
+    # @return [String]
     attr_accessor :severity
+
+    # @api private
+    # @return [Hash]
     attr_accessor :severity_reason
+
+    # The current user when this report was generated
+    # @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.
+    #
+    # @param name [String, #to_s] The name of the tab to add
+    # @param value [Hash, Object] The value to add to the tab. If the tab already
+    #   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?
 
@@ -81,6 +191,11 @@ module Bugsnag
 
     ##
     # Removes a metadata tab from this notification.
+    #
+    # @param name [String]
+    # @return [void]
+    #
+    # @deprecated Use {#clear_metadata} instead
     def remove_tab(name)
       return if name.nil?
 
@@ -89,6 +204,8 @@ module Bugsnag
 
     ##
     # Builds and returns the exception payload for this notification.
+    #
+    # @return [Hash]
     def as_json
       # Build the payload's exception event
       payload_event = {
@@ -101,9 +218,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,
@@ -123,34 +242,43 @@ module Bugsnag
           :version => NOTIFIER_VERSION,
           :url => NOTIFIER_URL
         },
+        :payloadVersion => CURRENT_PAYLOAD_VERSION,
         :events => [payload_event]
       }
     end
 
     ##
     # Returns the headers required for the notification.
+    #
+    # @return [Hash{String => String}]
     def headers
       {
         "Bugsnag-Api-Key" => api_key,
         "Bugsnag-Payload-Version" => CURRENT_PAYLOAD_VERSION,
-        "Bugsnag-Sent-At" => Time.now().utc().strftime('%Y-%m-%dT%H:%M:%S')
+        "Bugsnag-Sent-At" => Time.now.utc.iso8601(3)
       }
     end
 
     ##
     # Whether this report should be ignored and not sent.
+    #
+    # @return [Boolean]
     def ignore?
       @should_ignore
     end
 
     ##
     # Data set on the configuration to be attached to every error notification.
+    #
+    # @return [Hash]
     def request_data
       configuration.request_data
     end
 
     ##
     # Tells the client this report should not be sent.
+    #
+    # @return [void]
     def ignore!
       @should_ignore = true
     end
@@ -175,24 +303,179 @@ 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
+
+      # the string returned by 'detailed_message' defaults to 'ASCII_8BIT' but
+      # is actually UTF-8 encoded; we can't convert the encoding normally as its
+      # internal encoding doesn't match its actual encoding
+      message.force_encoding(::Encoding::UTF_8) if message.encoding == ::Encoding::ASCII_8BIT
+
+      # remove the class name to be consistent with Exception#message
+      message.sub!(" (#{class_name})".encode(message.encoding), "") rescue nil
+
+      message
+    end
+
     def generate_raw_exceptions(exception)
       exceptions = []
 
@@ -229,4 +512,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

@@ -3,7 +3,7 @@ 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 `([^']+)')?$/
+    BACKTRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in [`']([^']+)')?$/
 
     # e.g. "org.jruby.Ruby.runScript(Ruby.java:807)"
     JAVA_BACKTRACE_REGEX = /^(.*)\((.*)(?::([0-9]+))?\)$/
@@ -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