mongo 2.19.0 → 2.19.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '073817a77e166171b32b6531b111a273bd327d754e65e0b10c8e21d750afe861'
-  data.tar.gz: a133671749199aa848a5ba068fc586922bb4e1494e33eec976240e488e7fa66a
+  metadata.gz: 455d5b9685fd2cefa18a1c37e81ddb97a177ac8e40b9298945e4f126ac9ce093
+  data.tar.gz: fab0630edde803ab5125536159e8fbd12d3f0bac233e87d40ea1e414287145ac
 SHA512:
-  metadata.gz: d7aeab7c0494cab55b75f3c1b7ab1ec8c5e301cf6a29d8eb927c3176106d9885d67898d3c0b9a8d494f4546b3db3bbd6bd316398d85aa30edeebbb0335461955
-  data.tar.gz: cd5e5d4fd5de2b2503b8ff15e8408ad41e08e2a37f3547152e33742b385908956dae63bffdffda88f05456a5e43bc57c2f6086d5391074ea7e1724ea2a7fad1b
+  metadata.gz: f3db945520bf825c31fcd7a21295b03257b1ee01d3d2eb6903f69ae6dfdbb0834516c8214227196702f88e087754780a876941eb5a3ac8f0861bff40a3e55a07
+  data.tar.gz: 73ea3f0a4fc86ba9922c1054f925db03eab8ac3da47bd9b9daae5006af1f32299c3d1a45104623126db5c89e41bf3ddbfe82dd641ea77dce6d8936a5297a1880

data/lib/mongo/client.rb

@@ -71,6 +71,7 @@ module Mongo
       :local_threshold,
       :logger,
       :log_prefix,
+      :max_connecting,
       :max_idle_time,
       :max_pool_size,
       :max_read_retries,
@@ -266,6 +267,12 @@ module Mongo
     # @option options [ String ] :log_prefix A custom log prefix to use when
     #   logging. This option is experimental and subject to change in a future
     #   version of the driver.
+    # @option options [ Integer ] :max_connecting The maximum number of
+    #  connections that can be connecting simultaneously. The default is 2.
+    #  This option should be increased if there are many threads that share
+    #  the same client and the application is experiencing timeouts
+    #  while waiting for connections to be established.
+    #  selecting a server for an operation. The default is 2.
     # @option options [ Integer ] :max_idle_time The maximum seconds a socket can remain idle
     #   since it has been checked in to the pool.
     # @option options [ Integer ] :max_pool_size The maximum size of the
@@ -1318,6 +1325,7 @@ module Mongo
         key = k.to_sym
         if VALID_OPTIONS.include?(key)
           validate_max_min_pool_size!(key, opts)
+          validate_max_connecting!(key, opts)
           validate_read!(key, opts)
           if key == :compressors
             compressors = valid_compressors(v)
@@ -1580,6 +1588,23 @@ module Mongo
       true
     end
 
+    # Validates whether the max_connecting option is valid.
+    #
+    # @param [ Symbol ] option The option to validate.
+    # @param [ Hash ] opts The client options.
+    #
+    # @return [ true ] If the option is valid.
+    # @raise [ Error::InvalidMaxConnecting ] If the option is invalid.
+    def validate_max_connecting!(option, opts)
+      if option == :max_connecting && opts.key?(:max_connecting)
+        max_connecting = opts[:max_connecting] || Server::ConnectionPool::DEFAULT_MAX_CONNECTING
+        if max_connecting <= 0
+          raise Error::InvalidMaxConnecting.new(opts[:max_connecting])
+        end
+      end
+      true
+    end
+
     def validate_read!(option, opts)
       if option == :read && opts.has_key?(:read)
         read = opts[:read]

data/lib/mongo/collection/view/iterable.rb

@@ -185,6 +185,8 @@ module Mongo
             collection.client.log_warn("The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later")
           end
 
+          maybe_set_tailable_options(spec)
+
           if explained?
             spec[:explain] = options[:explain]
             Operation::Explain.new(spec)
@@ -200,6 +202,19 @@ module Mongo
         def use_query_cache?
           QueryCache.enabled? && !collection.system_collection?
         end
+
+        # Add tailable cusror options to the command specifiction if needed.
+        #
+        # @param [ Hash ] spec The command specification.
+        def maybe_set_tailable_options(spec)
+          case cursor_type
+          when :tailable
+            spec[:tailable] = true
+          when :tailable_await
+            spec[:tailable] = true
+            spec[:await_data] = true
+          end
+        end
       end
     end
   end

