mongo 2.20.1 → 2.21.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a641cd6128fd246b0ac9999f00167631548206573a22989968f2a7a132bc0ae
-  data.tar.gz: d5526d1ca34219ac644191f1e2c7177877c70063cc5a97992379e8e86065d0ca
+  metadata.gz: 047b2bd74446fc71cfe815c1610d47608078301092f8bbd29c0819f85fb1ed3c
+  data.tar.gz: 931d7cf1753c4bcdfc66a8d25867b591daa3027d653488dfe28023a55dc4f378
 SHA512:
-  metadata.gz: 4c23fd9abff5c29517b2cf0c0094bedfbbe667a96f2494b36e6465d8bbfbe113cd08f05e72d15b6db17ef35a211c4aaa040c20dc99eb65417c3c3690b7712c59
-  data.tar.gz: 54ffbc332168455337aa4de863db0ca179084a35c271e9f21dbfe2425556bd00e02b2fd46a5c2581aa15d5e9a11b84d9a0c231889774adb129f2ad38b997f4f4
+  metadata.gz: 843f969dc849f53be7531c3cc7cf0f2f0100b383eadf442709fbfa10aad89b56940c60351b06f68f9a08bf76896889bbb752d6d1dbfdef854dd2eccb673c93cf
+  data.tar.gz: 7568cad4a519464cffd3953f9183c4cf85d1fe9c4818e18bbefc9c5b82ec91f76ea228a51bd760a3be5f98e92275628452e65b96fe3d5f4b1f3f0435ab9ecdea

data/README.md

@@ -53,6 +53,9 @@ API documentation for the most recent release can be found
 To build API documentation for the master branch, check out the
 repository locally and run `rake docs`.
 
+High-level driver documentation including tutorials and the reference that were in the docs folder can now be found
+at the docs-ruby repository, [here](https://github.com/mongodb/docs-ruby)
+
 ## Support
 
 Commercial support for the driver is available through the
@@ -115,7 +118,7 @@ their applications.
 
 ## Running Tests
 
-Please refer to [spec/README.md](spec/README.md) for instructions on how
+Please refer to [spec/README.md](https://github.com/mongodb/mongo-ruby-driver/blob/master/spec/README.md) for instructions on how
 to run the driver's test suite.
 
 ## Release History

data/lib/mongo/address.rb

@@ -178,6 +178,9 @@ module Mongo
     # @param [ Hash ] opts The options.
     #
     # @option opts [ Float ] :connect_timeout Connect timeout.
+    # @option opts [ Boolean ] :csot Whether the client-side operation timeout
+    #   should be considered when connecting the socket. This option influences
+    #   only what errors will be raised if timeout expires.
     # @option opts [ true | false ] :ssl Whether to use SSL.
     # @option opts [ String ] :ssl_ca_cert
     #   Same as the corresponding Client/Socket::SSL option.
@@ -214,11 +217,12 @@ module Mongo
     # @since 2.0.0
     # @api private
     def socket(socket_timeout, opts = {})
+      csot = !!opts[:csot]
       opts = {
         connect_timeout: Server::CONNECT_TIMEOUT,
       }.update(options).update(Hash[opts.map { |k, v| [k.to_sym, v] }])
 
-      map_exceptions do
+      map_exceptions(csot) do
         if seed.downcase =~ Unix::MATCH
           specific_address = Unix.new(seed.downcase)
           return specific_address.socket(socket_timeout, opts)
@@ -281,11 +285,26 @@ module Mongo
       end
     end
 
-    def map_exceptions
+    # Maps some errors to different ones, mostly low-level errors to driver
+    # level errors
+    #
+    # @param [ Boolean ] csot Whether the client-side operation timeout
+    #   should be considered when connecting the socket.
+    def map_exceptions(csot)
       begin
         yield
       rescue Errno::ETIMEDOUT => e
-        raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{self})"
+        if csot
+          raise Error::TimeoutError, "#{e.class}: #{e} (for #{self})"
+        else
+          raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{self})"
+        end
+      rescue Error::SocketTimeoutError => e
+        if csot
+          raise Error::TimeoutError, "#{e.class}: #{e} (for #{self})"
+        else
+          raise e
+        end
       rescue IOError, SystemCallError => e
         raise Error::SocketError, "#{e.class}: #{e} (for #{self})"
       rescue OpenSSL::SSL::SSLError => e

