bugsnag 6.15.0 → 6.27.1

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

data/lib/bugsnag/utility/feature_flag_delegate.rb

@@ -0,0 +1,89 @@
+module Bugsnag::Utility
+  # @api private
+  class FeatureFlagDelegate
+    def initialize
+      # feature flags are stored internally in a hash of "name" => <FeatureFlag>
+      # we don't use a Set because new feature flags should overwrite old ones
+      # that share a name, but FeatureFlag equality also uses the variant
+      @storage = {}
+    end
+
+    def initialize_dup(original)
+      super
+
+      # copy the internal storage when 'dup' is called
+      @storage = @storage.dup
+    end
+
+    # Add a feature flag with the given name & variant
+    #
+    # @param name [String]
+    # @param variant [String, nil]
+    # @return [void]
+    def add(name, variant)
+      flag = Bugsnag::FeatureFlag.new(name, variant)
+
+      return unless flag.valid?
+
+      @storage[flag.name] = flag
+    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 merge(feature_flags)
+      feature_flags.each do |flag|
+        next unless flag.is_a?(Bugsnag::FeatureFlag)
+        next unless flag.valid?
+
+        @storage[flag.name] = flag
+      end
+    end
+
+    # Remove the stored flag with the given name
+    #
+    # @param name [String]
+    # @return [void]
+    def remove(name)
+      @storage.delete(name)
+    end
+
+    # Remove all the stored flags
+    #
+    # @return [void]
+    def clear
+      @storage.clear
+    end
+
+    # Get an array of FeatureFlag instances
+    #
+    # @example
+    #   [
+    #     <#Bugsnag::FeatureFlag>,
+    #     <#Bugsnag::FeatureFlag>,
+    #   ]
+    #
+    # @return [Array<Bugsnag::FeatureFlag>]
+    def to_a
+      @storage.values
+    end
+
+    # Get the feature flags in their JSON representation
+    #
+    # @example
+    #   [
+    #     { "featureFlag" => "name", "variant" => "variant" },
+    #     { "featureFlag" => "another name" },
+    #   ]
+    #
+    # @return [Array<Hash{String => String}>]
+    def as_json
+      to_a.map(&:to_h)
+    end
+  end
+end

data/lib/bugsnag/utility/metadata_delegate.rb

@@ -0,0 +1,102 @@
+module Bugsnag::Utility
+  # @api private
+  class MetadataDelegate
+    # nil is a valid metadata value, so we need a sentinel object so we can tell
+    # if the value parameter has been provided
+    NOT_PROVIDED = Object.new
+
+    ##
+    # Add values to metadata
+    #
+    # @overload add_metadata(metadata, section, data)
+    #   Merges data into the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param data [Hash]
+    #
+    # @overload add_metadata(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 metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #   @param value
+    #
+    # @return [void]
+    def add_metadata(metadata, section, key_or_data, value = NOT_PROVIDED)
+      case value
+      when NOT_PROVIDED
+        merge_metadata(metadata, section, key_or_data)
+      when nil
+        clear_metadata(metadata, section, key_or_data)
+      else
+        overwrite_metadata(metadata, section, key_or_data, value)
+      end
+    end
+
+    ##
+    # Clear values from metadata
+    #
+    # @overload clear_metadata(metadata, section)
+    #   Clears the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #
+    # @overload clear_metadata(metadata, section, key)
+    #   Clears the key in the given section of metadata
+    #   @param metadata [Hash] The metadata hash to operate on
+    #   @param section [String, Symbol]
+    #   @param key [String, Symbol]
+    #
+    # @return [void]
+    def clear_metadata(metadata, section, key = nil)
+      if key.nil?
+        metadata.delete(section)
+      elsif metadata[section]
+        metadata[section].delete(key)
+      end
+    end
+
+    private
+
+    ##
+    # Merge new metadata into the existing metadata
+    #
+    # Any keys with a 'nil' value in the new metadata will be deleted from the
+    # existing metadata
+    #
+    # @param existing_metadata [Hash]
+    # @param section [String, Symbol]
+    # @param new_metadata [Hash]
+    # @return [void]
+    def merge_metadata(existing_metadata, section, new_metadata)
+      return unless new_metadata.is_a?(Hash)
+
+      existing_metadata[section] ||= {}
+      data = existing_metadata[section]
+
+      new_metadata.each do |key, value|
+        if value.nil?
+          data.delete(key)
+        else
+          data[key] = value
+        end
+      end
+    end
+
+    ##
+    # Overwrite the value in metadata's section & key
+    #
+    # @param metadata [Hash]
+    # @param section [String, Symbol]
+    # @param key [String, Symbol]
+    # @param value
+    # @return [void]
+    def overwrite_metadata(metadata, section, key, value)
+      return unless key.is_a?(String) || key.is_a?(Symbol)
+
+      metadata[section] ||= {}
+      metadata[section][key] = value
+    end
+  end
+end