data/lib/mongo/collection/view.rb

@@ -127,6 +127,7 @@ module Mongo
       #   return in each response from MongoDB.
       # @option options [ Hash ] :collation The collation to use.
       # @option options [ String ] :comment Associate a comment with the query.
+      # @option options [ :tailable, :tailable_await ] :cursor_type The type of cursor to use.
       # @option options [ Hash ] :explain Execute an explain with the provided
       #   explain options (known options are :verbose and :verbosity) rather
       #   than a find.

data/lib/mongo/collection.rb

@@ -314,7 +314,9 @@ module Mongo
     #
     # @since 2.0.0
     def capped?
-      database.read_command(:collstats => name).documents[0][CAPPED]
+      database.list_collections(filter: { name: name })
+        .first
+        &.dig('options', CAPPED) || false
     end
 
     # Force the collection to be created in the database.

data/lib/mongo/error/invalid_max_connecting.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2014-present 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
+  class Error
+    # Exception that is raised when trying to create a client with an invalid
+    #   max_connecting option.
+    class InvalidMaxConnecting < Error
+      # Instantiate the new exception.
+      def initialize(max_connecting)
+        super("Invalid max_connecting: #{max_connecting}. Please ensure that it is greater than zero. ")
+      end
+    end
+  end
+end

data/lib/mongo/error.rb

@@ -159,6 +159,7 @@ require 'mongo/error/invalid_database_name'
 require 'mongo/error/invalid_document'
 require 'mongo/error/invalid_file'
 require 'mongo/error/invalid_file_revision'
+require 'mongo/error/invalid_max_connecting'
 require 'mongo/error/invalid_min_pool_size'
 require 'mongo/error/invalid_read_option'
 require 'mongo/error/invalid_application_name'

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

@@ -30,7 +30,6 @@ module Mongo
 
       READ_COMMANDS = [
         :aggregate,
-        :collStats,
         :count,
         :dbStats,
         :distinct,

data/lib/mongo/server/connection_pool.rb

@@ -29,12 +29,16 @@ module Mongo
       # The default max size for the connection pool.
       #
       # @since 2.9.0
-      DEFAULT_MAX_SIZE = 20.freeze
+      DEFAULT_MAX_SIZE = 20
 
       # The default min size for the connection pool.
       #
       # @since 2.9.0
-      DEFAULT_MIN_SIZE = 0.freeze
+      DEFAULT_MIN_SIZE = 0
+
+      # The default maximum number of connections that can be connecting at
+      # any given time.
+      DEFAULT_MAX_CONNECTING = 2
 
       # The default timeout, in seconds, to wait for a connection.
       #
@@ -61,6 +65,11 @@ module Mongo
       #
       # @option options [ Integer ] :max_size The maximum pool size. Setting
       #   this option to zero creates an unlimited connection pool.
+      # @option options [ Integer ] :max_connecting The maximum number of
+      #  connections that can be connecting simultaneously. The default is 2.
+      #  This option should be increased if there are many threads that share
+      #  same connection pool and the application is experiencing timeouts
+      #  while waiting for connections to be established.
       # @option options [ Integer ] :max_pool_size Deprecated.
       #   The maximum pool size. If max_size is also given, max_size and
       #   max_pool_size must be identical.
@@ -89,6 +98,7 @@ module Mongo
       #   any connections created by the pool.
       #
       # @since 2.0.0, API changed in 2.9.0
+
       def initialize(server, options = {})
         unless server.is_a?(Server)
           raise ArgumentError, 'First argument must be a Server instance'
@@ -146,7 +156,7 @@ module Mongo
         # Condition variable to enforce the first check in check_out: max_pool_size.
         # This condition variable should be signaled when the number of
         # unavailable connections decreases (pending + pending_connections +
-        # available_connections).
+        # checked_out_connections).
         @size_cv = Mongo::ConditionVariable.new(@lock)
         # This represents the number of threads that have made it past the size_cv
         # gate but have not acquired a connection to add to the pending_connections
@@ -157,7 +167,7 @@ module Mongo
         # Thei condition variable should be signaled when the number of pending
         # connections decreases.
         @max_connecting_cv = Mongo::ConditionVariable.new(@lock)
-        @max_connecting = options.fetch(:max_connecting, 2)
+        @max_connecting = options.fetch(:max_connecting, DEFAULT_MAX_CONNECTING)
 
         ObjectSpace.define_finalizer(self, self.class.finalize(@available_connections, @pending_connections, @populator))
 
@@ -1074,7 +1084,8 @@ module Mongo
           "from pool for #{@server.address}#{connection_global_id_msg} after #{wait_timeout} sec. " +
           "Connections in pool: #{@available_connections.length} available, " +
           "#{@checked_out_connections.length} checked out, " +
-          "#{@pending_connections.length + @connection_requests} pending " +
+          "#{@pending_connections.length} pending, " +
+          "#{@connection_requests} connections requests " +
           "(max size: #{max_size})"
         raise Error::ConnectionCheckOutTimeout.new(msg, address: @server.address)
       end
@@ -1170,7 +1181,6 @@ module Mongo
       # one. If no connection exists and the pool is at max size, wait until
       # a connection is checked back into the pool.
       #
-      # @param [ Float ] deadline The deadline to get the connection.
       # @param [ Integer ] pid The current process id.
       # @param [ Integer ] connection_global_id The global id for the
       #   connection to check out.
@@ -1180,17 +1190,22 @@ module Mongo
       # @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 get_connection(deadline, pid, connection_global_id)
+      def get_connection(pid, connection_global_id)
         if connection = next_available_connection(connection_global_id)
           unless valid_available_connection?(connection, pid, connection_global_id)
             return nil
           end
 
+          # We've got a connection, so we decrement the number of connection
+          # requests.
+          # We do not need to signal condition variable here, because
+          # because the execution will continue, and we signal later.
+          @connection_requests -= 1
+
           # If the connection is connected, it's not considered a
           # "pending connection". The pending_connections list represents
           # the set of connections that are awaiting connection.
           unless connection.connected?
-            @connection_requests -= 1
             @pending_connections << connection
           end
           return connection
@@ -1207,6 +1222,9 @@ module Mongo
                   Monitoring::Event::Cmap::ConnectionCheckOutFailed::CONNECTION_ERROR
                 ),
               )