data/lib/mongo/auth/aws/conversation.rb

@@ -22,7 +22,7 @@ module Mongo
       # Defines behavior around a single MONGODB-AWS conversation between the
       # client and server.
       #
-      # @see https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst#mongodb-aws
+      # @see https://github.com/mongodb/specifications/blob/master/source/auth/auth.md#mongodb-aws
       #
       # @api private
       class Conversation < SaslConversationBase

data/lib/mongo/auth/aws/credentials_retriever.rb

@@ -69,20 +69,24 @@ module Mongo
         # Retrieves a valid set of credentials, if possible, or raises
         # Auth::InvalidConfiguration.
         #
+        # @param [ CsotTimeoutHolder | nil ] timeout_holder CSOT timeout, if any.
+        #
         # @return [ Auth::Aws::Credentials ] A valid set of credentials.
         #
         # @raise Auth::InvalidConfiguration if a source contains an invalid set
         #   of credentials.
         # @raise Auth::Aws::CredentialsNotFound if credentials could not be
         #   retrieved from any source.
-        def credentials
+        # @raise Error::TimeoutError if credentials cannot be retrieved within
+        #   the timeout defined on the operation context.
+        def credentials(timeout_holder = nil)
           credentials = credentials_from_user(user)
           return credentials unless credentials.nil?
 
           credentials = credentials_from_environment
           return credentials unless credentials.nil?
 
-          credentials = @credentials_cache.fetch { obtain_credentials_from_endpoints }
+          credentials = @credentials_cache.fetch { obtain_credentials_from_endpoints(timeout_holder) }
           return credentials unless credentials.nil?
 
           raise Auth::Aws::CredentialsNotFound
@@ -127,17 +131,21 @@ module Mongo
 
         # Returns credentials from the AWS metadata endpoints.
         #
+        # @param [ CsotTimeoutHolder ] timeout_holder CSOT timeout.
+        #
         # @return [ Auth::Aws::Credentials | nil ] A set of credentials, or nil
         #   if retrieval failed or the obtained credentials are invalid.
         #
         # @raise Auth::InvalidConfiguration if a source contains an invalid set
         #   of credentials.
-        def obtain_credentials_from_endpoints
-          if (credentials = web_identity_credentials) && credentials_valid?(credentials, 'Web identity token')
+        # @ raise Error::TimeoutError if credentials cannot be retrieved within
+        #   the timeout defined on the operation context.
+        def obtain_credentials_from_endpoints(timeout_holder = nil)
+          if (credentials = web_identity_credentials(timeout_holder)) && credentials_valid?(credentials, 'Web identity token')
             credentials
-          elsif (credentials = ecs_metadata_credentials) && credentials_valid?(credentials, 'ECS task metadata')
+          elsif (credentials = ecs_metadata_credentials(timeout_holder)) && credentials_valid?(credentials, 'ECS task metadata')
             credentials
-          elsif (credentials = ec2_metadata_credentials) && credentials_valid?(credentials, 'EC2 instance metadata')
+          elsif (credentials = ec2_metadata_credentials(timeout_holder)) && credentials_valid?(credentials, 'EC2 instance metadata')
             credentials
           end
         end
@@ -145,21 +153,26 @@ module Mongo
         # Returns credentials from the EC2 metadata endpoint. The credentials
         # could be empty, partial or invalid.
         #
+        # @param [ CsotTimeoutHolder ] timeout_holder CSOT timeout.
+        #
         # @return [ Auth::Aws::Credentials | nil ] A set of credentials, or nil
         #   if retrieval failed.
