mongo 2.19.1 → 2.21.0

data/lib/mongo/server/app_metadata/environment.rb

@@ -18,9 +18,12 @@ module Mongo
   class Server
     class AppMetadata
       # Implements the logic from the handshake spec, for deducing and
-      # reporting the current FaaS environment in which the program is
+      # reporting the current environment in which the program is
       # executing.
       #
+      # This includes FaaS environment checks, as well as checks for the
+      # presence of a container (Docker) and/or orchestrator (Kubernetes).
+      #
       # @api private
       class Environment
         # Error class for reporting that too many discriminators were found
@@ -39,6 +42,10 @@ module Mongo
         # Error class for reporting that the value for a field is too long.
         class ValueTooLong < Mongo::Error; end
 
+        # The name and location of the .dockerenv file that will signal the
+        # presence of Docker.
+        DOCKERENV_PATH = '/.dockerenv'
+
         # This value is not explicitly specified in the spec, only implied to be
         # less than 512.
         MAXIMUM_VALUE_LENGTH = 500
@@ -102,9 +109,11 @@ module Mongo
         # if the environment contains invalid or contradictory state, it will
         # be initialized with {{name}} set to {{nil}}.
         def initialize
+          @fields = {}
           @error = nil
           @name = detect_environment
-          populate_fields
+          populate_faas_fields
+          detect_container
         rescue TooManyEnvironments => e
           self.error = "too many environments detected: #{e.message}"
         rescue MissingVariable => e
@@ -115,6 +124,23 @@ module Mongo
           self.error = "value for #{e.message} is too long"
         end
 
+        # Queries the detected container information.
+        #
+        # @return [ Hash | nil ] the detected container information, or
+        #    nil if no container was detected.
+        def container
+          fields[:container]
+        end
+
+        # Queries whether any environment information was able to be
+        # detected.
+        #
+        # @return [ true | false ] if any environment information was
+        #   detected.
+        def present?
+          @name || fields.any?
+        end
+
         # Queries whether the current environment is a valid FaaS environment.
         #
         # @return [ true | false ] whether the environment is a FaaS
@@ -159,14 +185,11 @@ module Mongo
           @name == 'vercel'
         end
 
-        # Compiles the detected environment information into a Hash. It will
-        # always include a {{name}} key, but may include other keys as well,
-        # depending on the detected FaaS environment. (See the handshake
-        # spec for details.)
+        # Compiles the detected environment information into a Hash.
         #
         # @return [ Hash ] the detected environment information.
         def to_h
-          fields.merge(name: name)
+          name ? fields.merge(name: name) : fields
         end
 
         private
@@ -192,6 +215,38 @@ module Mongo
           names.first
         end
 
+        # Looks for the presence of a container. Currently can detect
+        # Docker (by the existence of a .dockerenv file in the root
+        # directory) and Kubernetes (by the existence of the KUBERNETES_SERVICE_HOST
+        # environment variable).
+        def detect_container
+          runtime = docker_present? && 'docker'
+          orchestrator = kubernetes_present? && 'kubernetes'
+
+          return unless runtime || orchestrator
+
+          fields[:container] = {}
+          fields[:container][:runtime] = runtime if runtime
+          fields[:container][:orchestrator] = orchestrator if orchestrator
+        end
+
+        # Checks for the existence of a .dockerenv in the root directory.
+        def docker_present?
+          File.exist?(dockerenv_path)
+        end
+
+        # Implementing this as a method so that it can be mocked in tests, to
+        # test the presence or absence of Docker.
+        def dockerenv_path
+          DOCKERENV_PATH
+        end
+
+        # Checks for the presence of a non-empty KUBERNETES_SERVICE_HOST
+        # environment variable.
+        def kubernetes_present?
+          !ENV['KUBERNETES_SERVICE_HOST'].to_s.empty?
+        end
+
         # Determines whether the named environment variable exists, and (if
         # a pattern has been declared for that descriminator) whether the
         # pattern matches the value of the variable.
@@ -212,10 +267,10 @@ module Mongo
         # Extracts environment information from the current environment
         # variables, based on the detected FaaS environment. Populates the
         # {{@fields}} instance variable.
-        def populate_fields
+        def populate_faas_fields
           return unless name
 
-          @fields = FIELDS[name].each_with_object({}) do |(var, defn), fields|
+          FIELDS[name].each_with_object(@fields) do |(var, defn), fields|
             fields[defn[:field]] = extract_field(var, defn)
           end
         end

data/lib/mongo/server/app_metadata.rb

@@ -187,13 +187,14 @@ module Mongo
         }
       end
 
-      # Returns the environment doc describing the current FaaS environment.
+      # Returns the environment doc describing the current execution
+      # environment.
       #
-      # @return [ Hash | nil ] the environment doc (or nil if not in a FaaS
-      #   environment).
+      # @return [ Hash | nil ] the environment doc (or nil if no relevant
+      #    environment info was detected)
       def env_doc
         env = Environment.new
-        env.faas? ? env.to_h : nil
+        env.present? ? env.to_h : nil
       end
 
       def type

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

@@ -48,6 +48,7 @@ module Mongo
           # provided by the client during findAndModify operations, requiring the
           # driver to raise client-side errors when those options are provided.
           find_and_modify_option_validation: 8,
+          sharded_transactions: 8,
           transactions: 7,
           scram_sha_256: 7,
           array_filters: 6,
@@ -82,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

@@ -110,6 +110,24 @@ module Mongo
 
       private
 
+      # Sends the hello command to the server, then receive and deserialize
+      # the response.
+      #
+      # This method is extracted to be mocked in the tests.
+      #
+      # @param [ Protocol::Message ] Command that should be sent to a server
+      #   for handshake purposes.
+      #
+      # @return [ Mongo::Protocol::Reply ] Deserialized server response.
+      def get_handshake_response(hello_command)
+        @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)
+          end
+        end
+      end
+
       # @param [ BSON::Document | nil ] speculative_auth_doc The document to
       #   provide in speculativeAuthenticate field of handshake command.
       #
@@ -131,12 +149,7 @@ module Mongo
         doc = nil
         @server.handle_handshake_failure! do
           begin
-            response = @server.round_trip_time_averager.measure do
-              add_server_diagnostics do
-                socket.write(hello_command.serialize.to_s)
-                Protocol::Message.deserialize(socket, Protocol::Message::MAX_MESSAGE_SIZE)
-              end
-            end
+            response = get_handshake_response(hello_command)
             result = Operation::Result.new([response])
             result.validate!
             doc = result.documents.first
@@ -155,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
@@ -205,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'