+              # We're going to raise, so we need to decrement the number of
+              # connection requests.
+              decrement_connection_requests_and_signal
               raise Error::MissingConnection.new
             end
           end
@@ -1237,7 +1255,6 @@ module Mongo
         connection = nil
 
         @lock.synchronize do
-
           # The first gate to checking out a connection. Make sure the number of
           # unavailable connections is less than the max pool size.
           until max_size == 0 || unavailable_connections < max_size
@@ -1247,60 +1264,97 @@ module Mongo
             raise_if_not_ready!
           end
           @connection_requests += 1
+          connection = wait_for_connection(connection_global_id, deadline)
+        end
 
-          while connection.nil?
-            # The second gate to checking out a connection. Make sure 1) there
-            # exists an available connection and 2) we are under max_connecting.
-            until @available_connections.any? || @pending_connections.length < @max_connecting
-              wait = deadline - Utils.monotonic_time
-              raise_check_out_timeout!(connection_global_id) if wait <= 0
-              @max_connecting_cv.wait(wait)
-              raise_if_not_ready!
-            end
+        connect_or_raise(connection) unless connection.connected?
 
-            connection = get_connection(deadline, Process.pid, connection_global_id)
-            wait = deadline - Utils.monotonic_time
-            raise_check_out_timeout!(connection_global_id) if connection.nil? && wait <= 0
+        @lock.synchronize do
+          @checked_out_connections << connection
+          if @pending_connections.include?(connection)
+            @pending_connections.delete(connection)
           end
+          @max_connecting_cv.signal
+          # no need to signal size_cv here since the number of unavailable
+          # connections is unchanged.
         end
 
-        begin
-          connect_connection(connection)
-        rescue Exception
-          # Handshake or authentication failed
-          @lock.synchronize do
-            if @pending_connections.include?(connection)
-              @pending_connections.delete(connection)
-            else
-              @connection_requests -= 1
+        connection
+      end
+
+      # Waits for a connection to become available, or raises is no connection
+      # becomes available before the timeout.
+      # @param [ Integer ] connection_global_id The global id for the
+      #   connection to check out.
+      # @param [ Float ] deadline The time at which to stop waiting.
+      #
+      # @return [ Mongo::Server::Connection ] The checked out connection.
+      def wait_for_connection(connection_global_id, deadline)
+        connection = nil
+        while connection.nil?
+          # The second gate to checking out a connection. Make sure 1) there
+          # exists an available connection and 2) we are under max_connecting.
+          until @available_connections.any? || @pending_connections.length < @max_connecting
+            wait = deadline - Utils.monotonic_time
+            if wait <= 0
+              # We are going to raise a timeout error, so the connection
+              # request is not going to be fulfilled. Decrement the counter
+              # here.
+              decrement_connection_requests_and_signal
+              raise_check_out_timeout!(connection_global_id)
             end