data/lib/bugsnag.rb

@@ -1,10 +1,17 @@
 require "rubygems"
 require "thread"
+require "set"
+require "json"
+require "uri"
+require "socket"
+require "logger"
 
 require "bugsnag/version"
+require "bugsnag/utility/feature_data_store"
 require "bugsnag/configuration"
 require "bugsnag/meta_data"
 require "bugsnag/report"
+require "bugsnag/event"
 require "bugsnag/cleaner"
 require "bugsnag/helpers"
 require "bugsnag/session_tracker"
@@ -13,25 +20,19 @@ require "bugsnag/delivery"
 require "bugsnag/delivery/synchronous"
 require "bugsnag/delivery/thread_queue"
 
+require "bugsnag/feature_flag"
+
 # Rack is not bundled with the other integrations
 # as it doesn't auto-configure when loaded
 require "bugsnag/integrations/rack"
 
-require "bugsnag/middleware/rack_request"
-require "bugsnag/middleware/warden_user"
-require "bugsnag/middleware/clearance_user"
-require "bugsnag/middleware/callbacks"
-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"
-
+require "bugsnag/breadcrumb_type"
 require "bugsnag/breadcrumbs/validator"
 require "bugsnag/breadcrumbs/breadcrumb"
-require "bugsnag/breadcrumbs/breadcrumbs"
+
+require "bugsnag/utility/duplicator"
+require "bugsnag/utility/metadata_delegate"
+require "bugsnag/utility/feature_flag_delegate"
 
 # rubocop:todo Metrics/ModuleLength
 module Bugsnag
@@ -41,10 +42,15 @@ module Bugsnag
   NIL_EXCEPTION_DESCRIPTION = "'nil' was notified as an exception"
 
   class << self
+    include Utility::FeatureDataStore
+
     ##
     # 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?
 
@@ -65,7 +71,7 @@ module Bugsnag
     #
     # Optionally accepts a block to append metadata to the yielded report.
     def notify(exception, auto_notify=false, &block)
-      unless auto_notify.is_a? TrueClass or auto_notify.is_a? FalseClass
+      unless false.equal? auto_notify or true.equal? auto_notify
         configuration.warn("Adding metadata/severity using a hash is no longer supported, please use block syntax instead")
         auto_notify = false
       end
@@ -77,7 +83,12 @@ module Bugsnag
       report = Report.new(exception, configuration, auto_notify)
 
       # If this is an auto_notify we yield the block before the any middleware is run
-      yield(report) if block_given? && auto_notify
+      begin
+        yield(report) if block_given? && auto_notify
+      rescue StandardError => e
+        configuration.warn("Error in internal notify block: #{e}")
+        configuration.warn("Error in internal notify block stacktrace: #{e.backtrace.inspect}")
+      end
 
       if report.ignore?
         configuration.debug("Not notifying #{report.exceptions.last[:errorClass]} due to ignore being signified in auto_notify block")
@@ -104,7 +115,12 @@ module Bugsnag
 
         # If this is not an auto_notify then the block was provided by the user. This should be the last
         # block that is run as it is the users "most specific" block.
-        yield(report) if block_given? && !auto_notify
+        begin
+          yield(report) if block_given? && !auto_notify
+        rescue StandardError => e
+          configuration.warn("Error in notify block: #{e}")
+          configuration.warn("Error in notify block stacktrace: #{e.backtrace.inspect}")
+        end
 
         if report.ignore?
           configuration.debug("Not notifying #{report.exceptions.last[:errorClass]} due to ignore being signified in user provided block")
@@ -120,18 +136,27 @@ module Bugsnag
           report.severity_reason = initial_reason
         end
 
+        if report.unhandled_overridden?
+          # let the dashboard know that the unhandled flag was overridden
+          report.severity_reason[:unhandledOverridden] = true
+        end
+
         deliver_notification(report)
       end
     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
@@ -142,14 +167,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)
@@ -158,19 +188,44 @@ 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}
     end
 
     ##
-    # Starts a session.
+    # Starts a new session, which allows Bugsnag to track error rates across
+    # releases
     #