-        def ec2_metadata_credentials
+        # @ raise Error::TimeoutError if credentials cannot be retrieved within
+        #   the timeout.
+        def ec2_metadata_credentials(timeout_holder = nil)
+          timeout_holder&.check_timeout!
           http = Net::HTTP.new('169.254.169.254')
           req = Net::HTTP::Put.new('/latest/api/token',
             # The TTL is required in order to obtain the metadata token.
             {'x-aws-ec2-metadata-token-ttl-seconds' => '30'})
-          resp = ::Timeout.timeout(METADATA_TIMEOUT) do
+          resp = with_timeout(timeout_holder) do
             http.request(req)
           end
           if resp.code != '200'
             return nil
           end
           metadata_token = resp.body
-          resp = ::Timeout.timeout(METADATA_TIMEOUT) do
+          resp = with_timeout(timeout_holder) do
             http_get(http, '/latest/meta-data/iam/security-credentials', metadata_token)
           end
           if resp.code != '200'
@@ -167,7 +180,7 @@ module Mongo
           end
           role_name = resp.body
           escaped_role_name = CGI.escape(role_name).gsub('+', '%20')
-          resp = ::Timeout.timeout(METADATA_TIMEOUT) do
+          resp = with_timeout(timeout_holder) do
             http_get(http, "/latest/meta-data/iam/security-credentials/#{escaped_role_name}", metadata_token)
           end
           if resp.code != '200'
@@ -189,7 +202,17 @@ module Mongo
           return nil
         end
 
-        def ecs_metadata_credentials
+        # Returns credentials from the ECS metadata endpoint. The credentials
+        # could be empty, partial or invalid.
+        #
+        # @param [ CsotTimeoutHolder | nil ] timeout_holder CSOT timeout.
+        #
+        # @return [ Auth::Aws::Credentials | nil ] A set of credentials, or nil
+        #   if retrieval failed.
+        # @ raise Error::TimeoutError if credentials cannot be retrieved within
+        #   the timeout defined on the operation context.
+        def ecs_metadata_credentials(timeout_holder = nil)
+          timeout_holder&.check_timeout!
           relative_uri = ENV['AWS_CONTAINER_CREDENTIALS_RELATIVE_URI']
           if relative_uri.nil? || relative_uri.empty?
             return nil
@@ -203,7 +226,7 @@ module Mongo
           # a leading slash must be added by the driver, but this is not
           # in fact needed.
           req = Net::HTTP::Get.new(relative_uri)
-          resp = ::Timeout.timeout(METADATA_TIMEOUT) do
+          resp = with_timeout(timeout_holder) do
             http.request(req)
           end
           if resp.code != '200'
@@ -225,13 +248,15 @@ module Mongo
         # inside EKS. See https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html
         # for further details.
         #
+        # @param [ CsotTimeoutHolder | nil ] timeout_holder CSOT timeout.
+        #
         # @return [ Auth::Aws::Credentials | nil ] A set of credentials, or nil
         #   if retrieval failed.
-        def web_identity_credentials
+        def web_identity_credentials(timeout_holder = nil)
           web_identity_token, role_arn, role_session_name = prepare_web_identity_inputs
           return nil if web_identity_token.nil?
           response = request_web_identity_credentials(
-            web_identity_token, role_arn, role_session_name
+            web_identity_token, role_arn, role_session_name, timeout_holder
           )
           return if response.nil?
           credentials_from_web_identity_response(response)
@@ -266,10 +291,15 @@ module Mongo
         #   that the caller is assuming.
         # @param [ String ] role_session_name An identifier for the assumed
         #   role session.
+        # @param [ CsotTimeoutHolder | nil ] timeout_holder CSOT timeout.
         #
         # @return [ Net::HTTPResponse | nil ] AWS API response if successful,
         #   otherwise nil.
