mongo 2.24.1 → 2.26.0

data/lib/mongo/operation/drop_database/op_msg.rb

@@ -24,6 +24,7 @@ module Mongo
       # @since 2.5.2
       class OpMsg < OpMsgBase
         include ExecutableTransactionLabel
+        include CausalConsistencySupported
       end
     end
   end

data/lib/mongo/operation/drop_index/op_msg.rb

@@ -24,6 +24,7 @@ module Mongo
       # @since 2.5.2
       class OpMsg < OpMsgBase
         include ExecutableTransactionLabel
+        include CausalConsistencySupported
 
         private
 

data/lib/mongo/operation/find/builder/command.rb

@@ -60,7 +60,7 @@ module Mongo
                 end
               end
 
-              if rc = selector[:readConcern]
+              if (rc = selector[:readConcern])
                 selector[:readConcern] = Options::Mapper.transform_values_to_strings(rc)
               end
 

data/lib/mongo/operation/insert/bulk_result.rb

@@ -47,11 +47,9 @@ module Mongo
         # @since 2.0.0
         # @api private
         def initialize(replies, connection_description, connection_global_id, ids)
-          @replies = [ *replies ] if replies
-          @connection_description = connection_description
-          @connection_global_id = connection_global_id
+          super(replies, connection_description, connection_global_id)
           if replies && replies.first && (doc = replies.first.documents.first)
-            if errors = doc['writeErrors']
+            if (errors = doc['writeErrors'])
               # some documents were potentially inserted
               bad_indices = {}
               errors.map do |error|

data/lib/mongo/operation/insert/op_msg.rb

@@ -28,6 +28,7 @@ module Mongo
         include ExecutableNoValidate
         include ExecutableTransactionLabel
         include PolymorphicResult
+        include CausalConsistencySupported
 
         private
 

data/lib/mongo/operation/result.rb

@@ -162,15 +162,6 @@ module Mongo
         !!@replies
       end
 
-      # Whether the result contains cursor_id
-      #
-      # @return [ true, false ] If the result contains cursor_id.
-      #
-      # @api private
-      def has_cursor_id?
-        acknowledged? && replies.last.respond_to?(:cursor_id)
-      end
-
       # Get the cursor id if the response is acknowledged.
       #
       # @note Cursor ids of 0 indicate there is no cursor on the server.
@@ -183,7 +174,17 @@ module Mongo
       # @since 2.0.0
       # @api private
       def cursor_id
-        acknowledged? ? replies.last.cursor_id : 0
+        return 0 unless acknowledged?
+
+        if replies.last.respond_to?(:cursor_id)
+          # Legacy OP_REPLY replies expose the cursor id directly.
+          replies.last.cursor_id
+        elsif first_document.key?(CURSOR)
+          # OP_MSG command replies carry the cursor id in the `cursor` subdocument.
+          first_document[CURSOR][CURSOR_ID] || 0
+        else
+          0
+        end
       end
 
       # Get the namespace of the cursor. The method should be defined in
@@ -450,11 +451,20 @@ module Mongo
       end
 
       def snapshot_timestamp
-        return unless doc = reply.documents.first
+        return unless (doc = reply.documents.first)
 
         doc['cursor']&.[]('atClusterTime') || doc['atClusterTime']
       end
 
+      # Returns the base backoff in milliseconds for a server overload error, if present.
+      #
+      # @return [ Integer | nil ] The base backoff in milliseconds.
+      #
+      # @api private
+      def base_backoff_ms
+        first_document && first_document['baseBackoffMS']
+      end
+
       private
 
       def operation_failure_class
@@ -465,20 +475,6 @@ module Mongo
         end
       end
 
-      def aggregate_returned_count
-        replies.reduce(0) do |n, reply|
-          n += reply.number_returned
-          n
-        end
-      end
-
-      def aggregate_written_count
-        documents.reduce(0) do |n, document|
-          n += document[N] || 0
-          n
-        end
-      end
-
       def parser
         @parser ||= Error::Parser.new(first_document, replies)
       end

