mongo 2.18.1 → 2.19.0

data/lib/mongo/protocol/serializers.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -51,9 +51,11 @@ module Mongo
         #
         # @param buffer [ String ] Buffer to receive the serialized value.
         # @param value [ String ] Header value to be serialized.
+        # @param [ true, false ] validating_keys Whether keys should be validated when serializing.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_bytes(value.pack(HEADER_PACK))
         end
 
@@ -80,7 +82,7 @@ module Mongo
         # @param value [ String ] The string to be serialized.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_cstring(value)
         end
       end
@@ -96,7 +98,7 @@ module Mongo
         # @param value [ Fixnum ] Ignored value.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_int32(ZERO)
         end
       end
@@ -112,7 +114,7 @@ module Mongo
         # @param value [ Integer | BSON::Int32 ] 32-bit integer to be serialized.
         #
         # @return [String] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           if value.is_a?(BSON::Int32)
             if value.respond_to?(:value)
               # bson-ruby >= 4.6.0
@@ -146,7 +148,7 @@ module Mongo
         # @param value [ Integer | BSON::Int64 ] 64-bit integer to be serialized.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           if value.is_a?(BSON::Int64)
             if value.respond_to?(:value)
               # bson-ruby >= 4.6.0
@@ -182,19 +184,20 @@ module Mongo
         # @param [ Array<Hash, BSON::Document> ] value The sections to be serialized.
         # @param [ Fixnum ] max_bson_size The max bson size of documents in the sections.
         # @param [ true, false ] validating_keys Whether to validate document keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
           value.each do |section|
             case section[:type]
             when PayloadZero::TYPE
-              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size)
             when nil
-              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size)
             when PayloadOne::TYPE
-              PayloadOne.serialize(buffer, section[:payload], max_bson_size, validating_keys)
+              PayloadOne.serialize(buffer, section[:payload], max_bson_size)
             else
               raise Error::UnknownPayloadType.new(section[:type])
             end
@@ -259,13 +262,14 @@ module Mongo
           # @param [ BSON::Document, Hash ] value The object to serialize.
           # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
           # @param [ true, false ] validating_keys Whether to validate document keys.
+          #   This option is deprecated and will not be used. It will removed in version 3.0.
           #
           # @return [ BSON::ByteBuffer ] Buffer with serialized value.
           #
           # @since 2.5.0
-          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
             buffer.put_byte(TYPE_BYTE)
-            Serializers::Document.serialize(buffer, value, max_bson_size, validating_keys)
+            Serializers::Document.serialize(buffer, value, max_bson_size)
           end
 
           # Deserializes a section of payload type 0 of an OP_MSG from the IO stream.
@@ -307,17 +311,18 @@ module Mongo
           # @param [ BSON::Document, Hash ] value The object to serialize.
           # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
           # @param [ true, false ] validating_keys Whether to validate document keys.
+          #   This option is deprecated and will not be used. It will removed in version 3.0.
           #
           # @return [ BSON::ByteBuffer ] Buffer with serialized value.
           #
           # @since 2.5.0
-          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
             buffer.put_byte(TYPE_BYTE)
             start = buffer.length
             buffer.put_int32(0) # hold for size
             buffer.put_cstring(value[:identifier])
             value[:sequence].each do |document|
-              Document.serialize(buffer, document, max_bson_size, validating_keys)
+              Document.serialize(buffer, document, max_bson_size)
             end
             buffer.replace_int32(start, buffer.length - start)
           end
@@ -356,9 +361,9 @@ module Mongo
         # @param value [ Hash ] Document to serialize as BSON.
         #
         # @return [ String ] Buffer with serialized value.
-        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = nil)
           start_size = buffer.length
-          value.to_bson(buffer, validating_keys)
+          value.to_bson(buffer)
           serialized_size = buffer.length - start_size
           if max_bson_size && serialized_size > max_bson_size
             raise Error::MaxBSONSize,
@@ -401,11 +406,12 @@ module Mongo
         # @param [ BSON::ByteBuffer ] buffer Buffer to receive the single byte.
         # @param [ String ] value The byte to write to the buffer.
         # @param [ true, false ] validating_keys Whether to validate keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_byte(value)
         end
 
