mongo 2.20.1 → 2.21.0

data/lib/mongo/server/connection_pool.rb

@@ -205,11 +205,18 @@ module Mongo
 
       # The time to wait, in seconds, for a connection to become available.
       #
+      # @param [ Mongo::Operation:Context | nil ] context Context of the operation
+      #   the connection is requested for, if any.
+      #
       # @return [ Float ] The queue wait timeout.
       #
       # @since 2.9.0
-      def wait_timeout
-        @wait_timeout ||= options[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
+      def wait_timeout(context = nil)
+        if context&.remaining_timeout_sec.nil?
+          options[:wait_timeout] || DEFAULT_WAIT_TIMEOUT
+        else
+          context&.remaining_timeout_sec
+        end
       end
 
       # The maximum seconds a socket can remain idle since it has been
@@ -345,6 +352,10 @@ module Mongo
       # The returned connection counts toward the pool's max size. When the
       # caller is finished using the connection, the connection should be
       # checked back in via the check_in method.
+      # @param [ Integer | nil ] :connection_global_id The global id for the
+      #   connection to check out.
+      # @param [ Mongo::Operation:Context | nil ] :context Context of the operation
+      #   the connection is requested for, if any.
       #
       # @return [ Mongo::Server::Connection ] The checked out connection.
       # @raise [ Error::PoolClosedError ] If the pool has been closed.
@@ -352,7 +363,7 @@ module Mongo
       #   and remains so for longer than the wait timeout.
       #
       # @since 2.9.0
-      def check_out(connection_global_id: nil)
+      def check_out(connection_global_id: nil, context: nil)
         check_invariants
 
         publish_cmap_event(
@@ -362,7 +373,9 @@ module Mongo
         raise_if_pool_closed!
         raise_if_pool_paused_locked!
 
-        connection = retrieve_and_connect_connection(connection_global_id)
+        connection = retrieve_and_connect_connection(
+          connection_global_id, context
+        )
 
         publish_cmap_event(
           Monitoring::Event::Cmap::ConnectionCheckedOut.new(@server.address, connection.id, self),
@@ -698,10 +711,13 @@ module Mongo
       # @return [ Object ] The result of the block.
       #
       # @since 2.0.0
-      def with_connection(connection_global_id: nil)
+      def with_connection(connection_global_id: nil, context: nil)
         raise_if_closed!
 
-        connection = check_out(connection_global_id: connection_global_id)
+        connection = check_out(
+          connection_global_id: connection_global_id,
+          context: context
+        )
         yield(connection)
       rescue Error::SocketError, Error::SocketTimeoutError, Error::ConnectionPerished => e
         maybe_raise_pool_cleared!(connection, e)
@@ -975,9 +991,9 @@ module Mongo
 
       # Attempts to connect (handshake and auth) the connection. If an error is
       # encountered, closes the connection and raises the error.
-      def connect_connection(connection)
+      def connect_connection(connection, context = nil)
         begin
-          connection.connect!
+          connection.connect!(context)
         rescue Exception
           connection.disconnect!(reason: :error)
           raise
@@ -1242,16 +1258,18 @@ module Mongo
 
       # Retrieves a connection and connects it.
       #
-      # @param [ Integer ] connection_global_id The global id for the
+      # @param [ Integer | nil ] connection_global_id The global id for the
       #   connection to check out.
+      # @param [ Mongo::Operation:Context | nil ] context Context of the operation
+      #   the connection is requested for, if any.
       #
       # @return [ Mongo::Server::Connection ] The checked out connection.
       #
       # @raise [ Error::PoolClosedError ] If the pool has been closed.
       # @raise [ Timeout::Error ] If the connection pool is at maximum size
       #   and remains so for longer than the wait timeout.
-      def retrieve_and_connect_connection(connection_global_id)
-        deadline = Utils.monotonic_time + wait_timeout
+      def retrieve_and_connect_connection(connection_global_id, context =  nil)
+        deadline = Utils.monotonic_time + wait_timeout(context)
         connection = nil
 
         @lock.synchronize do
@@ -1267,7 +1285,7 @@ module Mongo
           connection = wait_for_connection(connection_global_id, deadline)
         end
 
-        connect_or_raise(connection) unless connection.connected?
+        connect_or_raise(connection, context) unless connection.connected?
 
         @lock.synchronize do
           @checked_out_connections << connection
@@ -1327,8 +1345,8 @@ module Mongo
       # cannot be connected.
       # This method also publish corresponding event and ensures that counters
       # and condition variables are updated.
-      def connect_or_raise(connection)
-        connect_connection(connection)
+      def connect_or_raise(connection, context)
+        connect_connection(connection, context)
       rescue Exception
         # Handshake or authentication failed
         @lock.synchronize do

data/lib/mongo/server/description/features.rb

@@ -83,7 +83,7 @@ module Mongo
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (6..21).freeze
+        DRIVER_WIRE_VERSIONS = (6..25).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/description.rb

@@ -209,8 +209,8 @@ module Mongo
       # @param [ Hash ] config The result of the hello command.
       # @param [ Float ] average_round_trip_time The moving average time (sec) the hello
       #   command took to complete.
-      # @param [ Float ] average_round_trip_time The moving average time (sec)
-      #   the ismaster call took to complete.
+      # @param [ Float ] minimum_round_trip_time The minimum round trip time
+      #   of ten last hello commands.
       # @param [ true | false ] load_balancer Whether the server is treated as
       #   a load balancer.
       # @param [ true | false ] force_load_balancer Whether the server is
@@ -218,7 +218,8 @@ module Mongo
       #
       # @api private
       def initialize(address, config = {}, average_round_trip_time: nil,
-        load_balancer: false, force_load_balancer: false
+        minimum_round_trip_time: 0, load_balancer: false,
+        force_load_balancer: false
       )
         @address = address
         @config = config
@@ -226,6 +227,7 @@ module Mongo
         @force_load_balancer = !!force_load_balancer
         @features = Features.new(wire_versions, me || @address.to_s)
         @average_round_trip_time = average_round_trip_time
+        @minimum_round_trip_time = minimum_round_trip_time
         @last_update_time = Time.now.freeze
         @last_update_monotime = Utils.monotonic_time
 
@@ -302,6 +304,10 @@ module Mongo
       # @return [ Float ] The moving average time the hello call took to complete.
       attr_reader :average_round_trip_time
 
+      # @return [ Float ] The minimum time from the ten last hello calls took
+      #   to complete.
+      attr_reader :minimum_round_trip_time
+
       # Returns whether this server is an arbiter, per the SDAM spec.
       #
       # @example Is the server an arbiter?
@@ -723,8 +729,7 @@ module Mongo
 
       # @api private
       def ok?
-        config[Operation::Result::OK] &&
-          config[Operation::Result::OK] == 1 || false
+        config[Operation::Result::OK] == 1
       end
 
       # Get the range of supported wire versions for the server.
@@ -802,6 +807,14 @@ module Mongo
         !!(address.to_s.downcase != me.downcase if me)
       end
 
+      # Whether this description is from a mongocryptd server.
+      #
+      # @return [ true, false ] Whether this description is from a mongocryptd
+      #   server.
+      def mongocryptd?
+        ok? && config['iscryptd'] == true
+      end
+
       # opTime in lastWrite subdocument of the hello response.
       #
       # @return [ BSON::Timestamp ] The timestamp.

data/lib/mongo/server/monitor.rb

@@ -237,8 +237,11 @@ module Mongo
         @sdam_mutex.synchronize do
           old_description = server.description
 
-          new_description = Description.new(server.address, result,
-            average_round_trip_time: server.round_trip_time_averager.average_round_trip_time
+          new_description = Description.new(
+            server.address,
+            result,
+            average_round_trip_time: server.round_trip_time_calculator.average_round_trip_time,
+            minimum_round_trip_time: server.round_trip_time_calculator.minimum_round_trip_time
           )
 
           server.cluster.run_sdam_flow(server.description, new_description, awaited: awaited, scan_error: scan_error)
@@ -306,7 +309,7 @@ module Mongo
         end
 
         if @connection
-          result = server.round_trip_time_averager.measure do
+          result = server.round_trip_time_calculator.measure do
             begin
               doc = @connection.check_document
               cmd = Protocol::Query.new(
@@ -323,7 +326,7 @@ module Mongo
         else
           connection = Connection.new(server.address, options)
           connection.connect!
-          result = server.round_trip_time_averager.measure do
+          result = server.round_trip_time_calculator.measure do
             connection.handshake!
           end
           @connection = connection

data/lib/mongo/server/pending_connection.rb

@@ -120,7 +120,7 @@ module Mongo
       #
       # @return [ Mongo::Protocol::Reply ] Deserialized server response.
       def get_handshake_response(hello_command)
-        @server.round_trip_time_averager.measure do
+        @server.round_trip_time_calculator.measure do
           add_server_diagnostics do
             socket.write(hello_command.serialize.to_s)
             Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE)
@@ -168,7 +168,11 @@ module Mongo
           doc['serviceId'] ||= "fake:#{rand(2**32-1)+1}"
         end
 
-        post_handshake(doc, @server.round_trip_time_averager.average_round_trip_time)
+        post_handshake(
+          doc,
+          @server.round_trip_time_calculator.average_round_trip_time,
+          @server.round_trip_time_calculator.minimum_round_trip_time
+        )
 
         doc
       end
@@ -218,7 +222,7 @@ module Mongo
       #
       # @return [ Server::Description ] The server description calculated from
       #   the handshake response for this particular connection.
-      def post_handshake(response, average_rtt)
+      def post_handshake(response, average_rtt, minimum_rtt)
         if response["ok"] == 1
           # Auth mechanism is entirely dependent on the contents of
           # hello response *for this connection*.

data/lib/mongo/server/{round_trip_time_averager.rb → round_trip_time_calculator.rb}

@@ -18,20 +18,30 @@
 module Mongo
   class Server
     # @api private
-    class RoundTripTimeAverager
+    class RoundTripTimeCalculator
 
       # The weighting factor (alpha) for calculating the average moving
       # round trip time.
       RTT_WEIGHT_FACTOR = 0.2.freeze
       private_constant :RTT_WEIGHT_FACTOR
 
+      RTT_SAMPLES_FOR_MINIMUM = 10
+      private_constant :RTT_SAMPLES_FOR_MINIMUM
+
+      MIN_SAMPLES = 3
+      private_constant :MIN_SAMPLES
+
       def initialize
         @last_round_trip_time = nil
         @average_round_trip_time = nil
+        @minimum_round_trip_time = 0
+        @lock = Mutex.new
+        @rtts = []
       end
 
       attr_reader :last_round_trip_time
       attr_reader :average_round_trip_time
+      attr_reader :minimum_round_trip_time
 
       def measure
         start = Utils.monotonic_time
@@ -44,14 +54,17 @@ module Mongo
         rescue Error, Error::AuthError => exc
           # For other errors, RTT is valid.
         end
-        last_round_trip_time = Utils.monotonic_time - start
+        last_rtt = Utils.monotonic_time - start
 
         # If hello fails, we need to return the last round trip time
         # because it is used in the heartbeat failed SDAM event,
         # but we must not update the round trip time recorded in the server.
         unless exc
-          @last_round_trip_time = last_round_trip_time
-          update_average_round_trip_time
+          @last_round_trip_time = last_rtt
+          @lock.synchronize do
+            update_average_round_trip_time
+            update_minimum_round_trip_time
+          end
         end
 
         if exc
@@ -61,9 +74,6 @@ module Mongo
         end
       end
 
-      private
-
-      # This method is separate for testing purposes.
       def update_average_round_trip_time
         @average_round_trip_time = if average_round_trip_time
           RTT_WEIGHT_FACTOR * last_round_trip_time + (1 - RTT_WEIGHT_FACTOR) * average_round_trip_time
@@ -71,6 +81,14 @@ module Mongo
           last_round_trip_time
         end
       end
+
+      def update_minimum_round_trip_time
+        @rtts.push(last_round_trip_time) unless last_round_trip_time.nil?
+        @minimum_round_trip_time = 0 and return if @rtts.size < MIN_SAMPLES
+
+        @rtts.shift if @rtts.size > RTT_SAMPLES_FOR_MINIMUM
+        @minimum_round_trip_time = @rtts.compact.min
+      end
     end
   end
 end

data/lib/mongo/server.rb

@@ -80,7 +80,7 @@ module Mongo
         include Id
       end
       @scan_semaphore = DistinguishingSemaphore.new
-      @round_trip_time_averager = RoundTripTimeAverager.new
+      @round_trip_time_calculator = RoundTripTimeCalculator.new
       @description = Description.new(address, {},
         load_balancer: !!@options[:load_balancer],
         force_load_balancer: force_load_balancer?,
@@ -197,6 +197,7 @@ module Mongo
                    :max_message_size,
                    :tags,
                    :average_round_trip_time,
+                   :minimum_round_trip_time,
                    :mongos?,
                    :other?,
                    :primary?,
@@ -228,9 +229,9 @@ module Mongo
     # @api private
     attr_reader :scan_semaphore
 
-    # @return [ RoundTripTimeAverager ] Round trip time averager object.
+    # @return [ RoundTripTimeCalculator ] Round trip time calculator object.
     # @api private
-    attr_reader :round_trip_time_averager
+    attr_reader :round_trip_time_calculator
 
     # Is this server equal to another?
     #
@@ -490,8 +491,12 @@ module Mongo
     # @return [ Object ] The result of the block execution.
     #
     # @since 2.3.0
-    def with_connection(connection_global_id: nil, &block)
-      pool.with_connection(connection_global_id: connection_global_id, &block)
+    def with_connection(connection_global_id: nil, context: nil, &block)
+      pool.with_connection(
+        connection_global_id: connection_global_id,
+        context: context,
+        &block
+      )
     end
 
     # Handle handshake failure.
@@ -697,5 +702,5 @@ require 'mongo/server/connection'
 require 'mongo/server/connection_pool'
 require 'mongo/server/description'
 require 'mongo/server/monitor'
-require 'mongo/server/round_trip_time_averager'
+require 'mongo/server/round_trip_time_calculator'
 require 'mongo/server/push_monitor'

data/lib/mongo/server_selector/base.rb

@@ -33,11 +33,11 @@ module Mongo
       #
       # @option options [ Integer ] :local_threshold The local threshold boundary for
       #  nearest selection in seconds.
-      # @option options [ Integer ] max_staleness The maximum replication lag,
+      # @option options [ Integer ] :max_staleness The maximum replication lag,
       #   in seconds, that a secondary can suffer and still be eligible for a read.
       #   A value of -1 is treated identically to nil, which is to not
       #   have a maximum staleness.
-      # @option options [ Hash | nil ] hedge A Hash specifying whether to enable hedged
+      # @option options [ Hash | nil ] :hedge A Hash specifying whether to enable hedged
       #   reads on the server. Hedged reads are not enabled by default. When
       #   specifying this option, it must be in the format: { enabled: true },
       #   where the value of the :enabled key is a boolean value.
@@ -168,6 +168,8 @@ module Mongo
       #   be selected from only if no other servers are available. This is
       #   used to avoid selecting the same server twice in a row when
       #   retrying a command.
+      # @param [ Float | nil ] :timeout Timeout in seconds for the operation,
+      #   if any.
       #
       # @return [ Mongo::Server ] A server matching the server preference.
       #
@@ -178,21 +180,35 @@ module Mongo
       #   lint mode is enabled.
       #
       # @since 2.0.0
-      def select_server(cluster, ping = nil, session = nil, write_aggregation: false, deprioritized: [])
-        select_server_impl(cluster, ping, session, write_aggregation, deprioritized).tap do |server|
+      def select_server(
+        cluster,
+        ping = nil,
+        session = nil,
+        write_aggregation: false,
+        deprioritized: [],
+        timeout: nil
+      )
+        select_server_impl(cluster, ping, session, write_aggregation, deprioritized, timeout).tap do |server|
           if Lint.enabled? && !server.pool.ready?
             raise Error::LintError, 'Server selector returning a server with a pool which is not ready'
           end
         end
       end
 
-      # Parameters and return values are the same as for select_server.
-      private def select_server_impl(cluster, ping, session, write_aggregation, deprioritized)
+      # Parameters and return values are the same as for select_server, only
+      # the +timeout+ param is renamed to +csot_timeout+.
+      private def select_server_impl(cluster, ping, session, write_aggregation, deprioritized, csot_timeout)
         if cluster.topology.is_a?(Cluster::Topology::LoadBalanced)
           return cluster.servers.first
         end
 
-        server_selection_timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
+        timeout = cluster.options[:server_selection_timeout] || SERVER_SELECTION_TIMEOUT
+
+        server_selection_timeout = if csot_timeout && csot_timeout > 0
+                                     [timeout, csot_timeout].min
+                                   else
+                                     timeout
+                                   end
 
         # Special handling for zero timeout: if we have to select a server,
         # and the timeout is zero, fail immediately (since server selection
@@ -638,9 +654,9 @@ module Mongo
       # state resulting from SDAM will immediately wake up this method and
       # cause it to return.
       #
-      # If the cluster des not have a server selection semaphore, waits
+      # If the cluster does not have a server selection semaphore, waits
       # the smaller of 0.25 seconds and the specified remaining time.
-      # This functionality is provided for backwards compatibilty only for
+      # This functionality is provided for backwards compatibility only for
       # applications directly invoking the server selection process.
       # If lint mode is enabled and the cluster does not have a server
       # selection semaphore, Error::LintError will be raised.

data/lib/mongo/session.rb

@@ -57,6 +57,12 @@ module Mongo
     #
     # @option options [ true|false ] :causal_consistency Whether to enable
     #   causal consistency for this session.
+    # @option options [ Integer ] :default_timeout_ms The timeoutMS value for
+    #   the following operations executed on the session:
+    #   - commitTransaction
+    #   - abortTransaction
+    #   - withTransaction
+    #   - endSession
     # @option options [ Hash ] :default_transaction_options Options to pass
     #   to start_transaction by default, can contain any of the options that
     #   start_transaction accepts.
@@ -96,6 +102,7 @@ module Mongo
       @options = options.dup.freeze
       @cluster_time = nil
       @state = NO_TRANSACTION_STATE
+      @with_transaction_deadline = nil
     end
 
     # @return [ Hash ] The options for this session.
@@ -438,9 +445,21 @@ module Mongo
     #   progress or if the write concern is unacknowledged.
     #
     # @since 2.7.0
-    def with_transaction(options=nil)
-      # Non-configurable 120 second timeout for the entire operation
-      deadline = Utils.monotonic_time + 120
+    def with_transaction(options = nil)
+      if timeout_ms = (options || {})[:timeout_ms]
+        timeout_sec = timeout_ms / 1_000.0
+        deadline = Utils.monotonic_time + timeout_sec
+        @with_transaction_deadline = deadline
+      elsif default_timeout_ms = @options[:default_timeout_ms]
+        timeout_sec = default_timeout_ms / 1_000.0
+        deadline = Utils.monotonic_time + timeout_sec
+        @with_transaction_deadline = deadline
+      elsif @client.timeout_sec
+        deadline = Utils.monotonic_time + @client.timeout_sec
+        @with_transaction_deadline = deadline
+      else
+        deadline = Utils.monotonic_time + 120
+      end
       transaction_in_progress = false
       loop do
         commit_options = {}
@@ -454,6 +473,7 @@ module Mongo
         rescue Exception => e
           if within_states?(STARTING_TRANSACTION_STATE, TRANSACTION_IN_PROGRESS_STATE)
             log_warn("Aborting transaction due to #{e.class}: #{e}")
+            @with_transaction_deadline = nil
             abort_transaction
             transaction_in_progress = false
           end
@@ -481,7 +501,7 @@ module Mongo
           rescue Mongo::Error => e
             if e.label?('UnknownTransactionCommitResult')
               if Utils.monotonic_time >= deadline ||
-                e.is_a?(Error::OperationFailure) && e.max_time_ms_expired?
+                e.is_a?(Error::OperationFailure::Family) && e.max_time_ms_expired?
               then
                 transaction_in_progress = false
                 raise
@@ -522,9 +542,10 @@ module Mongo
         log_warn('with_transaction callback broke out of with_transaction loop, aborting transaction')
         begin
           abort_transaction
-        rescue Error::OperationFailure, Error::InvalidTransactionOperation
+        rescue Error::OperationFailure::Family, Error::InvalidTransactionOperation
         end
       end
+      @with_transaction_deadline = nil
     end
 
     # Places subsequent operations in this session into a new transaction.
@@ -539,6 +560,7 @@ module Mongo
     #
     # @option options [ Integer ] :max_commit_time_ms The maximum amount of
     #   time to allow a single commitTransaction command to run, in milliseconds.
+    #   This options is deprecated, use :timeout_ms instead.
     # @option options [ Hash ] :read_concern The read concern options hash,
     #   with the following optional keys:
     #   - *:level* -- the read preference level as a symbol; valid values
@@ -549,6 +571,10 @@ module Mongo
     #   items:
     #   - *:mode* -- read preference specified as a symbol; the only valid value is
     #     *:primary*.
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
     #
     # @raise [ Error::InvalidTransactionOperation ] If a transaction is already in
     #   progress or if the write concern is unacknowledged.
@@ -611,6 +637,10 @@ module Mongo
     #
     # @option options :write_concern [ nil | WriteConcern::Base ] The write
     #   concern to use for this operation.
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
     #
     # @raise [ Error::InvalidTransactionOperation ] If there is no active transaction.
     #
@@ -647,7 +677,11 @@ module Mongo
             write_concern = WriteConcern.get(write_concern)
           end
 
-          context = Operation::Context.new(client: @client, session: self)
+          context = Operation::Context.new(
+            client: @client,
+            session: self,
+            operation_timeouts: operation_timeouts(options)
+          )
           write_with_retry(write_concern, ending_transaction: true,
             context: context,
           ) do |connection, txn_num, context|
@@ -685,10 +719,15 @@ module Mongo
     # @example Abort the transaction.
     #   session.abort_transaction
     #
+    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    #    Must be a non-negative integer. An explicit value of 0 means infinite.
+    #    The default value is unset which means the value is inherited from
+    #    the client.
+    #
     # @raise [ Error::InvalidTransactionOperation ] If there is no active transaction.
     #
     # @since 2.6.0
-    def abort_transaction
+    def abort_transaction(options = nil)
       QueryCache.clear
 
       check_if_ended!
@@ -705,10 +744,16 @@ module Mongo
           Mongo::Error::InvalidTransactionOperation.cannot_call_twice_msg(:abortTransaction))
       end
 
+      options ||= {}
+
       begin
         unless starting_transaction?
           @aborting_transaction = true
-          context = Operation::Context.new(client: @client, session: self)
+          context = Operation::Context.new(
+            client: @client,
+            session: self,
+            operation_timeouts: operation_timeouts(options)
+          )
           write_with_retry(txn_options[:write_concern],
             ending_transaction: true, context: context,
           ) do |connection, txn_num, context|
@@ -898,7 +943,7 @@ module Mongo
     #
     # @since 2.6.0
     # @api private
-    def add_txn_opts!(command, read)
+    def add_txn_opts!(command, read, context)
       command.tap do |c|
         # The read concern should be added to any command that starts a transaction.
         if starting_transaction?
@@ -952,6 +997,14 @@ module Mongo
         if c[:writeConcern] && c[:writeConcern][:w] && c[:writeConcern][:w].is_a?(Symbol)
           c[:writeConcern][:w] = c[:writeConcern][:w].to_s
         end
+
+        # Ignore wtimeout if csot
+        if context&.csot?
+          c[:writeConcern]&.delete(:wtimeout)
+        end
+
+        # We must not send an empty (server default) write concern.
+        c.delete(:writeConcern) if c[:writeConcern]&.empty?
       end
     end
 
@@ -1138,6 +1191,8 @@ module Mongo
     # @api private
     attr_accessor :snapshot_timestamp
 
+    attr_reader :with_transaction_deadline
+
     private
 
     # Get the read concern the session will use when starting a transaction.
@@ -1217,5 +1272,19 @@ module Mongo
         end
       end
     end
+
+    def operation_timeouts(opts)
+      {
+        inherited_timeout_ms: @client.timeout_ms
+      }.tap do |result|
+        if @with_transaction_deadline.nil?
+          if timeout_ms = opts[:timeout_ms]
+            result[:operation_timeout_ms] = timeout_ms
+          elsif default_timeout_ms = options[:default_timeout_ms]
+            result[:operation_timeout_ms] = default_timeout_ms
+          end
+        end
+      end
+    end
   end
 end