data/lib/mongo/operation/shared/causal_consistency_supported.rb

@@ -28,8 +28,10 @@ module Mongo
       #
       # This method overrides the causal consistency addition logic of
       # SessionsSupported and is meant to be used with operations classified
-      # as "read operations accepting a read concern", as these are defined
-      # in the causal consistency spec.
+      # as "read and write operations accepting a read concern", as these are
+      # defined in the causal consistency spec. For write operations this
+      # attaches only afterClusterTime (no read concern level) so that causal
+      # ordering is preserved across writes in a causally consistent session.
       #
       # In order for the override to work correctly the
       # CausalConsistencySupported module must be included after

data/lib/mongo/operation/shared/executable.rb

@@ -64,14 +64,6 @@ module Mongo
                     end
                   end
 
-                  if result.has_cursor_id? &&
-                     connection.description.load_balancer?
-                    if result.cursor_id == 0
-                      connection.unpin
-                    else
-                      connection.pin
-                    end
-                  end
                   process_result(result, connection)
                 end
               end
@@ -121,7 +113,7 @@ module Mongo
       # @param [ Mongo::Operation::Context ] context The operation context.
       def build_message(connection, context)
         msg = message(connection)
-        if server_api = context.server_api
+        if (server_api = context.server_api)
           msg = msg.maybe_add_server_api(server_api)
         end
         msg
@@ -140,12 +132,7 @@ module Mongo
       def process_result_for_sdam(result, connection)
         if (result.not_master? || result.node_recovering?) &&
            connection.generation >= connection.server.pool.generation(service_id: connection.service_id)