-        def request_web_identity_credentials(token, role_arn, role_session_name)
+        #
+        # @ raise Error::TimeoutError if credentials cannot be retrieved within
+        #   the timeout defined on the operation context.
+        def request_web_identity_credentials(token, role_arn, role_session_name, timeout_holder)
+          timeout_holder&.check_timeout!
           uri = URI('https://sts.amazonaws.com/')
           params = {
             'Action' => 'AssumeRoleWithWebIdentity',
@@ -281,8 +311,10 @@ module Mongo
           uri.query = ::URI.encode_www_form(params)
           req = Net::HTTP::Post.new(uri)
           req['Accept'] = 'application/json'
-          resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |https|
-            https.request(req)
+          resp = with_timeout(timeout_holder) do
+            Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |https|
+              https.request(req)
+            end
           end
           if resp.code != '200'
             return nil
@@ -351,6 +383,27 @@ module Mongo
 
           true
         end
+
+        # Execute the given block considering the timeout defined on the context,
+        # or the default timeout value.
+        #
+        # We use +Timeout.timeout+ here because there is no other acceptable easy
+        # way to time limit http requests.
+        #
+        # @param [ CsotTimeoutHolder | nil ] timeout_holder CSOT timeout.
+        #
+        # @ raise Error::TimeoutError if deadline exceeded.
+        def with_timeout(timeout_holder)
+          timeout = timeout_holder&.remaining_timeout_sec! || METADATA_TIMEOUT
+          exception_class = if timeout_holder&.csot?
+                              Error::TimeoutError
+                            else
+                              nil
+                            end
+          ::Timeout.timeout(timeout, exception_class) do
+            yield
+          end
+        end
       end
     end
   end

data/lib/mongo/auth/base.rb

@@ -117,7 +117,7 @@ module Mongo
         else
           nil
         end
-        result = Operation::Result.new(reply, connection.description, connection_global_id)
+        result = Operation::Result.new(reply, connection.description, connection_global_id, context: context)
         connection.update_cluster_time(result)
         reply_document
       end

data/lib/mongo/auth/credential_cache.rb

@@ -22,19 +22,24 @@ module Mongo
     #
     # @api private
     module CredentialCache
-
       class << self
         attr_reader :store
       end
 
+      MUTEX = Mutex.new
+
       module_function def get(key)
-        @store ||= {}
-        @store[key]
+        MUTEX.synchronize do
+          @store ||= {}
+          @store[key]
+        end
       end
 
       module_function def set(key, value)
-        @store ||= {}
-        @store[key] = value
+        MUTEX.synchronize do
+          @store ||= {}
+          @store[key] = value
+        end
       end
 
       module_function def cache(key)
@@ -47,7 +52,9 @@ module Mongo
       end
 
       module_function def clear
-        @store = {}
+        MUTEX.synchronize do
+          @store = {}
+        end
       end
     end
   end

data/lib/mongo/bulk_write.rb

@@ -60,10 +60,15 @@ module Mongo
       result_combiner = ResultCombiner.new
       operations = op_combiner.combine
       validate_requests!
+      deadline = calculate_deadline
 
-      client.send(:with_session, @options) do |session|
-        context = Operation::Context.new(client: client, session: session)
+      client.with_session(@options) do |session|
         operations.each do |operation|
+          context = Operation::Context.new(
+            client: client,
+            session: session,
+            operation_timeouts: { operation_timeout_ms: op_timeout_ms(deadline) }
+          )
           if single_statement?(operation)
             write_concern = write_concern(session)
             write_with_retry(write_concern, context: context) do |connection, txn_num, context|
@@ -124,6 +129,9 @@ module Mongo
       @collection = collection
       @requests = requests
       @options = options || {}
+      if @options[:timeout_ms] && @options[:timeout_ms] < 0
+        raise ArgumentError, "timeout_ms options must be non-negative integer"
+      end
     end
 
     # Is the bulk write ordered?
@@ -162,6 +170,31 @@ module Mongo
                              :update_one,
                              :insert_one ].freeze
 