@@ -432,11 +438,12 @@ module Mongo
         # @param [ BSON::ByteBuffer ] buffer Buffer to receive the bytes.
         # @param [ String ] value The bytes to write to the buffer.
         # @param [ true, false ] validating_keys Whether to validate keys.
+        #   This option is deprecated and will not be used. It will removed in version 3.0.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
         # @since 2.5.0
-        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+        def self.serialize(buffer, value, validating_keys = nil)
           buffer.put_bytes(value)
         end
 

data/lib/mongo/protocol.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Wire Protocol Base
 require 'mongo/protocol/serializers'
@@ -10,12 +10,9 @@ require 'mongo/protocol/caching_hash'
 
 # Client Requests
 require 'mongo/protocol/compressed'
-require 'mongo/protocol/delete'
 require 'mongo/protocol/get_more'
-require 'mongo/protocol/insert'
 require 'mongo/protocol/kill_cursors'
 require 'mongo/protocol/query'
-require 'mongo/protocol/update'
 require 'mongo/protocol/msg'
 
 # Server Responses

data/lib/mongo/query_cache.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB, Inc.
 #
@@ -114,24 +114,24 @@ module Mongo
       #
       # @param [ Mongo::CachingCursor ] cursor The CachingCursor instance to store.
       #
-      # @option opts [ String | nil ] namespace The namespace of the query,
+      # @option opts [ String | nil ] :namespace The namespace of the query,
       #   in the format "database_name.collection_name".
-      # @option opts [ Array, Hash ] selector The selector passed to the query.
+      # @option opts [ Array, Hash ] :selector The selector passed to the query.
       #   For most queries, this will be a Hash, but for aggregations, this
       #   will be an Array representing the aggregation pipeline. May not be nil.
-      # @option opts [ Integer | nil ] skip The skip value of the query.
-      # @option opts [ Hash | nil ] sort The order of the query results
+      # @option opts [ Integer | nil ] :skip The skip value of the query.
+      # @option opts [ Hash | nil ] :sort The order of the query results
       #   (e.g. { name: -1 }).
-      # @option opts [ Integer | nil ] limit The limit value of the query.
-      # @option opts [ Hash | nil ] projection The projection of the query
+      # @option opts [ Integer | nil ] :limit The limit value of the query.
+      # @option opts [ Hash | nil ] :projection The projection of the query
       #   results (e.g. { name: 1 }).
-      # @option opts [ Hash | nil ] collation The collation of the query
+      # @option opts [ Hash | nil ] :collation The collation of the query
       #   (e.g. { "locale" => "fr_CA" }).
-      # @option opts [ Hash | nil ] read_concern The read concern of the query
+      # @option opts [ Hash | nil ] :read_concern The read concern of the query
       #   (e.g. { level: :majority }).
-      # @option opts [ Hash | nil ] read_preference The read preference of
+      # @option opts [ Hash | nil ] :read_preference The read preference of
       #   the query (e.g. { mode: :secondary }).
-      # @option opts [ Boolean | nil ] multi_collection Whether the query
+      # @option opts [ Boolean | nil ] :multi_collection Whether the query
       #   results could potentially come from multiple collections. When true,
       #   these results will be stored under the nil namespace key and cleared
       #   on every write command.
@@ -152,24 +152,24 @@ module Mongo
       # For the given query options, retrieve a cached cursor that can be used
       # to obtain the correct query results, if one exists in the cache.
       #
-      # @option opts [ String | nil ] namespace The namespace of the query,
+      # @option opts [ String | nil ] :namespace The namespace of the query,
       #   in the format "database_name.collection_name".
-      # @option opts [ Array, Hash ] selector The selector passed to the query.
+      # @option opts [ Array, Hash ] :selector The selector passed to the query.
       #   For most queries, this will be a Hash, but for aggregations, this
       #   will be an Array representing the aggregation pipeline. May not be nil.
-      # @option opts [ Integer | nil ] skip The skip value of the query.
-      # @option opts [ Hash | nil ] sort The order of the query results
+      # @option opts [ Integer | nil ] :skip The skip value of the query.
+      # @option opts [ Hash | nil ] :sort The order of the query results
       #   (e.g. { name: -1 }).
-      # @option opts [ Integer | nil ] limit The limit value of the query.
-      # @option opts [ Hash | nil ] projection The projection of the query
+      # @option opts [ Integer | nil ] :limit The limit value of the query.
+      # @option opts [ Hash | nil ] :projection The projection of the query
       #   results (e.g. { name: 1 }).