-            @max_connecting_cv.signal
-            @size_cv.signal
+            @max_connecting_cv.wait(wait)
+            # We do not need to decrement the connection_requests counter
+            # or signal here because the pool is not ready yet.
+            raise_if_not_ready!
           end
-          @populate_semaphore.signal
 
-          publish_cmap_event(
-            Monitoring::Event::Cmap::ConnectionCheckOutFailed.new(
-              @server.address,
-              Monitoring::Event::Cmap::ConnectionCheckOutFailed::CONNECTION_ERROR
-            ),
-          )
-          raise
+          connection = get_connection(Process.pid, connection_global_id)
+          wait = deadline - Utils.monotonic_time
+          if connection.nil? && wait <= 0
+            # connection is nil here, it means that get_connection method
+            # did not create a new connection; therefore, it did not decrease
+            # the connection_requests counter. We need to do it here.
+            decrement_connection_requests_and_signal
+            raise_check_out_timeout!(connection_global_id)
+          end
         end
 
+        connection
+      end
+
+      # Connects a connection and raises an exception if the connection
+      # 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)
+      rescue Exception
+        # Handshake or authentication failed
         @lock.synchronize do
-          @checked_out_connections << connection
           if @pending_connections.include?(connection)
             @pending_connections.delete(connection)
-          else
-            @connection_requests -= 1
           end
           @max_connecting_cv.signal
-          # no need to signal size_cv here since the number of unavailable
-          # connections is unchanged.
+          @size_cv.signal
         end
+        @populate_semaphore.signal
+        publish_cmap_event(
+          Monitoring::Event::Cmap::ConnectionCheckOutFailed.new(
+            @server.address,
+            Monitoring::Event::Cmap::ConnectionCheckOutFailed::CONNECTION_ERROR
+          ),
+        )
+        raise
+      end
 
-        connection
+
+      # Decrement connection requests counter and signal the condition
+      # variables that the number of unavailable connections has decreased.
+      def decrement_connection_requests_and_signal
+        @connection_requests -= 1
+        @max_connecting_cv.signal
+        @size_cv.signal
       end
     end
   end

data/lib/mongo/uri/options_mapper.rb

@@ -285,6 +285,7 @@ module Mongo
       uri_option 'maxStalenessSeconds', :max_staleness, group: :read, type: :max_staleness
 
       # Pool options
+      uri_option 'maxConnecting', :max_connecting, type: :integer
       uri_option 'minPoolSize', :min_pool_size, type: :integer
       uri_option 'maxPoolSize', :max_pool_size, type: :integer
       uri_option 'waitQueueTimeoutMS', :wait_queue_timeout, type: :ms

data/lib/mongo/version.rb

@@ -20,5 +20,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.19.0'.freeze
+  VERSION = '2.19.2'.freeze
 end

data/spec/integration/docs_examples_spec.rb

@@ -162,7 +162,7 @@ describe 'aggregation examples in Ruby' do
 
       # Start runCommand Example 2
 
-      client.database.command(collStats: 'restaurants')
+      client.database.command(dbStats: 1)
 
       # End runCommand Example 2
     end

