mongo 2.20.1 → 2.21.1

data/lib/mongo/retryable/write_worker.rb

@@ -74,7 +74,11 @@ module Mongo
         # If we are here, session is not nil. A session being nil would have
         # failed retry_write_allowed? check.
 
-        server = select_server(cluster, ServerSelector.primary, session)
+        server = select_server(
+          cluster, ServerSelector.primary,
+          session,
+          timeout: context.remaining_timeout_sec
+        )
 
         unless ending_transaction || server.retry_writes?
           return legacy_write_with_retry(server, context: context, &block)
@@ -110,7 +114,7 @@ module Mongo
             server.with_connection(connection_global_id: context.connection_global_id) do |connection|
               yield connection, nil, context
             end
-          rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure => e
+          rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure::Family => e
             e.add_note('retries disabled')
             raise e
           end
@@ -170,6 +174,7 @@ module Mongo
       # @api private
       def legacy_write_with_retry(server = nil, context:)
         session = context.session
+        context.check_timeout!
 
         # This is the pre-session retry logic, and is not subject to
         # current retryable write specifications.
@@ -177,12 +182,20 @@ module Mongo
         attempt = 0
         begin
           attempt += 1
-          server ||= select_server(cluster, ServerSelector.primary, session)
-          server.with_connection(connection_global_id: context.connection_global_id) do |connection|
+          server ||= select_server(
+            cluster,
+            ServerSelector.primary,
+            session,
+            timeout: context.remaining_timeout_sec
+          )
+          server.with_connection(
+            connection_global_id: context.connection_global_id,
+            context: context
+          ) do |connection|
             # Legacy retries do not use txn_num
             yield connection, nil, context.dup
           end
-        rescue Error::OperationFailure => e
+        rescue Error::OperationFailure::Family => e
           e.add_note('legacy retry')
           e.add_note("attempt #{attempt}")
           server = nil
@@ -220,7 +233,10 @@ module Mongo
         txn_num = nil
         connection_succeeded = false
 
-        server.with_connection(connection_global_id: context.connection_global_id) do |connection|
+        server.with_connection(
+          connection_global_id: context.connection_global_id,
+          context: context
+        ) do |connection|
           connection_succeeded = true
 
           session.materialize_if_needed
@@ -230,10 +246,10 @@ module Mongo
           # it later for the retry as well.
           yield connection, txn_num, context.dup
         end
-      rescue *retryable_exceptions, Error::PoolError, Auth::Unauthorized, Error::OperationFailure => e
+      rescue *retryable_exceptions, Error::PoolError, Auth::Unauthorized, Error::OperationFailure::Family => e
         e.add_notes('modern retry', 'attempt 1')
 
-        if e.is_a?(Error::OperationFailure)
+        if e.is_a?(Error::OperationFailure::Family)
           ensure_retryable!(e)
         else
           ensure_labeled_retryable!(e, connection_succeeded, session)
@@ -256,6 +272,8 @@ module Mongo
       #
       # @return [ Result ] The result of the operation.
       def retry_write(original_error, txn_num, context:, failed_server: nil, &block)
+        context&.check_timeout!
+
         session = context.session
 
         # We do not request a scan of the cluster here, because error handling
@@ -263,7 +281,13 @@ module Mongo
         # server description and/or topology as necessary (specifically,
         # a socket error or a not master error should have marked the respective
         # server unknown). Here we just need to wait for server selection.
-        server = select_server(cluster, ServerSelector.primary, session, failed_server)
+        server = select_server(
+          cluster,
+          ServerSelector.primary,
+          session,
+          failed_server,
+          timeout: context.remaining_timeout_sec
+        )
 
         unless server.retry_writes?
           # Do not need to add "modern retry" here, it should already be on
@@ -279,14 +303,21 @@ module Mongo
           raise Error::RaiseOriginalError
         end
 
+        attempt = attempt ? attempt + 1 : 2
         log_retry(original_error, message: 'Write retry')
         server.with_connection(connection_global_id: context.connection_global_id) do |connection|
           yield(connection, txn_num, context)
         end
       rescue *retryable_exceptions, Error::PoolError => e
-        fail_on_retryable!(e, original_error)
-      rescue Error::OperationFailure => e
-        fail_on_operation_failure!(e, original_error)
+        maybe_fail_on_retryable(e, original_error, context, attempt)
+        failed_server = server
+        retry
+      rescue Error::OperationFailure::Family => e
+        maybe_fail_on_operation_failure(e, original_error, context, attempt)
+        failed_server = server
+        retry
+      rescue Mongo::Error::TimeoutError
+        raise
       rescue Error, Error::AuthError => e
         fail_on_other_error!(e, original_error)
       rescue Error::RaiseOriginalError
@@ -332,10 +363,10 @@ module Mongo
 
       # Raise either e, or original_error, depending on whether e is
       # write_retryable.
-      def fail_on_retryable!(e, original_error)
+      def maybe_fail_on_retryable(e, original_error, context, attempt)
         if e.write_retryable?
-          e.add_notes('modern retry', 'attempt 2')
-          raise e
+          e.add_notes('modern retry', "attempt #{attempt}")
+          raise e unless context&.deadline
         else
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error
@@ -344,11 +375,11 @@ module Mongo
 
       # Raise either e, or original_error, depending on whether e is
       # appropriately labeled.