-      # @option opts [ Hash | nil ] collation The collation of the query
+      # @option opts [ Hash | nil ] :collation The collation of the query
       #   (e.g. { "locale" => "fr_CA" }).
-      # @option opts [ Hash | nil ] read_concern The read concern of the query
+      # @option opts [ Hash | nil ] :read_concern The read concern of the query
       #   (e.g. { level: :majority }).
-      # @option opts [ Hash | nil ] read_preference The read preference of
+      # @option opts [ Hash | nil ] :read_preference The read preference of
       #   the query (e.g. { mode: :secondary }).
-      # @option opts [ Boolean | nil ] multi_collection Whether the query
+      # @option opts [ Boolean | nil ] :multi_collection Whether the query
       #   results could potentially come from multiple collections. When true,
       #   these results will be stored under the nil namespace key and cleared
       #   on every write command.

data/lib/mongo/retryable/base_worker.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+# Copyright (C) 2015-2023 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  module Retryable
+
+    # The abstract superclass for workers employed by Mongo::Retryable.
+    #
+    # @api private
+    class BaseWorker
+      extend Forwardable
+
+      def_delegators :retryable,
+        :client,
+        :cluster,
+        :select_server
+
+      # @return [ Mongo::Retryable ] retryable A reference to the client object
+      #   that instatiated this worker.
+      attr_reader :retryable
+
+      # Constructs a new worker.
+      #
+      # @example Instantiating a new read worker
+      #   worker = Mongo::Retryable::ReadWorker.new(self)
+      #
+      # @example Instantiating a new write worker
+      #   worker = Mongo::Retryable::WriteWorker.new(self)
+      #
+      # @param [ Mongo::Retryable ] retryable The client object that is using
+      #   this worker to perform a retryable operation
+      def initialize(retryable)
+        @retryable = retryable
+      end
+
+      private
+
+      # Indicate which exception classes that are generally retryable. 
+      #
+      # @return [ Array<Mongo:Error> ] Array of exception classes that are
+      #   considered retryable.
+      def retryable_exceptions
+        [
+          Error::ConnectionPerished,
+          Error::ServerNotUsable,
+          Error::SocketError,
+          Error::SocketTimeoutError
+        ].freeze
+      end
+
+      # Tests to see if the given exception instance is of a type that can
+      # be retried.
+      #
+      # @return [ true | false ] true if the exception is retryable.
+      def is_retryable_exception?(e)
+        retryable_exceptions.any? { |klass| klass === e }
+      end
+
+      # Logs the given deprecation warning the first time it is called for a
+      # given key; after that, it does nothing when given the same key.
+      def deprecation_warning(key, warning)
+        $_deprecation_warnings ||= {}
+        unless $_deprecation_warnings[key]
+          $_deprecation_warnings[key] = true
+          Logger.logger.warn(warning)
+        end
+      end
+
+      # Log a warning so that any application slow down is immediately obvious.
+      def log_retry(e, options = nil)
+        message = (options || {}).fetch(:message, "Retry")
+        Logger.logger.warn "#{message} due to: #{e.class.name}: #{e.message}"
+      end
+    end
+
+  end
+end

