mongo 2.25.0 → 2.26.1

data/lib/mongo/crypt/explicit_encrypter.rb

@@ -37,12 +37,19 @@ module Mongo
       #   to TLS connection options of Mongo::Client.
       # @param [ Integer | nil ] timeout_ms Timeout for every operation executed
       #   on this object.
-      def initialize(key_vault_client, key_vault_namespace, kms_providers, kms_tls_options, timeout_ms = nil)
+      # @param [ Integer | nil ] key_expiration_ms The lifetime of the data
+      #   encryption key cache, in milliseconds. A value of 0 means the cache
+      #   never expires. When nil, libmongocrypt's default of 60000 is used.
+      def initialize(
+        key_vault_client, key_vault_namespace, kms_providers, kms_tls_options,
+        timeout_ms = nil, key_expiration_ms = nil
+      )
         Crypt.validate_ffi!
         @crypt_handle = Handle.new(
           kms_providers,
           kms_tls_options,
-          explicit_encryption_only: true
+          explicit_encryption_only: true,
+          key_expiration_ms: key_expiration_ms
         )
         @encryption_io = EncryptionIO.new(
           key_vault_client: key_vault_client,
@@ -93,23 +100,31 @@ module Mongo
       #   encryption key.
       # @option options [ String ] :algorithm The algorithm used to encrypt the value.
       #   Valid algorithms are "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
-      #   "AEAD_AES_256_CBC_HMAC_SHA_512-Random", "Indexed", "Unindexed".
+      #   "AEAD_AES_256_CBC_HMAC_SHA_512-Random", "Indexed", "Unindexed",
+      #   "Range", "String".
       # @option options [ Integer | nil ] :contention_factor Contention factor
-      #   to be applied if encryption algorithm is set to "Indexed". If not
-      #   provided, it defaults to a value of 0. Contention factor should be set
-      #   only if encryption algorithm is set to "Indexed".
-      # @option options [ String | nil ] query_type Query type to be applied
-      # if encryption algorithm is set to "Indexed". Query type should be set
-      #   only if encryption algorithm is set to "Indexed". The only allowed
-      #   value is "equality".
+      #   to be applied if encryption algorithm is set to "Indexed", "Range", or
+      #   "String". If not provided, it defaults to a value of 0. Contention
+      #   factor should be set only if encryption algorithm is set to "Indexed",
+      #   "Range", or "String".
+      # @option options [ String | nil ] :query_type Query type to be applied
+      #   if encryption algorithm is set to "Indexed", "Range", or "String".
+      #   Allowed values are "equality" (for "Indexed"), "range" (for "Range"),
+      #   and "prefix", "suffix", "substring" (for "String").
+      # @option options [ Hash | nil ] :range_opts Specifies index options for a
+      #   Queryable Encryption field supporting "range" queries. Required when
+      #   algorithm is "Range".
+      # @option options [ Hash | nil ] :string_opts Specifies index options for a
+      #   Queryable Encryption field supporting "prefix", "suffix", or
+      #   "substring" queries. Required when algorithm is "String".
       #
       # @note The :key_id and :key_alt_name options are mutually exclusive. Only
       #   one is required to perform explicit encryption.
       #
       # @return [ BSON::Binary ] A BSON Binary object of subtype 6 (ciphertext)
       #   representing the encrypted value
-      # @raise [ ArgumentError ] if either contention_factor or query_type
-      #   is set, and algorithm is not "Indexed".
+      # @raise [ ArgumentError ] if either contention_factor or query_type is
+      #   set, and algorithm is not "Indexed", "Range", or "String".
       def encrypt(value, options)
         Crypt::ExplicitEncryptionContext.new(
           @crypt_handle,

data/lib/mongo/crypt/explicit_encryption_context.rb

@@ -36,14 +36,16 @@ module Mongo
       #   that will be used to encrypt the value.
       # @option options [ String ] :algorithm The algorithm used to encrypt the
       #   value. Valid algorithms are "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
-      #   "AEAD_AES_256_CBC_HMAC_SHA_512-Random", "Indexed", "Unindexed", "Range".
+      #   "AEAD_AES_256_CBC_HMAC_SHA_512-Random", "Indexed", "Unindexed", "Range",
+      #   "String".
       # @option options [ Integer | nil ] :contention_factor Contention factor
-      #   to be applied if encryption algorithm is set to "Indexed". If not
-      #   provided, it defaults to a value of 0. Contention factor should be set
-      #   only if encryption algorithm is set to "Indexed".
+      #   to be applied if encryption algorithm is set to "Indexed", "Range", or "String".
+      #   If not provided, it defaults to a value of 0. Contention factor should be set
+      #   only if encryption algorithm is set to "Indexed", "Range", or "String".
       # @option options [ String | nil ] query_type Query type to be applied
-      #   if encryption algorithm is set to "Indexed" or "Range".
-      #   Allowed values are "equality" and "range".
+      #   if encryption algorithm is set to "Indexed", "Range", or "String".
+      #   Allowed values are "equality", "range", "prefix", "suffix", and
+      #   "substring".
       # @option options [ Hash | nil ] :range_opts Specifies index options for
       #   a Queryable Encryption field supporting "range" queries.
       #   Allowed options are:
@@ -56,9 +58,22 @@ module Mongo
       #   the encryptedFields of the destination collection.
       #   For double and decimal128, min/max/precision must all be set,
       #   or all be unset.
+      # @option options [ Hash | nil ] :string_opts Specifies index options for
+      #   a Queryable Encryption field supporting "prefix", "suffix", or
+      #   "substring" queries (algorithm "String"). Allowed options are:
+      #   - :case_sensitive
+      #   - :diacritic_sensitive
+      #   - :prefix (Hash with :str_min_query_length, :str_max_query_length)
+      #   - :suffix (Hash with :str_min_query_length, :str_max_query_length)
+      #   - :substring (Hash with :str_max_length, :str_min_query_length,
+      #     :str_max_query_length)
+      #   The options must match the values set in the encryptedFields of the
+      #   destination collection.
       #
       # @note The Range algorithm is experimental only. It is not intended for
       # public use.
+      # @note The "substring" query type is unstable and subject to backwards
+      # breaking changes.
       #
       # @raise [ ArgumentError|Mongo::Error::CryptError ] If invalid options are provided
       def initialize(mongocrypt, io, doc, options = {})
@@ -114,28 +129,52 @@ module Mongo
 
       def set_algorithm_opts(options)
         Binding.ctx_setopt_algorithm(self, options[:algorithm])
-        if %w[Indexed Range].include?(options[:algorithm])
+        if %w[Indexed Range String].include?(options[:algorithm])
           Binding.ctx_setopt_contention_factor(self, options[:contention_factor]) if options[:contention_factor]
           Binding.ctx_setopt_query_type(self, options[:query_type]) if options[:query_type]
         else
           if options[:contention_factor]
-            raise ArgumentError.new(':contention_factor is allowed only for "Indexed" or "Range" algorithms')
+            raise ArgumentError.new(':contention_factor is allowed only for "Indexed", "Range", or "String" algorithms')
           end
           if options[:query_type]
-            raise ArgumentError.new(':query_type is allowed only for "Indexed" or "Range" algorithms')
+            raise ArgumentError.new(':query_type is allowed only for "Indexed", "Range", or "String" algorithms')
           end
         end
-        return unless options[:algorithm] == 'Range'
-
-        Binding.ctx_setopt_algorithm_range(self, convert_range_opts(options[:range_opts]))
+        if options[:algorithm] == 'Range'
+          Binding.ctx_setopt_algorithm_range(self, convert_range_opts(options[:range_opts]))
+        elsif options[:algorithm] == 'String'
+          Binding.ctx_setopt_algorithm_text(self, convert_string_opts(options[:string_opts]))
+        end
       end
 
       def convert_range_opts(range_opts)
+        raise ArgumentError.new(':range_opts is required for the "Range" algorithm') if range_opts.nil?
+
         range_opts.dup.tap do |opts|
           opts[:sparsity] = BSON::Int64.new(opts[:sparsity]) if opts[:sparsity] && !opts[:sparsity].is_a?(BSON::Int64)
           opts[:trimFactor] = opts.delete(:trim_factor) if opts[:trim_factor]
         end
       end
+
+      def convert_string_opts(string_opts)
+        raise ArgumentError.new(':string_opts is required for the "String" algorithm') if string_opts.nil?
+
+        string_opts.dup.tap do |opts|
+          opts[:caseSensitive] = opts.delete(:case_sensitive) if opts.key?(:case_sensitive)
+          opts[:diacriticSensitive] = opts.delete(:diacritic_sensitive) if opts.key?(:diacritic_sensitive)
+          %i[substring prefix suffix].each do |query_type|
+            opts[query_type] = convert_string_query_opts(opts[query_type]) if opts[query_type]
+          end
+        end
+      end
+
+      def convert_string_query_opts(query_opts)
+        query_opts.dup.tap do |opts|
+          opts[:strMaxLength] = opts.delete(:str_max_length) if opts.key?(:str_max_length)
+          opts[:strMinQueryLength] = opts.delete(:str_min_query_length) if opts.key?(:str_min_query_length)
+          opts[:strMaxQueryLength] = opts.delete(:str_max_query_length) if opts.key?(:str_max_query_length)
+        end
+      end
     end
   end
 end

data/lib/mongo/crypt/handle.rb

@@ -66,6 +66,10 @@ module Mongo
       #   error that libmongocrypt raises on a subsequent "$SYSTEM" search.
       # @option options [ Logger ] :logger A Logger object to which libmongocrypt logs
       #   will be sent
+      # @option options [ Integer | nil ] :key_expiration_ms The lifetime of the
+      #   data encryption key cache, in milliseconds. A value of 0 means the
+      #   cache never expires. When nil, libmongocrypt's default of 60000 is
+      #   used.
       def initialize(kms_providers, kms_tls_options, options = {})
         # FFI::AutoPointer uses a custom release strategy to automatically free
         # the pointer once this object goes out of scope
@@ -87,6 +91,9 @@ module Mongo
         @bypass_query_analysis = options[:bypass_query_analysis]
         set_bypass_query_analysis if @bypass_query_analysis
 
+        @key_expiration_ms = options[:key_expiration_ms]
+        set_key_expiration unless @key_expiration_ms.nil?
+
         @crypt_shared_lib_path = options[:crypt_shared_lib_path]
         @explicit_encryption_only = options[:explicit_encryption_only]
         @disable_crypt_shared_lib_search = options[:disable_crypt_shared_lib_search]
@@ -200,6 +207,17 @@ module Mongo
         Binding.setopt_bypass_query_analysis(self) if @bypass_query_analysis
       end
 
+      def set_key_expiration
+        unless @key_expiration_ms.is_a?(Integer) && !@key_expiration_ms.negative?
+          raise ArgumentError.new(
+            "#{@key_expiration_ms} is an invalid key_expiration_ms value; " \
+            'must be a non-negative Integer or nil'
+          )
+        end
+
+        Binding.setopt_key_expiration(self, @key_expiration_ms)
+      end
+
       # Send the logs from libmongocrypt to the Mongo::Logger
       def set_logger_callback
         @log_callback = proc do |level, msg|

data/lib/mongo/cursor.rb

@@ -103,6 +103,19 @@ module Mongo
           self.class.finalize(kill_spec(@connection_global_id), cluster)
         )
       end
+    rescue Exception # rubocop:disable Lint/RescueException
+      # In load-balanced topology the connection of the initial result is
+      # checked out of the pool until the cursor is drained. If the cursor
+      # cannot be constructed, nothing will ever check the connection back
+      # in, so release it here before the error propagates. Exception (not
+      # StandardError) is rescued so that an interrupt does not permanently
+      # leak the connection. In other topologies the connection is not owned
+      # by the cursor and must not be touched here.
+      if server&.load_balancer? && result.is_a?(Operation::Result) &&
+         (connection = result.connection)
+        connection.connection_pool.check_in_if_checked_out(connection)
+      end
+      raise
     end
 
     # @api private

data/lib/mongo/database/view.rb

@@ -273,12 +273,13 @@ module Mongo
         execution_opts = {}
         execution_opts[:deserialize_as_bson] = opts.delete(:deserialize_as_bson) if opts.key?(:deserialize_as_bson)
         if server.load_balancer?
-          connection = server.pool.check_out(context: context)
-          initial_query_op(session, opts).execute_with_connection(
-            connection,
-            context: context,
-            options: execution_opts
-          )
+          server.pool.with_cursor_connection(context: context) do |connection|
+            initial_query_op(session, opts).execute_with_connection(
+              connection,
+              context: context,
+              options: execution_opts
+            )
+          end
         else
           initial_query_op(session, opts).execute(
             server,

data/lib/mongo/database.rb

@@ -339,15 +339,12 @@ module Mongo
           server = selector.select_server(cluster, nil, session)
           if server.load_balancer?
             # The connection is checked in by the cursor when it is drained.
-            connection = check_out_cursor_command_connection(server, context)
-            begin
-              op.execute_with_connection(connection, context: context, options: execution_opts)
-            rescue StandardError
-              # Release the connection before the error propagates so that
-              # a retried attempt checks out a fresh one.
-              connection.connection_pool.check_in(connection) unless connection.pinned?
-              connection = nil
-              raise
+            # If the command fails, the connection is released before the
+            # error propagates so that a retried attempt checks out a
+            # fresh one.
+            server.pool.with_cursor_connection(context: context) do |conn|
+              connection = conn
+              op.execute_with_connection(conn, context: context, options: execution_opts)
             end
           else
             op.execute(server, context: context, options: execution_opts)
@@ -366,7 +363,7 @@ module Mongo
         # If the cursor was created it owns the session and connection;
         # otherwise (error or no cursor in the response) release them here.
         unless cursor
-          connection.connection_pool.check_in(connection) if connection && !connection.pinned?
+          connection.connection_pool.check_in_if_checked_out(connection) if connection
           session.end_session if session && session.implicit?
         end
       end

data/lib/mongo/error/unsupported_option.rb

@@ -18,24 +18,6 @@ module Mongo
   class Error
     # Raised if an unsupported option is specified for an operation.
     class UnsupportedOption < Error
-      # The error message provided when the user passes the hint option to
-      # a write operation against a server that does not support the hint
-      # option and does not provide option validation.
-      #
-      # @api private
-      HINT_MESSAGE = 'The MongoDB server handling this request does not support ' \
-                     'the hint option on this command. The hint option is supported on update ' \
-                     'commands on MongoDB server versions 4.2 and later and on findAndModify ' \
-                     'and delete commands on MongoDB server versions 4.4 and later'
-
-      # The error message provided when the user passes the hint option to
-      # an unacknowledged write operation.
-      #
-      # @api private
-      UNACKNOWLEDGED_HINT_MESSAGE = 'The hint option cannot be specified on ' \
-                                    'an unacknowledged write operation. Remove the hint option or perform ' \
-                                    'this operation with a write concern of at least { w: 1 }'
-
       # The error message provided when the user passes the allow_disk_use
       # option to a find operation against a server that does not support the
       # allow_disk_use operation and does not provide option validation.
@@ -56,28 +38,6 @@ module Mongo
                               'option is supported on createIndexes commands on MongoDB server versions ' \
                               '4.4 and later'
 
-      # Raise an error about an unsupported hint option.
-      #
-      # @option options [ Boolean ] unacknowledged_write Whether this error
-      #   pertains to a hint option passed to an unacknowledged write. Defaults
-      #   to false.
-      #
-      # @return [ Mongo::Error::UnsupportedOption ] An error with a default
-      #   error message.
-      #
-      # @api private
-      def self.hint_error(**options)
-        unacknowledged_write = options[:unacknowledged_write] || false
-
-        error_message = if unacknowledged_write
-                          UNACKNOWLEDGED_HINT_MESSAGE
-                        else
-                          HINT_MESSAGE
-                        end
-
-        new(error_message)
-      end
-
       # Raise an error about an unsupported allow_disk_use option.
       #
       # @return [ Mongo::Error::UnsupportedOption ] An error with a default

data/lib/mongo/grid/fs_bucket.rb

@@ -218,10 +218,10 @@ module Mongo
       def delete(id, opts = {})
         timeout_holder = CsotTimeoutHolder.new(operation_timeouts: operation_timeouts(opts))
         result = files_collection
-                 .find({ _id: id }, @options.merge(timeout_ms: timeout_holder.remaining_timeout_ms))
+                 .find({ _id: { '$eq' => id } }, @options.merge(timeout_ms: timeout_holder.remaining_timeout_ms))
                  .delete_one(timeout_ms: timeout_holder.remaining_timeout_ms)
         chunks_collection
-          .find({ files_id: id }, @options.merge(timeout_ms: timeout_holder.remaining_timeout_ms))
+          .find({ files_id: { '$eq' => id } }, @options.merge(timeout_ms: timeout_holder.remaining_timeout_ms))
           .delete_many(timeout_ms: timeout_holder.remaining_timeout_ms)
         raise Error::FileNotFound.new(id, :id) if result.n == 0
 

data/lib/mongo/grid/stream/read.rb

@@ -182,7 +182,7 @@ module Mongo
             @file_info ||= begin
               doc = options[:file_info_doc] ||
                     fs.files_collection.find(
-                      { _id: file_id },
+                      { _id: { '$eq' => file_id } },
                       { timeout_ms: @timeout_holder.remaining_timeout_ms! }
                     ).first
               File::Info.new(Options::Mapper.transform(doc, File::Info::MAPPINGS.invert)) if doc
@@ -216,7 +216,7 @@ module Mongo
                 opts[:timeout_mode] = :cursor_lifetime
               end
 
-              fs.chunks_collection.find({ files_id: file_id }, opts).sort(n: 1)
+              fs.chunks_collection.find({ files_id: { '$eq' => file_id } }, opts).sort(n: 1)
             end
           end
 

data/lib/mongo/grid/stream/write.rb

@@ -177,7 +177,7 @@ module Mongo
           # @since 2.1.0
           def abort
             fs.chunks_collection.find(
-              { files_id: file_id },
+              { files_id: { '$eq' => file_id } },
               @options.merge(timeout_ms: @timeout_holder.remaining_timeout_ms!)
             ).delete_many
             (@open = false) || true

data/lib/mongo/index/view.rb

@@ -421,8 +421,9 @@ module Mongo
 
       def send_initial_query(op, server, _session, context)
         if server.load_balancer?
-          connection = server.pool.check_out(context: context)
-          op.execute_with_connection(connection, context: context)
+          server.pool.with_cursor_connection(context: context) do |connection|
+            op.execute_with_connection(connection, context: context)
+          end
         else
           op.execute(server, context: context)
         end

data/lib/mongo/monitoring/event/secure.rb

@@ -37,6 +37,11 @@ module Mongo
           copydb
         ].freeze
 
+        # The hello and legacy hello command names. A constant, because
+        # sensitive? runs on every command event and an array literal would
+        # allocate on each call.
+        HELLO_COMMANDS = %w[hello ismaster isMaster].freeze
+
         # Check whether the command is sensitive in terms of command monitoring
         # spec. A command is detected as sensitive if it is in the
         # list or if it is a hello/legacy hello command, and
@@ -53,7 +58,7 @@ module Mongo
           # when speculativeAuthenticate is present, their commands AND replies
           # MUST be redacted from the events.
           # See https://github.com/mongodb/specifications/blob/master/source/command-logging-and-monitoring/command-logging-and-monitoring.md#security
-          %w[hello ismaster isMaster].include?(command_name.to_s) &&
+          HELLO_COMMANDS.include?(command_name.to_s) &&
             !!document['speculativeAuthenticate']
         end
 

data/lib/mongo/operation/map_reduce/result.rb

@@ -80,7 +80,7 @@ module Mongo
         # @since 2.0.0
         # @api public
         def successful?
-          !documents.nil?
+          !documents.nil? && parser.message.empty?
         end
 
         # Get the execution time of the map/reduce.
@@ -112,7 +112,11 @@ module Mongo
         # @since 2.0.0
         # @api private
         def validate!
-          documents.nil? ? raise_operation_failure : self
+          if documents.nil? || !parser.message.empty?
+            raise_operation_failure
+          else
+            self
+          end
         end
 
         # Get the cursor id.

data/lib/mongo/operation/result.rb

@@ -456,6 +456,15 @@ module Mongo
         doc['cursor']&.[]('atClusterTime') || doc['atClusterTime']
       end
 
+      # Returns the base backoff in milliseconds for a server overload error, if present.
+      #
+      # @return [ Integer | nil ] The base backoff in milliseconds.
+      #
+      # @api private
+      def base_backoff_ms
+        first_document && first_document['baseBackoffMS']
+      end
+
       private
 
       def operation_failure_class

data/lib/mongo/operation/shared/executable.rb

@@ -132,12 +132,7 @@ module Mongo
       def process_result_for_sdam(result, connection)
         if (result.not_master? || result.node_recovering?) &&
            connection.generation >= connection.server.pool.generation(service_id: connection.service_id)
-          keep_pool = if result.node_shutting_down?
-                        false
-                      else
-                        # Max wire version needs to be examined while the server is known
-                        connection.description.server_version_gte?('4.2')
-                      end
+          keep_pool = !result.node_shutting_down?
 
           connection.server.unknown!(
             keep_connection_pool: keep_pool,

data/lib/mongo/operation/shared/result/aggregatable.rb

@@ -36,7 +36,7 @@ module Mongo
           return unless @replies
 
           @replies.reduce(nil) do |errors, reply|
-            next unless (write_errors = reply.documents.first['writeErrors'])
+            next errors unless (write_errors = reply.documents.first['writeErrors'])
 
             wes = write_errors.collect do |we|
               we.merge!('index' => count + we['index'])
@@ -59,11 +59,11 @@ module Mongo
           return unless @replies
 
           @replies.each_with_index.reduce(nil) do |errors, (reply, _)|
-            next unless (write_concern_errors = reply.documents.first['writeConcernErrors'])
+            next errors unless (write_concern_errors = reply.documents.first['writeConcernErrors'])
 
             (errors || []) << write_concern_errors.reduce(nil) do |errs, wce|
               wce.merge!('index' => count + wce['index'])
-              (errs || []) << write_concern_error
+              (errs || []) << wce
             end
           end
         end

data/lib/mongo/protocol/message.rb

@@ -148,10 +148,6 @@ module Mongo
       # @return [ Mongo::Protocol::Msg ] The decrypted message, or the original
       #   message if decryption was not possible or necessary.
       def maybe_decrypt(_context)
-        # TODO: determine if we should be decrypting data coming from pre-4.2
-        # servers, potentially using legacy wire protocols. If so we need
-        # to implement decryption for those wire protocols as our current
-        # encryption/decryption code is OP_MSG-specific.
         self
       end
 

data/lib/mongo/protocol/msg.rb

@@ -201,23 +201,12 @@ module Mongo
       # represents one of the command types allow-listed by libmongocrypt and it
       # contains data that is required to be encrypted by a local or remote json schema.
       #
-      # @param [ Mongo::Server::Connection ] connection The connection on which
-      #   the operation is performed.
       # @param [ Mongo::Operation::Context ] context The operation context.
       #
       # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
       #   message if encryption was not possible or necessary.
-      def maybe_encrypt(connection, context)
+      def maybe_encrypt(_connection, context)
         if context.encrypt?
-          if connection.description.max_wire_version < 8
-            raise Error::CryptError.new(
-              'Cannot perform encryption against a MongoDB server older than ' +
-              '4.2 (wire version less than 8). Currently connected to server ' +
-              "with max wire version #{connection.description.max_wire_version}} " +
-              '(Auto-encryption requires a minimum MongoDB version of 4.2)'
-            )
-          end
-
           db_name = @main_document[DATABASE_IDENTIFIER]
           cmd = merge_sections
           enc_cmd = context.encrypt(db_name, cmd)

data/lib/mongo/protocol/serializers.rb

@@ -319,16 +319,8 @@ module Mongo
           # @return [ Array<BSON::Document> ] Deserialized section.
           #
           # @since 2.5.0
-          def self.deserialize(buffer)
+          def self.deserialize(buffer, _options = {})
             raise NotImplementedError
-
-            start_size = buffer.length
-            section_size = buffer.get_int32 # get the size
-            end_size = start_size - section_size
-            buffer.get_cstring # get the identifier
-            documents = []
-            documents << BSON::Document.from_bson(buffer) until buffer.length == end_size
-            documents
           end
         end
       end

data/lib/mongo/retryable/backpressure.rb

@@ -23,9 +23,24 @@ module Mongo
       #   a random value. Can be injected for deterministic testing.
       #
       # @return [ Float ] The backoff delay in seconds.
-      def self.backoff_delay(attempt, jitter: rand)
-        jitter * [ MAX_BACKOFF, BASE_BACKOFF * (2**(attempt - 1)) ].min
+      def self.backoff_delay(attempt, jitter: rand, err: nil)
+        jitter * [ MAX_BACKOFF, base_backoff(err) * (2**attempt) ].min
       end
+
+      def self.base_backoff(err)
+        return BASE_BACKOFF if err.nil?
+        return BASE_BACKOFF unless err.respond_to?(:result) && err.result.respond_to?(:base_backoff_ms)
+
+        base_backoff_ms = err.result.base_backoff_ms
+
+        if base_backoff_ms && base_backoff_ms > 0
+          err.result.base_backoff_ms / 1000.0
+        else
+          BASE_BACKOFF
+        end
+      end
+
+      private_class_method :base_backoff
     end
   end
 end

data/lib/mongo/retryable/read_worker.rb

@@ -340,7 +340,7 @@ module Mongo
       def overload_read_retry(last_error, session, server_selector, context, failed_server, error_count:)
         last_was_overload = true
         loop do
-          delay = last_was_overload ? retry_policy.backoff_delay(error_count) : 0
+          delay = last_was_overload ? retry_policy.backoff_delay(error_count, err: last_error) : 0
           raise last_error unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
           log_retry(last_error, message: 'Read retry (overload backoff)')

data/lib/mongo/retryable/retry_policy.rb

@@ -27,8 +27,8 @@ module Mongo
       # @param [ Float ] jitter A random float in [0.0, 1.0).
       #
       # @return [ Float ] The backoff delay in seconds.
-      def backoff_delay(attempt, jitter: rand)
-        Backpressure.backoff_delay(attempt, jitter: jitter)
+      def backoff_delay(attempt, jitter: rand, err: nil)
+        Backpressure.backoff_delay(attempt, jitter: jitter, err: err)
       end
 
       # Determine whether an overload retry should be attempted.

data/lib/mongo/retryable/write_worker.rb

@@ -123,7 +123,7 @@ module Mongo
               unless e.respond_to?(:label?) && e.label?('NoWritesPerformed')
                 error_to_raise = e
               end
-              delay = retry_policy.backoff_delay(error_count)
+              delay = retry_policy.backoff_delay(error_count, err: e)
               raise error_to_raise unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
               log_retry(e, message: 'Write retry (overload backoff)')
@@ -386,7 +386,7 @@ module Mongo
         last_was_overload = true
 
         loop do
-          delay = last_was_overload ? retry_policy.backoff_delay(error_count) : 0
+          delay = last_was_overload ? retry_policy.backoff_delay(error_count, err: last_error) : 0
           raise error_to_raise unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
           log_retry(last_error, message: 'Write retry (overload backoff)')

data/lib/mongo/retryable.rb

@@ -129,7 +129,7 @@ module Mongo
 
         error_count += 1
         policy = client.retry_policy
-        delay = policy.backoff_delay(error_count)
+        delay = policy.backoff_delay(error_count, err: e)
         raise e unless policy.should_retry_overload?(error_count, delay, context: context)
 
         Logger.logger.warn("Overload retry due to: #{e.class.name}: #{e.message}")

data/lib/mongo/server/app_metadata.rb

@@ -130,7 +130,6 @@ module Mongo
             doc[:driver] = driver_doc
             doc[:os] = os_doc
             doc[:platform] = platform_string
-            doc[:backpressure] = true
             env_doc.tap { |env| doc[:env] = env if env }
           end
       end
@@ -157,7 +156,7 @@ module Mongo
       def document
         @document ||= begin
           client = Truncator.new(client_document).document
-          BSON::Document.new(compression: @compressors, client: client).tap do |doc|
+          BSON::Document.new(compression: @compressors, client: client, backpressure: '2').tap do |doc|
             doc[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
             doc.update(Utils.transform_server_api(@server_api)) if @server_api
           end