+    # @return [ Float | nil ] Deadline for the batch of operations, if set.
+    def calculate_deadline
+      timeout_ms = @options[:timeout_ms] || collection.timeout_ms
+      return nil if timeout_ms.nil?
+
+      if timeout_ms == 0
+        0
+      else
+        Utils.monotonic_time + (timeout_ms / 1_000.0)
+      end
+    end
+
+    # @param [ Float | nil ] deadline Deadline for the batch of operations.
+    #
+    # @return [ Integer | nil ] Timeout in milliseconds for the next operation.
+    def op_timeout_ms(deadline)
+      return nil if deadline.nil?
+
+      if deadline == 0
+        0
+      else
+        ((deadline - Utils.monotonic_time) * 1_000).to_i
+      end
+    end
+
     def single_statement?(operation)
       SINGLE_STATEMENT_OPS.include?(operation.keys.first)
     end

data/lib/mongo/client.rb

@@ -111,6 +111,7 @@ module Mongo
       :ssl_verify_certificate,
       :ssl_verify_hostname,
       :ssl_verify_ocsp_endpoint,
+      :timeout_ms,
       :truncate_logs,
       :user,
       :wait_queue_timeout,
@@ -349,7 +350,8 @@ module Mongo
     # @option options [ Integer ] :server_selection_timeout The timeout in seconds
     #   for selecting a server for an operation.
     # @option options [ Float ] :socket_timeout The timeout, in seconds, to
-    #   execute operations on a socket.
+    #   execute operations on a socket. This option is deprecated, use
+    #   :timeout_ms instead.
     # @option options [ Integer ] :srv_max_hosts The maximum number of mongoses
     #   that the driver will communicate with for sharded topologies. If this
     #   option is 0, then there will be no maximum number of mongoses. If the
@@ -413,11 +415,15 @@ module Mongo
     # @option options [ true, false ] :ssl_verify_hostname Whether to perform peer hostname
     #   validation. This setting overrides :ssl_verify with respect to whether hostname validation
     #   is performed.
+    # @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 feature is not enabled.
     # @option options [ true, false ] :truncate_logs Whether to truncate the
     #   logs at the default 250 characters.
     # @option options [ String ] :user The user name.
     # @option options [ Float ] :wait_queue_timeout The time to wait, in
     #   seconds, in the connection pool for a connection to be checked in.
+    #   This option is deprecated, use :timeout_ms instead.
     # @option options [ Array<Hash> ] :wrapping_libraries Information about
     #   libraries such as ODMs that are wrapping the driver, to be added to
     #    metadata sent to the server. Specify the lower level libraries first.
@@ -425,7 +431,7 @@ module Mongo
     # @option options [ Hash ] :write Deprecated. Equivalent to :write_concern
     #   option.
     # @option options [ Hash ] :write_concern The write concern options.
-    #   Can be :w => Integer|String, :wtimeout => Integer (in milliseconds),
+    #   Can be :w => Integer|String, :wtimeout => Integer (in milliseconds, deprecated),
     #   :j => Boolean, :fsync => Boolean.
     # @option options [ Integer ] :zlib_compression_level The Zlib compression level to use, if using compression.
     #   See Ruby's Zlib module for valid levels.
@@ -496,35 +502,15 @@ module Mongo
     def initialize(addresses_or_uri, options = nil)
       options = options ? options.dup : {}
 
-      srv_uri = nil
-      if addresses_or_uri.is_a?(::String)
-        uri = URI.get(addresses_or_uri, options)
-        if uri.is_a?(URI::SRVProtocol)
-          # If the URI is an SRV URI, note this so that we can start
-          # SRV polling if the topology is a sharded cluster.
-          srv_uri = uri
-        end
-        addresses = uri.servers
-        uri_options = uri.client_options.dup
-        # Special handing for :write and :write_concern: allow client Ruby
-        # options to override URI options, even when the Ruby option uses the
-        # deprecated :write key and the URI option uses the current
-        # :write_concern key
-        if options[:write]
-          uri_options.delete(:write_concern)
-        end
-        options = uri_options.merge(options)
-        @srv_records = uri.srv_records
-      else
-        addresses = addresses_or_uri
-        addresses.each do |addr|
-          if addr =~ /\Amongodb(\+srv)?:\/\//i
-            raise ArgumentError, "Host '#{addr}' should not contain protocol. Did you mean to not use an array?"
-          end
-        end
+      processed = process_addresses(addresses_or_uri, options)
 