data/spec/integration/find_options_spec.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Find operation options' do
+  require_mri
+  require_no_auth
+  min_server_fcv '4.4'
+
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:seeds) do
+    [ SpecConfig.instance.addresses.first ]
+  end
+
+  let(:client_options) do
+    {}
+  end
+
+  let(:collection_options) do
+    {}
+  end
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      seeds,
+      SpecConfig.instance.test_options
+        .merge(database: SpecConfig.instance.test_db)
+        .merge(client_options)
+    ).tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:collection) do
+    client['find_options', collection_options]
+  end
+
+  let(:find_command) do
+    subscriber.started_events.find { |cmd| cmd.command_name == 'find' }
+  end
+
+  let(:should_create_collection) { true }
+
+  before do
+    client['find_options'].drop
+    collection.create if should_create_collection
+    collection.insert_many([ { a: 1 }, { a: 2 }, { a: 3 } ])
+  end
+
+  describe 'collation' do
+    let(:client_options) do
+      {}
+    end
+
+    let(:collation) do
+      { 'locale' => 'en_US' }
+    end
+
+    context 'when defined on the collection' do
+      let(:collection_options) do
+        { collation: collation }
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['collation']).to be_nil
+      end
+    end
+
+    context 'when defined on the operation' do
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+
+    context 'when defined on both collection and operation' do
+      let(:collection_options) do
+        { 'locale' => 'de_AT' }
+      end
+
+      let(:should_create_collection) { false }
+
+      it 'uses the collation defined on the collection' do
+        collection.find({}, collation: collation).to_a
+        expect(find_command.command['collation']).to eq(collation)
+      end
+    end
+  end
+
+  describe 'read concern' do
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read_concern: { level: :local } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read concern defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'local')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read_concern: { level: :majority } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'majority')
+        end
+
+        context 'when defined on the operation' do
+          let(:operation_read_concern) do
+            { level: :available }
+          end
+
+          it 'uses the read concern defined on the operation' do
+            collection.find({}, read_concern: operation_read_concern).to_a
+            expect(find_command.command['readConcern']).to eq('level' => 'available')
+          end
+        end
+      end
+
+      context 'when defined on the operation' do
+        let(:collection_options) do
+          {}
+        end
+
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+
+    context 'when defined on the collection' do
+      let(:client_options) do
+        {}
+      end
+
+      let(:collection_options) do
+        { read_concern: { level: :majority } }
+      end
+
+      it 'uses the read concern defined on the collection' do
+        collection.find.to_a
+        expect(find_command.command['readConcern']).to eq('level' => 'majority')
+      end
+
+      context 'when defined on the operation' do
+        let(:operation_read_concern) do
+          { level: :available }
+        end
+
+        it 'uses the read concern defined on the operation' do
+          collection.find({}, read_concern: operation_read_concern).to_a
+          expect(find_command.command['readConcern']).to eq('level' => 'available')
+        end
+      end
+    end
+  end
+
+  describe 'read preference' do
+    require_topology :replica_set
+
+    context 'when defined on the client' do
+      let(:client_options) do
+        { read: { mode: :secondary } }
+      end
+
+      let(:collection_options) do
+        {}
+      end
+
+      it 'uses the read preference defined on the client' do
+        collection.find.to_a
+        expect(find_command.command['$readPreference']).to eq('mode' => 'secondary')
+      end
+
+      context 'when defined on the collection' do
+        let(:collection_options) do
+          { read: { mode: :secondary_preferred } }
+        end
+
+        it 'uses the read concern defined on the collection' do
+          collection.find.to_a
+          expect(find_command.command['$readPreference']).to eq('mode' => 'secondaryPreferred')
+        end
+      end
+    end
+  end
+
+  describe 'cursor type' do
+    let(:collection_options) do
+      { capped: true, size: 1000 }
+    end
+
+    context 'when cursor type is :tailable' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be_falsey
+      end
+    end
+
+    context 'when cursor type is :tailable_await' do
+      it 'sets the cursor type to tailable' do
+        collection.find({}, cursor_type: :tailable_await).first
+        expect(find_command.command['tailable']).to be true
+        expect(find_command.command['awaitData']).to be true
+      end
+    end
+  end
+end

data/spec/lite_spec_helper.rb