-      def fail_on_operation_failure!(e, original_error)
+      def maybe_fail_on_operation_failure(e, original_error, context, attempt)
         e.add_note('modern retry')
         if e.label?('RetryableWriteError') && !e.label?('NoWritesPerformed')
-          e.add_note('attempt 2')
-          raise e
+          e.add_note("attempt #{attempt}")
+          raise e unless context&.deadline
         else
           original_error.add_note("later retry failed: #{e.class}: #{e}")
           raise original_error

data/lib/mongo/retryable.rb

@@ -46,8 +46,14 @@ module Mongo
     # @api private
     #
     # @return [ Mongo::Server ] A server matching the server preference.
-    def select_server(cluster, server_selector, session, failed_server = nil)
-      server_selector.select_server(cluster, nil, session, deprioritized: [failed_server].compact)
+    def select_server(cluster, server_selector, session, failed_server = nil, timeout: nil)
+      server_selector.select_server(
+        cluster,
+        nil,
+        session,
+        deprioritized: [failed_server].compact,
+        timeout: timeout
+      )
     end
 
     # Returns the read worker for handling retryable reads.

data/lib/mongo/search_index/view.rb

@@ -48,8 +48,8 @@ module Mongo
       # @param [ nil | String ] name The name to give the new search index.
       #
       # @return [ String ] the name of the new search index.
-      def create_one(definition, name: nil)
-        create_many([ { name: name, definition: definition } ]).first
+      def create_one(definition, name: nil, type: 'search')
+        create_many([ { name: name, definition: definition, type: type } ]).first
       end
 
       # Create multiple search indexes with a single command.
@@ -99,7 +99,7 @@ module Mongo
             s[:name] = requested_index_name if requested_index_name
           end
 
-          collection.aggregate(
+          collection.with(read_concern: {}).aggregate(
             [ { '$listSearchIndexes' => spec } ],
             aggregate_options
           )
@@ -200,7 +200,7 @@ module Mongo
       #
       # @raise [ ArgumentError ] if the list contains any invalid keys
       def validate_search_index_keys!(keys)
-        extras = keys - [ 'name', 'definition', :name, :definition ]
+        extras = keys - [ 'name', 'definition', 'type', :name, :definition, :type ]
 
         raise ArgumentError, "invalid keys in search index creation: #{extras.inspect}" if extras.any?
       end

data/lib/mongo/server/connection.rb

@@ -226,11 +226,11 @@ module Mongo
       # @return [ true ] If the connection succeeded.
       #
       # @since 2.0.0
-      def connect!
+      def connect!(context = nil)
         raise_if_closed!
 
         unless @socket
-          @socket = create_socket
+          @socket = create_socket(context)
           @description, @compressor = do_connect
 
           if server.load_balancer?
@@ -256,10 +256,16 @@ module Mongo
       #
       #
       # @return [ Socket ] The created socket.
-      private def create_socket
+      private def create_socket(context = nil)
         add_server_diagnostics do
-          address.socket(socket_timeout, ssl_options.merge(
-            connection_address: address, connection_generation: generation, pipe: options[:pipe]))
+          opts = ssl_options.merge(
+            connection_address: address,
+            connection_generation: generation,
+            pipe: options[:pipe],
+            connect_timeout: context&.remaining_timeout_sec,
+            csot: !!context&.csot?
+          )
+          address.socket(socket_timeout, opts)
         end
       end
 

data/lib/mongo/server/connection_base.rb

@@ -169,6 +169,7 @@ module Mongo
           raise Error::LintError, "Trying to deliver a message over a disconnected connection (to #{address})"
         end
         buffer = serialize(message, context)
+        check_timeout!(context)
         ensure_connected do |socket|
           operation_id = Monitoring.next_operation_id
           started_event = command_started(address, operation_id, message.payload,
@@ -181,9 +182,10 @@ module Mongo
           result = nil
           begin
             result = add_server_diagnostics do
-              socket.write(buffer.to_s)
+              socket.write(buffer.to_s, timeout: context.remaining_timeout_sec)
               if message.replyable?
-                Protocol::Message.deserialize(socket, max_message_size, message.request_id, options)
+                check_timeout!(context)
+                Protocol::Message.deserialize(socket, max_message_size, message.request_id, options.merge(timeout: context.remaining_timeout_sec))
               else
                 nil
               end
@@ -273,6 +275,24 @@ module Mongo
 
         buffer
       end
+
+      # If timeoutMS is set for the operation context, checks whether there is
+      # enough time left to send the corresponding message to the server
+      # (remaining timeout is bigger than minimum round trip time for
+      # the server)
+      #
+      # @param [ Mongo::Operation::Context ] context Context of the operation.
+      #
+      # @raise [ Mongo::Error::TimeoutError ] if timeout expired or there is
+      #   not enough time to send the message to the server.
+      def check_timeout!(context)
+        return if [nil, 0].include?(context.deadline)
+
+        time_to_execute = context.remaining_timeout_sec - server.minimum_round_trip_time
+        if time_to_execute <= 0
+          raise Mongo::Error::TimeoutError
+        end
+      end
     end
   end
 end

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/push_monitor.rb

@@ -104,7 +104,7 @@ module Mongo
         # include topology version. In this case we need to keep our existing
         # topology version so that we can resume monitoring.
         # The spec does not appear to directly address this case but
-        # https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-monitoring.rst#streaming-ismaster
+        # https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-monitoring.md#streamable-hello-or-legacy-hello-command
         # says that topologyVersion should only be updated from successful
         # hello responses.
         if new_description.topology_version

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'