data/lib/mongo/retryable/read_worker.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+# Copyright (C) 2015-2023 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'mongo/retryable/base_worker'
+
+module Mongo
+  module Retryable
+
+    # Implements the logic around retrying read operations.
+    #
+    # @api private
+    #
+    # @since 2.19.0
+    class ReadWorker < BaseWorker
+      # Execute a read operation returning a cursor with retrying.
+      #
+      # This method performs server selection for the specified server selector
+      # and yields to the provided block, which should execute the initial
+      # query operation and return its result. The block will be passed the
+      # server selected for the operation. If the block raises an exception,
+      # and this exception corresponds to a read retryable error, and read
+      # retries are enabled for the client, this method will perform server
+      # selection again and yield to the block again (with potentially a
+      # different server). If the block returns successfully, the result
+      # of the block (which should be a Mongo::Operation::Result) is used to
+      # construct a Mongo::Cursor object for the result set. The cursor
+      # is then returned.
+      #
+      # If modern retry reads are on (which is the default), the initial read
+      # operation will be retried once. If legacy retry reads are on, the
+      # initial read operation will be retried zero or more times depending
+      # on the :max_read_retries client setting, the default for which is 1.
+      # To disable read retries, turn off modern read retries by setting
+      # retry_reads: false and set :max_read_retries to 0 on the client.
+      #
+      # @api private
+      #
+      # @example Execute a read returning a cursor.
+      #   cursor = read_with_retry_cursor(session, server_selector, view) do |server|
+      #     # return a Mongo::Operation::Result
+      #     ...
+      #   end
+      #
+      # @param [ Mongo::Session ] session The session that the operation is being
+      #   run on.
+      # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
+      #   selector for the operation.
+      # @param [ CollectionView ] view The +CollectionView+ defining the query.
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Cursor ] The cursor for the result set.
+      def read_with_retry_cursor(session, server_selector, view, &block)
+        read_with_retry(session, server_selector) do |server|
+          result = yield server
+
+          # RUBY-2367: This will be updated to allow the query cache to
+          # cache cursors with multi-batch results.
+          if QueryCache.enabled? && !view.collection.system_collection?
+            CachingCursor.new(view, result, server, session: session)
+          else
+            Cursor.new(view, result, server, session: session)
+          end
+        end
+      end
+
+      # Execute a read operation with retrying.
+      #
+      # This method performs server selection for the specified server selector
+      # and yields to the provided block, which should execute the initial
+      # query operation and return its result. The block will be passed the
+      # server selected for the operation. If the block raises an exception,
+      # and this exception corresponds to a read retryable error, and read
+      # retries are enabled for the client, this method will perform server
+      # selection again and yield to the block again (with potentially a
+      # different server). If the block returns successfully, the result
+      # of the block is returned.
+      #
+      # If modern retry reads are on (which is the default), the initial read
+      # operation will be retried once. If legacy retry reads are on, the
+      # initial read operation will be retried zero or more times depending
+      # on the :max_read_retries client setting, the default for which is 1.
+      # To disable read retries, turn off modern read retries by setting
+      # retry_reads: false and set :max_read_retries to 0 on the client.
+      #
+      # @api private
+      #
+      # @example Execute the read.
+      #   read_with_retry(session, server_selector) do |server|
+      #     ...
+      #   end
+      #
+      # @param [ Mongo::Session | nil ] session The session that the operation
+      #   is being run on.
+      # @param [ Mongo::ServerSelector::Selectable | nil ] server_selector
+      #   Server selector for the operation.
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Result ] The result of the operation.
+      def read_with_retry(session = nil, server_selector = nil, &block)
+        if session.nil? && server_selector.nil?
+          deprecated_legacy_read_with_retry(&block)
+        elsif session&.retry_reads?
+          modern_read_with_retry(session, server_selector, &block)
+        elsif client.max_read_retries > 0
+          legacy_read_with_retry(session, server_selector, &block)
+        else
+          read_without_retry(session, server_selector, &block)
+        end
+      end
+
+      # Execute a read operation with a single retry on network errors.
+      #
+      # This method is used by the driver for some of the internal housekeeping
+      # operations. Application-requested reads should use read_with_retry
+      # rather than this method.
+      #
+      # @api private
+      #
+      # @example Execute the read.
+      #   read_with_one_retry do
+      #     ...
+      #   end
+      #
+      # @note This only retries read operations on socket errors.
+      #
+      # @param [ Hash | nil ] options Options.
+      #
+      # @option options [ String ] :retry_message Message to log when retrying.
+      #
+      # @yield Calls the provided block with no arguments
+      #
+      # @return [ Result ] The result of the operation.
+      #
+      # @since 2.2.6
+      def read_with_one_retry(options = nil)
+        yield
+      rescue *retryable_exceptions, Error::PoolError => e
+        raise e unless e.write_retryable?
+
+        retry_message = options && options[:retry_message]
+        log_retry(e, message: retry_message)
+        yield
+      end
+
+      private
+
+      # Attempts to do a legacy read_with_retry, without either a session or
+      # server_selector. This is a deprecated use-case, and a warning will be
+      # issued the first time this is invoked.
+      #
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Result ] The result of the operation.
+      def deprecated_legacy_read_with_retry(&block)
+        deprecation_warning :read_with_retry,
+          'Legacy read_with_retry invocation - ' \
+          'please update the application and/or its dependencies'
+
+        # Since we don't have a session, we cannot use the modern read retries.
+        # And we need to select a server but we don't have a server selector.
+        # Use PrimaryPreferred which will work as long as there is a data
+        # bearing node in the cluster; the block may select a different server
+        # which is fine.
+        server_selector = ServerSelector.get(mode: :primary_preferred)
+        legacy_read_with_retry(nil, server_selector, &block)
+      end
+
+      # Attempts to do a "modern" read with retry. Only a single retry will
+      # be attempted.
+      #
+      # @param [ Mongo::Session ] session The session that the operation is
+      #   being run on.
+      # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
+      #   selector for the operation.
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Result ] The result of the operation.
+      def modern_read_with_retry(session, server_selector, &block)
+        yield select_server(cluster, server_selector, session)
+      rescue *retryable_exceptions, Error::OperationFailure, Auth::Unauthorized, Error::PoolError => e
+        e.add_notes('modern retry', 'attempt 1')
+        raise e if session.in_transaction?
+        raise e if !is_retryable_exception?(e) && !e.write_retryable?
+        retry_read(e, session, server_selector, &block)
+      end
+  
+      # Attempts to do a "legacy" read with retry. The operation will be
+      # attempted multiple times, up to the client's `max_read_retries`
+      # setting.
+      #
+      # @param [ Mongo::Session ] session The session that the operation is
+      #   being run on.
+      # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
+      #   selector for the operation.
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Result ] The result of the operation.
+      def legacy_read_with_retry(session, server_selector, &block)
+        attempt = attempt ? attempt + 1 : 1
+        yield select_server(cluster, server_selector, session)
+      rescue *retryable_exceptions, Error::OperationFailure, Error::PoolError => e
+        e.add_notes('legacy retry', "attempt #{attempt}")
+        
+        if is_retryable_exception?(e)
+          raise e if attempt > client.max_read_retries || session&.in_transaction?
+        elsif e.retryable? && !session&.in_transaction?
+          raise e if attempt > client.max_read_retries
+        else
+          raise e
+        end
+        
+        log_retry(e, message: 'Legacy read retry')
+        sleep(client.read_retry_interval) unless is_retryable_exception?(e)
+        retry
+      end
+
+      # Attempts to do a read *without* a retry; for example, when retries have
+      # been explicitly disabled.
+      #
+      # @param [ Mongo::Session ] session The session that the operation is
+      #   being run on.
+      # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
+      #   selector for the operation.
+      # @param [ Proc ] block The block to execute.
+      #
+      # @return [ Result ] The result of the operation.
+      def read_without_retry(session, server_selector, &block)
+        server = select_server(cluster, server_selector, session)
+
+        begin
+          yield server
+        rescue *retryable_exceptions, Error::PoolError, Error::OperationFailure => e
+          e.add_note('retries disabled')
+          raise e
+        end
+      end
+
+      # The retry logic of the "modern" read_with_retry implementation.
+      #
+      # @param [ Exception ] original_error The original error that triggered
+      #   the retry.
+      # @param [ Mongo::Session ] session The session that the operation is
+      #   being run on.
+      # @param [ Mongo::ServerSelector::Selectable ] server_selector Server
+      #   selector for the operation.
+      # @param [ Proc ] block The block to execute.
+      # 
+      # @return [ Result ] The result of the operation.
+      def retry_read(original_error, session, server_selector, &block)
+        begin
+          server = select_server(cluster, server_selector, session)
+        rescue Error, Error::AuthError => e
+          original_error.add_note("later retry failed: #{e.class}: #{e}")
+          raise original_error
+        end
+  
+        log_retry(original_error, message: 'Read retry')
+  
+        begin
+          yield server, true
+        rescue *retryable_exceptions => e
+          e.add_notes('modern retry', 'attempt 2')
+          raise e
+        rescue Error::OperationFailure, Error::PoolError => e
+          e.add_note('modern retry')
+          unless e.write_retryable?
+            original_error.add_note("later retry failed: #{e.class}: #{e}")
+            raise original_error
+          end
+          e.add_note("attempt 2")
+          raise e
+        rescue Error, Error::AuthError => e
+          e.add_note('modern retry')
+          original_error.add_note("later retry failed: #{e.class}: #{e}")
+          raise original_error
+        end
+      end
+  
+    end
+
+  end
+end