@@ -16,7 +16,11 @@ GRIDFS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/gridfs/*.yml").sort
 TRANSACTIONS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/transactions/*.yml").sort
 TRANSACTIONS_API_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/transactions_api/*.yml").sort
 CHANGE_STREAMS_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/change_streams/*.yml").sort
-CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort
+CMAP_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/cmap/*.yml").sort.select do |f|
+  # Skip tests that are flaky on JRuby.
+  # https://jira.mongodb.org/browse/RUBY-3292
+  !defined?(JRUBY_VERSION) || !f.include?('pool-checkout-minPoolSize-connection-maxConnecting.yml')
+end
 AUTH_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/auth/*.yml").sort
 CLIENT_SIDE_ENCRYPTION_TESTS = Dir.glob("#{CURRENT_PATH}/spec_tests/data/client_side_encryption/*.yml").sort
 

data/spec/mongo/client_construction_spec.rb

@@ -797,6 +797,32 @@ describe Mongo::Client do
         end
       end
 
+      context 'when max_connecting is provided' do
+        let(:client) do
+          new_local_client_nmio(SINGLE_CLIENT, options)
+        end
+
+        context 'when max_connecting is a positive integer' do
+          let(:options) do
+            { max_connecting: 5 }
+          end
+
+          it 'sets the max connecting' do
+            expect(client.options[:max_connecting]).to eq(options[:max_connecting])
+          end
+        end
+
+        context 'when max_connecting is a negative integer' do
+          let(:options) do
+            { max_connecting: -5 }
+          end
+
+          it 'raises an exception' do
+            expect { client }.to raise_error(Mongo::Error::InvalidMaxConnecting)
+          end
+        end
+      end
+
       context 'when min_pool_size is provided' do
         let(:client) { new_local_client_nmio(SINGLE_CLIENT, options) }
 
@@ -998,6 +1024,28 @@ describe Mongo::Client do
           expect(client.options).to eq(expected_options)
         end
 
+        context 'when max_connecting is provided' do
+          context 'when max_connecting is a positive integer' do
+            let(:uri) do
+              'mongodb://127.0.0.1:27017/?maxConnecting=10'
+            end
+
+            it 'sets the max connecting' do
+              expect(client.options[:max_connecting]).to eq(10)
+            end
+          end
+
+          context 'when max_connecting is a negative integer' do
+            let(:uri) do
+              'mongodb://127.0.0.1:27017/?maxConnecting=0'
+            end
+
+            it 'raises an exception' do
+              expect { client }.to raise_error(Mongo::Error::InvalidMaxConnecting)
+            end
+          end
+        end
+
         context 'when min_pool_size is provided' do
           context 'when max_pool_size is provided' do
             context 'when the min_pool_size is greater than the max_pool_size' do

data/spec/mongo/collection_ddl_spec.rb

@@ -137,7 +137,11 @@ describe Mongo::Collection do
           end
 
           let(:collstats) do
-            database.read_command(:collstats => :specs).documents.first
+            collection.aggregate([ {'$collStats' => { 'storageStats' => {} }} ]).first
+          end
+
+          let(:storage_stats) do
+            collstats.fetch('storageStats', {})
           end
 
           let(:options) do
@@ -157,9 +161,9 @@ describe Mongo::Collection do
           end
 
           it "applies the options" do
-            expect(collstats["capped"]).to be true
-            expect(collstats["max"]).to eq(512)
-            expect(collstats["maxSize"]).to eq(4096)
+            expect(storage_stats["capped"]).to be true
+            expect(storage_stats["max"]).to eq(512)
+            expect(storage_stats["maxSize"]).to eq(4096)
           end
         end
       end

data/spec/mongo/collection_spec.rb

@@ -651,7 +651,11 @@ describe Mongo::Collection do
       end
 
       let(:collstats) do
-        database.read_command(:collstats => :specs).documents.first
+        collection.aggregate([ {'$collStats' => { 'storageStats' => {} }} ]).first
+      end
+
+      let(:storage_stats) do
+        collstats.fetch('storageStats', {})
       end
 
       before do
@@ -664,9 +668,9 @@ describe Mongo::Collection do
       end
 
       it "applies the options" do
-        expect(collstats["capped"]).to be true
-        expect(collstats["max"]).to eq(512)
-        expect(collstats["maxSize"]).to eq(4096)
+        expect(storage_stats["capped"]).to be true
+        expect(storage_stats["max"]).to eq(512)
+        expect(storage_stats["maxSize"]).to eq(4096)
       end
     end
 

data/spec/mongo/protocol/msg_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 # rubocop:todo all
 
-require 'lite_spec_helper'
+require 'spec_helper'
 require 'support/shared/protocol'
 
 describe Mongo::Protocol::Msg do
@@ -237,44 +237,6 @@ describe Mongo::Protocol::Msg do
         end
       end
 
-=begin no longer supported
-      context 'when a 0 payload type is specified' do
-
-        let(:section) do
-          { type: 0, payload: { ismaster: 1 } }
-        end
-
-        let(:section_payload_type) { bytes.to_s[36] }
-        let(:section_bytes) { bytes.to_s[37..-1] }
-
-        it 'sets the payload type' do
-          expect(section_payload_type).to eq(0.chr)
-        end
-
-        it 'serializes the section' do
-          expect(section_bytes).to be_bson(section[:payload])
-        end
-      end
-
-      context 'when a no payload type is specified' do
-
-        let(:section) do
-          { payload: { ismaster: 1 } }
-        end
-
-        let(:section_payload_type) { bytes.to_s[36] }
-        let(:section_bytes) { bytes.to_s[37..-1] }
-
-        it 'sets the payload type as 0' do
-          expect(section_payload_type).to eq(0.chr)
-        end
-
-        it 'serializes the section' do
-          expect(section_bytes).to be_bson(section[:payload])
-        end
-      end
-=end
-
       context 'when a payload of type 1 is specified' do
 
         let(:section) do
@@ -366,32 +328,9 @@ describe Mongo::Protocol::Msg do
           end
         end
       end
-
-=begin no longer supported
-      context 'when the sections are mixed types and payload type 1 comes before type 0' do
-
-        let(:section1) do
-          Mongo::Protocol::Msg::Section1.new('documents', [ { a: 1 } ])
-        end
-
-        let(:section2) do
-          { type: 0, payload: { 'b' => 2 } }
-        end
-
-        let(:sections) do
-          [ section1, section2 ]
-        end
-
-        it 'serializes all sections' do
-          expect(deserialized.documents).to eq([ BSON::Document.new(main_document), { 'a' => 1 }, { 'b' => 2 }])
-        end
-      end
-=end
     end
 
     context 'when the validating_keys option is true with payload 1' do
-      max_bson_version '4.99.99'
-
       let(:sequences) do
         [ section ]
       end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -1018,6 +1018,18 @@ describe Mongo::URI::SRVProtocol do
         include_examples "roundtrips string"
       end
 
+      context 'when providing maxConnecting' do
+
+        let(:max_connecting) { 10 }
+        let(:options) { "maxConnecting=#{max_connecting}" }
+
+        it 'sets the max connecting option' do
+          expect(uri.uri_options[:max_connecting]).to eq(max_connecting)
+        end
+
+        include_examples "roundtrips string"
+      end
+
       context 'when providing maxPoolSize' do
 
         let(:max_pool_size) { 10 }

data/spec/runners/unified/test.rb

@@ -320,22 +320,22 @@ module Unified
         collection = root_authorized_client.with(write_concern: {w: :majority}).
           use(spec.use!('databaseName'))[spec.use!('collectionName')]
         collection.drop
+        create_options = spec.use('createOptions') || {}
         docs = spec.use!('documents')
-        if docs.any?
-          collection.insert_many(docs)
-        else
-          begin
-            collection.create
-          rescue Mongo::Error => e
-            if Mongo::Error::OperationFailure === e && (
+        begin
+          collection.create(create_options)
+        rescue Mongo::Error => e
+          if Mongo::Error::OperationFailure === e && (
               e.code == 48 || e.message =~ /collection already exists/
-            )
-              # Already exists
-            else
-              raise
-            end
+          )
+            # Already exists
+          else
+            raise
           end
         end
+        if docs.any?
+          collection.insert_many(docs)
+        end
         unless spec.empty?
           raise NotImplementedError, "Unhandled spec keys: #{spec}"
         end

data/spec/spec_tests/data/client_side_encryption/bypassedCommand.yml

@@ -26,7 +26,7 @@ tests:
           command:
             ping: 1
           command_name: ping
-  - description: "current op is not bypassed"
+  - description: "kill op is not bypassed"
     clientOptions:
       autoEncryptOpts:
         kmsProviders:
@@ -34,9 +34,10 @@ tests:
     operations:
       - name: runCommand
         object: database
-        command_name: currentOp
+        command_name: killOp
         arguments:
           command:
-            currentOp: 1
+            killOp: 1
+            op: 1234 
         result:
-          errorContains: "command not supported for auto encryption: currentOp"
+          errorContains: "command not supported for auto encryption: killOp"

data/spec/spec_tests/data/cmap/pool-checkout-minPoolSize-connection-maxConnecting.yml

@@ -1,7 +1,6 @@
 version: 1
 style: integration
 description: threads blocked by maxConnecting check out minPoolSize connections
-# Remove the topology runOn requirement when cmap specs are adjusted for lbs
 runOn:
   -
     # required for blockConnection in fail point
@@ -14,7 +13,7 @@ failPoint:
     failCommands: ["isMaster","hello"]
     closeConnection: false
     blockConnection: true
-    blockTimeMS: 500
+    blockTimeMS: 1000
 poolOptions:
   # allows both thread1 and the background thread to start opening connections concurrently
   minPoolSize: 2
@@ -35,9 +34,8 @@ operations:
   # - it is long enough to make sure that the background thread opens a connection before thread1 releases its permit;
   # - it is short enough to allow thread2 to become blocked acquiring a permit to open a connection, and then grab the connection
   #   opened by the background thread, before the background thread releases its permit.
-  # This wait is not necessary in ruby since the background thread runs immediately.
   - name: wait
-    ms: 0
+    ms: 200
   - name: checkOut
     thread: thread1
   - name: waitForEvent

data/spec/spec_tests/data/unified/valid-pass/collectionData-createOptions.yml

@@ -0,0 +1,37 @@
+description: collectionData-createOptions
+schemaVersion: "1.9"
+runOnRequirements:
+  - minServerVersion: "3.6"
+    # Capped collections cannot be created on serverless instances.
+    serverless: forbid
+createEntities:
+  - client:
+      id: &client0 client0
+  - database:
+      id: &database0 database0
+      client: *client0
+      databaseName: &database0Name database0
+  - collection:
+      id: &collection0 collection0
+      database: *database0
+      collectionName: &collection0Name coll0
+initialData:
+  - collectionName: *collection0Name
+    databaseName: *database0Name
+    createOptions:
+      capped: true
+      # With MMAPv1, the size field cannot be less than 4096.
+      size: &cappedSize 4096
+    documents:
+      - { _id: 1, x: 11 }
+tests:
+  - description: collection is created with the correct options
+    operations:
+      - object: *collection0
+        name: aggregate
+        arguments:
+          pipeline:
+            - $collStats: { storageStats: {} }
+            - $project: { capped: '$storageStats.capped', maxSize: '$storageStats.maxSize'}
+        expectResult:
+          - { capped: true, maxSize: *cappedSize }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 2.19.0
+  version: 2.19.2
 platform: ruby
 authors:
 - The MongoDB Ruby Team
@@ -35,7 +35,7 @@ cert_chain:
   wkeAWhd5b+5JS0zgDL4SvGB8/W2IY+y0zELkojBMgJPyrpAWHL/WSsSBMuhyI2Pv
   xxaBVLklnJJ/qCCOZ3lG2MyVc/Nb0Mmq8ygWNsfwHmKKYuuWcviit0D0Tek=
   -----END CERTIFICATE-----
-date: 2023-06-22 00:00:00.000000000 Z
+date: 2023-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson
@@ -231,6 +231,7 @@ files:
 - lib/mongo/error/invalid_document.rb
 - lib/mongo/error/invalid_file.rb
 - lib/mongo/error/invalid_file_revision.rb
+- lib/mongo/error/invalid_max_connecting.rb
 - lib/mongo/error/invalid_min_pool_size.rb
 - lib/mongo/error/invalid_nonce.rb
 - lib/mongo/error/invalid_read_concern.rb
@@ -590,6 +591,7 @@ files:
 - spec/integration/cursor_reaping_spec.rb
 - spec/integration/docs_examples_spec.rb
 - spec/integration/error_detection_spec.rb
+- spec/integration/find_options_spec.rb
 - spec/integration/fork_reconnect_spec.rb
 - spec/integration/get_more_spec.rb
 - spec/integration/grid_fs_bucket_spec.rb
@@ -1774,6 +1776,7 @@ files:
 - spec/spec_tests/data/unified/valid-fail/operation-failure.yml
 - spec/spec_tests/data/unified/valid-fail/operation-unsupported.yml
 - spec/spec_tests/data/unified/valid-pass/assertNumberConnectionsCheckedOut.yml
+- spec/spec_tests/data/unified/valid-pass/collectionData-createOptions.yml
 - spec/spec_tests/data/unified/valid-pass/entity-client-cmap-events.yml
 - spec/spec_tests/data/unified/valid-pass/entity-client-storeEventsAsEntities.yml
 - spec/spec_tests/data/unified/valid-pass/expectedError-errorResponse.yml
@@ -2457,6 +2460,7 @@ test_files:
 - spec/integration/client_side_encryption/auto_encryption_spec.rb
 - spec/integration/client_side_encryption/on_demand_aws_credentials_spec.rb
 - spec/integration/server_selection_spec.rb
+- spec/integration/find_options_spec.rb
 - spec/integration/ocsp_connectivity_spec.rb
 - spec/integration/error_detection_spec.rb
 - spec/integration/aws_auth_request_spec.rb
@@ -2989,6 +2993,7 @@ test_files:
 - spec/spec_tests/data/unified/valid-pass/poc-sessions.yml
 - spec/spec_tests/data/unified/valid-pass/poc-transactions.yml
 - spec/spec_tests/data/unified/valid-pass/expectedEventsForClient-eventType.yml
+- spec/spec_tests/data/unified/valid-pass/collectionData-createOptions.yml
 - spec/spec_tests/data/unified/valid-pass/poc-retryable-writes.yml
 - spec/spec_tests/data/unified/valid-pass/observeSensitiveCommands.yml
 - spec/spec_tests/data/unified/valid-pass/poc-retryable-reads.yml