-    # Allows Bugsnag to track error rates across releases.
+    # @return [void]
     def start_session
       session_tracker.start_session
     end
 
+    ##
+    # 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
+      session_tracker.pause_session
+    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
+      session_tracker.resume_session
+    end
+
     ##
     # Allow access to "before notify" callbacks as an array.
     #
@@ -181,7 +236,10 @@ module Bugsnag
       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|
@@ -192,7 +250,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
@@ -207,8 +269,9 @@ module Bugsnag
     #
     # @param name [String] the main breadcrumb name/message
     # @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 type [String] the breadcrumb type, see {Bugsnag::BreadcrumbType}
     # @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)
@@ -219,7 +282,7 @@ module Bugsnag
       # Skip if it's already invalid
       return if breadcrumb.ignore?
 
-      # Run callbacks
+      # Run before_breadcrumb_callbacks
       configuration.before_breadcrumb_callbacks.each do |c|
         c.arity > 0 ? c.call(breadcrumb) : c.call
         break if breadcrumb.ignore?
@@ -228,6 +291,10 @@ module Bugsnag
       # Return early if ignored
       return if breadcrumb.ignore?
 
+      # Run on_breadcrumb callbacks
+      configuration.on_breadcrumb_callbacks.call(breadcrumb)
+      return if breadcrumb.ignore?
+
       # Validate again in case of callback alteration
       validator.validate(breadcrumb)
 
@@ -235,6 +302,20 @@ module Bugsnag
       configuration.breadcrumbs << breadcrumb unless breadcrumb.ignore?
     end
 
+    ##
+    # Add the given block 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
+    #
+    # @return [void]
+    def on_error(&block)
+      configuration.on_error(&block)
+    end
+
     ##
     # Add the given callback to the list of on_error callbacks
     #
@@ -244,7 +325,7 @@ module Bugsnag
     # 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]
+    # @param callback [Proc, Method, #call]
     # @return [void]
     def add_on_error(callback)
       configuration.add_on_error(callback)
@@ -262,6 +343,44 @@ module Bugsnag
       configuration.remove_on_error(callback)
     end
 
+    ##
+    # Add the given callback to the list of on_breadcrumb callbacks
+    #
+    # The on_breadcrumb callbacks will be called when a breadcrumb is left and
+    # are passed the {Breadcrumbs::Breadcrumb Breadcrumb} object
+    #
+    # Returning false from an on_breadcrumb callback will cause the breadcrumb
+    # to be ignored and will prevent any remaining callbacks from being called
+    #
+    # @param callback [Proc, Method, #call]
+    # @return [void]
+    def add_on_breadcrumb(callback)
+      configuration.add_on_breadcrumb(callback)
+    end
+
+    ##
+    # Remove the given callback from the list of on_breadcrumb callbacks
+    #
+    # Note that this must be the same instance that was passed to
+    # {add_on_breadcrumb}, otherwise it will not be removed
+    #
+    # @param callback [Proc, Method, #call]
+    # @return [void]
+    def remove_on_breadcrumb(callback)
+      configuration.remove_on_breadcrumb(callback)
+    end
+
+    ##
+    # Returns the current list of breadcrumbs
+    #
+    # This is a per-thread circular buffer, containing at most 'max_breadcrumbs'
+    # breadcrumbs
+    #
+    # @return [Bugsnag::Utility::CircularBuffer]
+    def breadcrumbs
+      configuration.breadcrumbs
+    end
+
     ##
     # Returns the client's Cleaner object, or creates one if not yet created.
     #
@@ -275,9 +394,66 @@ module Bugsnag
       end
     end
 
+    ##
+    # Global metadata added to every event
+    #
+    # @return [Hash]
+    def metadata
+      configuration.metadata
+    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)
+      configuration.add_metadata(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)
+      configuration.clear_metadata(section, *args)
+    end
+
+    # Expose the feature flag delegate internally for use when creating new Events
+    #
+    # The Bugsnag module's feature_flag_delegate is request-specific
+    #
+    # @return [Bugsnag::Utility::FeatureFlagDelegate]
+    # @api private
+    def feature_flag_delegate
+      configuration.request_data[:feature_flag_delegate] ||= Utility::FeatureFlagDelegate.new
+    end
+
     private
 
     def should_deliver_notification?(exception, auto_notify)
+      return false unless configuration.enable_events
+
       reason = abort_reason(exception, auto_notify)
       configuration.debug(reason) unless reason.nil?
       reason.nil?
@@ -303,15 +479,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],
@@ -353,13 +539,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