-          keep_pool = if result.node_shutting_down?
-                        false
-                      else
-                        # Max wire version needs to be examined while the server is known
-                        connection.description.server_version_gte?('4.2')
-                      end
+          keep_pool = !result.node_shutting_down?
 
           connection.server.unknown!(
             keep_connection_pool: keep_pool,

data/lib/mongo/operation/shared/result/aggregatable.rb

@@ -36,7 +36,7 @@ module Mongo
           return unless @replies
 
           @replies.reduce(nil) do |errors, reply|
-            next unless write_errors = reply.documents.first['writeErrors']
+            next unless (write_errors = reply.documents.first['writeErrors'])
 
             wes = write_errors.collect do |we|
               we.merge!('index' => count + we['index'])
@@ -59,7 +59,7 @@ module Mongo
           return unless @replies
 
           @replies.each_with_index.reduce(nil) do |errors, (reply, _)|
-            next unless write_concern_errors = reply.documents.first['writeConcernErrors']
+            next unless (write_concern_errors = reply.documents.first['writeConcernErrors'])
 
             (errors || []) << write_concern_errors.reduce(nil) do |errs, wce|
               wce.merge!('index' => count + wce['index'])

data/lib/mongo/operation/shared/sessions_supported.rb

@@ -61,7 +61,7 @@ module Mongo
       def apply_causal_consistency_if_possible(selector, connection)
         return if connection.description.standalone?
 
-        cc_doc = session.send(:causal_consistency_doc)
+        cc_doc = session.causal_consistency_doc
         return unless cc_doc
 
         rc_doc = (selector[:readConcern] || read_concern || {}).merge(cc_doc)
@@ -165,9 +165,7 @@ module Mongo
         read_doc = if connection.description.standalone?
                      # Read preference is never sent to standalones.
                      nil
-                   elsif connection.server.load_balancer?
-                     read&.to_mongos
-                   elsif connection.description.mongos?
+                   elsif connection.server.load_balancer? || connection.description.mongos?
                      # When server is a mongos:
                      # - $readPreference is never sent when mode is 'primary'
                      # - Otherwise $readPreference is sent
@@ -243,7 +241,7 @@ module Mongo
         end
 
         super.tap do |message|
-          if session = context.session
+          if (session = context.session)
             # Serialize the message to detect client-side problems,
             # such as invalid BSON keys or too large messages.
             # The message will be serialized again

data/lib/mongo/operation/update/bulk_result.rb

@@ -107,7 +107,7 @@ module Mongo
           return [] unless acknowledged?
 
           @replies.reduce([]) do |ids, reply|
-            if upserted_ids = reply.documents.first[UPSERTED]
+            if (upserted_ids = reply.documents.first[UPSERTED])
               ids += upserted_ids
             end
             ids

data/lib/mongo/operation/update/op_msg.rb

@@ -27,6 +27,7 @@ module Mongo
         include ExecutableNoValidate
         include ExecutableTransactionLabel
         include PolymorphicResult
+        include CausalConsistencySupported
 
         private
 

data/lib/mongo/operation/write_command/op_msg.rb

@@ -21,6 +21,8 @@ module Mongo
       #
       # @api private
       class OpMsg < OpMsgBase
+        include CausalConsistencySupported
+
         private
 
         def selector(connection)

data/lib/mongo/operation.rb

@@ -38,6 +38,7 @@ require 'mongo/operation/drop'
 require 'mongo/operation/drop_database'
 require 'mongo/operation/get_more'
 require 'mongo/operation/find'
+require 'mongo/operation/cursor_command'
 require 'mongo/operation/explain'
 require 'mongo/operation/kill_cursors'
 require 'mongo/operation/indexes'

data/lib/mongo/options/redacted.rb

@@ -143,14 +143,14 @@ module Mongo
 
       def redacted_string(method)
         '{' + reduce([]) do |list, (k, v)|
-          list << "#{k.send(method)}=>#{redact(k, v, method)}"
+          list << "#{k.public_send(method)}=>#{redact(k, v, method)}"
         end.join(', ') + '}'
       end
 
       def redact(k, v, method)
         return STRING_REPLACEMENT if SENSITIVE_OPTIONS.include?(k.to_sym)
 
-        v.send(method)
+        v.public_send(method)
       end
     end
   end

data/lib/mongo/protocol/compressed.rb

@@ -74,12 +74,15 @@ module Mongo
       #
       # @since 2.5.0
       def initialize(message, compressor, zlib_compression_level = nil)
+        super()
         @original_message = message
         @original_op_code = message.op_code
         @uncompressed_size = 0
         @compressor_id = COMPRESSOR_ID_MAP[compressor]
         @compressed_message = ''
         @zlib_compression_level = zlib_compression_level if zlib_compression_level && zlib_compression_level != -1
+        # A compressed message must reuse the wrapped message's request id,
+        # overriding the fresh id assigned by the superclass initializer.
         @request_id = message.request_id
       end
 
@@ -93,11 +96,11 @@ module Mongo
         message = Registry.get(@original_op_code).allocate
         buf = decompress(@compressed_message)
 
-        message.send(:fields).each do |field|
+        message.fields.each do |field|
           if field[:multi]
-            Message.deserialize_array(message, buf, field)
+            message.deserialize_array(buf, field)
           else
-            Message.deserialize_field(message, buf, field)
+            message.deserialize_field(buf, field)
           end
         end
         message.fix_after_deserialization if message.is_a?(Msg)
@@ -116,6 +119,15 @@ module Mongo
         @original_message.replyable?
       end
 
+      # @api private
+      def serialize_fields(buffer, max_bson_size)
+        buf = BSON::ByteBuffer.new
+        @original_message.serialize_fields(buf, max_bson_size)
+        @uncompressed_size = buf.length
+        @compressed_message = compress(buf)
+        super
+      end
+
       private
 
       # The operation code for a +Compressed+ message.
@@ -140,14 +152,6 @@ module Mongo
       # @return [ String ] The actual compressed message bytes.
       field :compressed_message, Bytes
 
-      def serialize_fields(buffer, max_bson_size)
-        buf = BSON::ByteBuffer.new
-        @original_message.send(:serialize_fields, buf, max_bson_size)
-        @uncompressed_size = buf.length
-        @compressed_message = compress(buf)
-        super
-      end
-
       def compress(buffer)
         if @compressor_id == NOOP_BYTE
           buffer.to_s.force_encoding(BSON::BINARY)

data/lib/mongo/protocol/message.rb

@@ -148,10 +148,6 @@ module Mongo
       # @return [ Mongo::Protocol::Msg ] The decrypted message, or the original
       #   message if decryption was not possible or necessary.
       def maybe_decrypt(_context)
-        # TODO: determine if we should be decrypting data coming from pre-4.2
-        # servers, potentially using legacy wire protocols. If so we need
-        # to implement decryption for those wire protocols as our current
-        # encryption/decryption code is OP_MSG-specific.
         self
       end
 
@@ -268,11 +264,11 @@ module Mongo
         buf = BSON::ByteBuffer.new(chunk)
 
         message = Registry.get(_op_code).allocate
-        message.send(:fields).each do |field|
+        message.fields.each do |field|
           if field[:multi]
-            deserialize_array(message, buf, field, options)
+            message.deserialize_array(buf, field, options)
           else
-            deserialize_field(message, buf, field, options)
+            message.deserialize_field(buf, field, options)
           end
         end
         message.fix_after_deserialization if message.is_a?(Msg)
@@ -369,7 +365,6 @@ module Mongo
       # deserialized field specified in the class by the field dsl under
       # the key +:multi+
       #
-      # @param message [Message] Message to contain the deserialized array.
       # @param io [IO] Stream containing the array to deserialize.
       # @param field [Hash] Hash representing a field.
       # @param options [ Hash ]
@@ -377,18 +372,17 @@ module Mongo
       # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
       #   each of the elements in this array using BSON types wherever possible.
       #
-      # @return [Message] Message with deserialized array.
+      # @return [Array] The deserialized array.
       # @api private
-      def self.deserialize_array(message, io, field, options = {})
+      def deserialize_array(io, field, options = {})
         elements = []
-        count = message.instance_variable_get(field[:multi])
+        count = instance_variable_get(field[:multi])
         count.times { elements << field[:type].deserialize(io, options) }
-        message.instance_variable_set(field[:name], elements)
+        instance_variable_set(field[:name], elements)
       end
 
-      # Deserializes a single field in a message
+      # Deserializes a single field into this message.
       #
-      # @param message [Message] Message to contain the deserialized field.
       # @param io [IO] Stream containing the field to deserialize.
       # @param field [Hash] Hash representing a field.
       # @param options [ Hash ]
@@ -396,20 +390,19 @@ module Mongo
       # @option options [ Boolean ] :deserialize_as_bson Whether to deserialize
       #   this field using BSON types wherever possible.
       #
-      # @return [Message] Message with deserialized field.
+      # @return [Object] The deserialized field value.
       # @api private
-      def self.deserialize_field(message, io, field, options = {})
-        message.instance_variable_set(
+      def deserialize_field(io, field, options = {})
+        instance_variable_set(
           field[:name],
           field[:type].deserialize(io, options)
         )
       end
 
-      private
-
       # A method for getting the fields for a message class
       #
-      # @return [Integer] the fields for the message class
+      # @return [Array<Hash>] The fields for the message class
+      # @api private
       def fields
         self.class.fields
       end
@@ -418,6 +411,7 @@ module Mongo
       #
       # @param buffer [String] buffer to receive the field
       # @return [String] buffer with serialized field
+      # @api private
       def serialize_fields(buffer, max_bson_size = nil)
         fields.each do |field|
           value = instance_variable_get(field[:name])
@@ -437,6 +431,8 @@ module Mongo
         end
       end
 
+      private
+
       # Serializes the header of the message consisting of 4 32bit integers
       #
       # The integers represent a message length placeholder (calculation of

data/lib/mongo/protocol/msg.rb

@@ -201,23 +201,12 @@ module Mongo
       # represents one of the command types allow-listed by libmongocrypt and it
       # contains data that is required to be encrypted by a local or remote json schema.
       #
-      # @param [ Mongo::Server::Connection ] connection The connection on which
-      #   the operation is performed.
       # @param [ Mongo::Operation::Context ] context The operation context.
       #
       # @return [ Mongo::Protocol::Msg ] The encrypted message, or the original
       #   message if encryption was not possible or necessary.
-      def maybe_encrypt(connection, context)
+      def maybe_encrypt(_connection, context)
         if context.encrypt?
-          if connection.description.max_wire_version < 8
-            raise Error::CryptError.new(
-              'Cannot perform encryption against a MongoDB server older than ' +
-              '4.2 (wire version less than 8). Currently connected to server ' +
-              "with max wire version #{connection.description.max_wire_version}} " +
-              '(Auto-encryption requires a minimum MongoDB version of 4.2)'
-            )
-          end
-
           db_name = @main_document[DATABASE_IDENTIFIER]
           cmd = merge_sections
           enc_cmd = context.encrypt(db_name, cmd)

data/lib/mongo/protocol/registry.rb

@@ -36,7 +36,7 @@ module Mongo
       #
       # @since 2.5.0
       def get(op_code, _message = nil)
-        if type = MAPPINGS[op_code]
+        if (type = MAPPINGS[op_code])
           type
         else
           handle_unsupported_op_code!(op_code)

data/lib/mongo/protocol/serializers.rb

@@ -181,9 +181,7 @@ module Mongo
         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)
-            when nil
+            when PayloadZero::TYPE, nil
               PayloadZero.serialize(buffer, section[:payload], max_bson_size)
             when PayloadOne::TYPE
               PayloadOne.serialize(buffer, section[:payload], max_bson_size)

data/lib/mongo/query_cache.rb

@@ -199,11 +199,9 @@ module Mongo
         # Otherwise, return nil because the stored cursor will not satisfy
         # the query.
 
-        if limit && (caching_cursor_limit.nil? || caching_cursor_limit >= limit)
-          caching_cursor
-        elsif limit.nil? && caching_cursor_limit.nil?
-          caching_cursor
-        end
+        return unless caching_cursor_limit.nil? || (limit && caching_cursor_limit >= limit)
+
+        caching_cursor
       end
 
       def normalized_limit(limit)

data/lib/mongo/retryable/backpressure.rb

@@ -23,9 +23,24 @@ module Mongo
       #   a random value. Can be injected for deterministic testing.
       #
       # @return [ Float ] The backoff delay in seconds.
-      def self.backoff_delay(attempt, jitter: rand)
-        jitter * [ MAX_BACKOFF, BASE_BACKOFF * (2**(attempt - 1)) ].min
+      def self.backoff_delay(attempt, jitter: rand, err: nil)
+        jitter * [ MAX_BACKOFF, base_backoff(err) * (2**attempt) ].min
       end
+
+      def self.base_backoff(err)
+        return BASE_BACKOFF if err.nil?
+        return BASE_BACKOFF unless err.respond_to?(:result) && err.result.respond_to?(:base_backoff_ms)
+
+        base_backoff_ms = err.result.base_backoff_ms
+
+        if base_backoff_ms && base_backoff_ms > 0
+          err.result.base_backoff_ms / 1000.0
+        else
+          BASE_BACKOFF
+        end
+      end
+
+      private_class_method :base_backoff
     end
   end
 end

data/lib/mongo/retryable/read_worker.rb

@@ -340,7 +340,7 @@ module Mongo
       def overload_read_retry(last_error, session, server_selector, context, failed_server, error_count:)
         last_was_overload = true
         loop do
-          delay = last_was_overload ? retry_policy.backoff_delay(error_count) : 0
+          delay = last_was_overload ? retry_policy.backoff_delay(error_count, err: last_error) : 0
           raise last_error unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
           log_retry(last_error, message: 'Read retry (overload backoff)')

data/lib/mongo/retryable/retry_policy.rb

@@ -27,8 +27,8 @@ module Mongo
       # @param [ Float ] jitter A random float in [0.0, 1.0).
       #
       # @return [ Float ] The backoff delay in seconds.
-      def backoff_delay(attempt, jitter: rand)
-        Backpressure.backoff_delay(attempt, jitter: jitter)
+      def backoff_delay(attempt, jitter: rand, err: nil)
+        Backpressure.backoff_delay(attempt, jitter: jitter, err: err)
       end
 
       # Determine whether an overload retry should be attempted.

data/lib/mongo/retryable/write_worker.rb

@@ -123,7 +123,7 @@ module Mongo
               unless e.respond_to?(:label?) && e.label?('NoWritesPerformed')
                 error_to_raise = e
               end
-              delay = retry_policy.backoff_delay(error_count)
+              delay = retry_policy.backoff_delay(error_count, err: e)
               raise error_to_raise unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
               log_retry(e, message: 'Write retry (overload backoff)')
@@ -386,7 +386,7 @@ module Mongo
         last_was_overload = true
 
         loop do
-          delay = last_was_overload ? retry_policy.backoff_delay(error_count) : 0
+          delay = last_was_overload ? retry_policy.backoff_delay(error_count, err: last_error) : 0
           raise error_to_raise unless retry_policy.should_retry_overload?(error_count, delay, context: context)
 
           log_retry(last_error, message: 'Write retry (overload backoff)')

data/lib/mongo/retryable.rb

@@ -129,7 +129,7 @@ module Mongo
 
         error_count += 1
         policy = client.retry_policy
-        delay = policy.backoff_delay(error_count)
+        delay = policy.backoff_delay(error_count, err: e)
         raise e unless policy.should_retry_overload?(error_count, delay, context: context)
 
         Logger.logger.warn("Overload retry due to: #{e.class.name}: #{e.message}")

data/lib/mongo/server/app_metadata.rb

@@ -130,7 +130,7 @@ module Mongo
             doc[:driver] = driver_doc
             doc[:os] = os_doc
             doc[:platform] = platform_string
-            doc[:backpressure] = true
+            doc[:backpressure] = '2'
             env_doc.tap { |env| doc[:env] = env if env }
           end
       end

data/lib/mongo/server/connection.rb

@@ -88,6 +88,7 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(server, options = {})
+        super()
         if server.load_balancer? && options[:generation]
           raise ArgumentError, 'Generation cannot be set when server is a load balancer'
         end
@@ -422,7 +423,8 @@ module Mongo
           generation: e.generation,
           # or description.service_id?
           service_id: e.service_id,
-          stop_push_monitor: true
+          stop_push_monitor: true,
+          network_error: true
         )
         raise
       rescue Error::SocketTimeoutError => e

data/lib/mongo/server/connection_common.rb

@@ -99,6 +99,14 @@ module Mongo
         end
       end
 
+      # Closes the underlying socket, if one is open, to interrupt an
+      # in-progress blocking read on the connection.
+      #
+      # @api private
+      def interrupt_socket
+        socket&.close
+      end
+
       private
 
       HELLO_DOC = BSON::Document.new({ hello: 1 }).freeze
@@ -112,7 +120,7 @@ module Mongo
 
         return unless options[:compressors]
 
-        if intersection = (server_compressors & options[:compressors])
+        if (intersection = (server_compressors & options[:compressors]))
           @compressor = intersection.first
         else
           msg = if server_compressors

data/lib/mongo/server/connection_pool/generation_manager.rb

@@ -125,7 +125,7 @@ module Mongo
 
         # Close all fds scheduled for closing.
         def close_all_scheduled
-          while pipe = @scheduled_for_close.pop
+          while (pipe = @scheduled_for_close.pop)
             pipe.close
           end
         end