-        @srv_records = nil
-      end
+      uri = processed[:uri]
+      addresses = processed[:addresses]
+      options = processed[:options]
+
+      # If the URI is an SRV URI, note this so that we can start
+      # SRV polling if the topology is a sharded cluster.
+      srv_uri = uri if uri.is_a?(URI::SRVProtocol)
 
       options = self.class.canonicalize_ruby_options(options)
 
@@ -934,8 +920,11 @@ module Mongo
     #   See https://mongodb.com/docs/manual/reference/command/listDatabases/
     #   for more information and usage.
     # @option opts [ Session ] :session The session to use.
-    # @option options [ Object ] :comment A user-provided
+    # @option opts [ Object ] :comment A user-provided
     #   comment to attach to this command.
+    # @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 feature is not enabled.
     #
     # @return [ Array<String> ] The names of the databases.
     #
@@ -955,7 +944,12 @@ module Mongo
     #
     # @option opts [ true, false ] :authorized_databases A flag that determines
     #   which databases are returned based on user privileges when access control
-    #   is enabled
+    #   is enabled.
+    # @option opts [ Object ] :comment A user-provided
+    #   comment to attach to this command.
+    # @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 feature is not enabled.
     #
     #   See https://mongodb.com/docs/manual/reference/command/listDatabases/
     #   for more information and usage.
@@ -1095,7 +1089,7 @@ module Mongo
       return use(Database::ADMIN).watch(pipeline, options) unless database.name == Database::ADMIN
 
       view_options = options.dup
-      view_options[:await_data] = true if options[:max_await_time_ms]
+      view_options[:cursor_type] = :tailable_await if options[:max_await_time_ms]
 
       Mongo::Collection::View::ChangeStream.new(
         Mongo::Collection::View.new(self["#{Database::COMMAND}.aggregate"], {}, view_options),
@@ -1185,8 +1179,91 @@ module Mongo
       @encrypted_fields_map ||= @options.fetch(:auto_encryption_options, {})[:encrypted_fields_map]
     end
 
+    # @return [ Integer | nil ] Value of timeout_ms option if set.
+    # @api private
+    def timeout_ms
+      @options[:timeout_ms]
+    end
+
+    # @return [ Float | nil ] Value of timeout_ms option converted to seconds.
+    # @api private
+    def timeout_sec
+      if timeout_ms.nil?
+        nil
+      else
+        timeout_ms / 1_000.0
+      end
+    end
+
     private
 
+    # Attempts to parse the given list of addresses, using the provided options.
+    #
+    # @param [ String | Array<String> ] addresses the list of addresses
+    # @param [ Hash ] options the options that may drive how the list is
+    #   processed.
+    #
+    # @return [ Hash<:uri, :addresses, :options> ] the results of processing the
+    #   list of addresses.
+    def process_addresses(addresses, options)
+      if addresses.is_a?(String)
+        process_addresses_string(addresses, options)
+      else
+        process_addresses_array(addresses, options)
+      end
+    end
+
+    # Attempts to parse the given list of addresses, using the provided options.
+    #
+    # @param [ String ] addresses the list of addresses
+    # @param [ Hash ] options the options that may drive how the list is
+    #   processed.
+    #
+    # @return [ Hash<:uri, :addresses, :options> ] the results of processing the
+    #   list of addresses.
+    def process_addresses_string(addresses, options)
+      {}.tap do |processed|
+        processed[:uri] = uri = URI.get(addresses, options)
+        processed[:addresses] = uri.servers
+
+        uri_options = uri.client_options.dup
+        # Special handing for :write and :write_concern: allow client Ruby
+        # options to override URI options, even when the Ruby option uses the
+        # deprecated :write key and the URI option uses the current
+        # :write_concern key
+        if options[:write]
+          uri_options.delete(:write_concern)
+        end
+
+        processed[:options] = uri_options.merge(options)
+
+        @srv_records = uri.srv_records
+      end
+    end
+
+    # Attempts to parse the given list of addresses, using the provided options.
+    #
+    # @param [ Array<String> ] addresses the list of addresses
+    # @param [ Hash ] options the options that may drive how the list is
+    #   processed.
+    #
+    # @return [ Hash<:uri, :addresses, :options> ] the results of processing the
+    #   list of addresses.
+    def process_addresses_array(addresses, options)
+      {}.tap do |processed|
+        processed[:addresses] = addresses
+        processed[:options] = options
+
+        addresses.each do |addr|
+          if addr =~ /\Amongodb(\+srv)?:\/\//i
+            raise ArgumentError, "Host '#{addr}' should not contain protocol. Did you mean to not use an array?"
+          end
+        end
+
+        @srv_records = nil
+      end
+    end
+
     # Create a new encrypter object using the client's auto encryption options
     def build_encrypter
       @encrypter = Crypt::AutoEncrypter.new(
@@ -1230,6 +1307,8 @@ module Mongo
     # @option options [ true | false ] :implicit When no session is passed in,
     #   whether to create an implicit session.
     # @option options [ Session ] :session The session to validate and return.
+    # @option options [ Operation::Context | nil ] :context Context of the
+    #   operation the session is used for.
     #
     # @return [ Session ] A session object.
     #
@@ -1242,7 +1321,7 @@ module Mongo
         return options[:session].validate!(self)
       end
 
-      cluster.validate_session_support!
+      cluster.validate_session_support!(timeout: timeout_sec)
 
       options = {implicit: true}.update(options)
 

data/lib/mongo/client_encryption.rb

@@ -40,6 +40,9 @@ module Mongo
     #   should be hashes of TLS connection options. The options are equivalent
     #   to TLS connection options of Mongo::Client.
     #   @see Mongo::Client#initialize for list of TLS options.
+    # @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 feature is disabled.
     #
     # @raise [ ArgumentError ] If required options are missing or incorrectly
     #   formatted.
@@ -131,7 +134,7 @@ module Mongo
     #     {'$and' =>  [{'$gt' => ['$field', 10]}, {'$lt' => ['$field', 20]}}
     #   )
     #   {$and: [{$gt: [<fieldpath>, <value1>]}, {$lt: [<fieldpath>, <value2>]}]
-    # Only supported when queryType is "rangePreview" and algorithm is "RangePreview".
+    # Only supported when queryType is "range" and algorithm is "Range".
     # @note: The Range algorithm is experimental only. It is not intended
     #   for public use. It is subject to breaking changes.
     #
@@ -143,11 +146,11 @@ module Mongo
     # @option options [ String ] :key_alt_name The alternate name for the
     #   encryption key.
     # @option options [ String ] :algorithm The algorithm used to encrypt the
-    #   expression. The only allowed value is "RangePreview"
+    #   expression. The only allowed value is "Range"
     # @option options [ Integer | nil ] :contention_factor Contention factor
     #   to be applied If not  provided, it defaults to a value of 0.
     # @option options [ String | nil ] query_type Query type to be applied.
-    #   The only allowed value is "rangePreview".
+    #   The only allowed value is "range".
     #
     # @note The :key_id and :key_alt_name options are mutually exclusive. Only
     #   one is required to perform explicit encryption.
@@ -291,7 +294,7 @@ module Mongo
     def create_data_keys(encrypted_fields, kms_provider, master_key)
       encrypted_fields = encrypted_fields.dup
       # We must return the partially formed encrypted_fields hash if an error
-      # occurs - https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/client-side-encryption.rst#create-encrypted-collection-helper
+      # occurs - https://github.com/mongodb/specifications/blob/master/source/client-side-encryption/client-side-encryption.md#create-encrypted-collection-helper
       # Thefore, we do this in a loop instead of using #map.
       encrypted_fields[:fields].size.times do |i|
         field = encrypted_fields[:fields][i]