mongo 2.22.0 → 2.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfc6de88aae51217bcbe02307215fefb67259f3257c5eba94c966fa8ceac5ccd
-  data.tar.gz: 258a3151671bf5ef8f6ece898dee5846b767ea5ed537fc2a86699ca688285176
+  metadata.gz: e69a3d0fe1586e73885c27a97616bb2422847a13a6b86e1c7f95348261d7de58
+  data.tar.gz: ff6fc65770491d22c49221140e248d37edbb58c3715808843718cb2b9fc8e331
 SHA512:
-  metadata.gz: 2c32a72398d175523f643ad4e229f406e82f450d5eb254ee3e05815645750dd578bca77da03ee5c546146c5d78779cced7c97485107589f057fef3fcb1097662
-  data.tar.gz: 1b3dfcefc33c710792591177f18ea274439326cac1c525cc13d39c6551ac33582baa579082832422166fd819cfa68815659925d925e34f8a4e1026f244fe63f2
+  metadata.gz: fc176435fcf633b0b3acd905bcbca387054f70210c3d140223b30eadbed7667e56ee3ae868ad003d47b89992de09da19fc0bcfc1009f186b8e4bbda1caead6a3
+  data.tar.gz: c5ca31db40bde02be00178be089fe7c7f47504374fd606b84696ddf3ae94d14bc7f2efb00a6c7093a224451022a0098e7528268b364a731e9d95db72f3f23ddf

data/lib/mongo/client.rb

@@ -112,6 +112,7 @@ module Mongo
       :ssl_verify_hostname,
       :ssl_verify_ocsp_endpoint,
       :timeout_ms,
+      :tracing,
       :truncate_logs,
       :user,
       :wait_queue_timeout,
@@ -356,7 +357,9 @@ module Mongo
     #   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
     #   given URI resolves to more hosts than ``:srv_max_hosts``, the client
-    #   will ramdomly choose an ``:srv_max_hosts`` sized subset of hosts.
+    #   will randomly choose an ``:srv_max_hosts`` sized subset of hosts. If
+    #   srvMaxHosts is provided in the URI options, it takes precedence over this
+    #   option.
     # @option options [ String ] :srv_service_name The service name to use in
     #   the SRV DNS query.
     # @option options [ true, false ] :ssl Whether to use TLS.
@@ -437,6 +440,20 @@ module Mongo
     #   See Ruby's Zlib module for valid levels.
     # @option options [ Hash ] :resolv_options For internal driver use only.
     #   Options to pass through to Resolv::DNS constructor for SRV lookups.
+    # @option options [ Hash ] :tracing OpenTelemetry tracing options.
+    #   - :enabled => Boolean, whether to enable OpenTelemetry tracing. The default
+    #     value is nil that means that the configuration will be taken from the
+    #     OTEL_RUBY_INSTRUMENTATION_MONGODB_ENABLED environment variable.
+    #   - :tracer => OpenTelemetry::Trace::Tracer, the tracer to use for
+    #     tracing. Must be an implementation of OpenTelemetry::Trace::Tracer
+    #     interface.
+    #   - :query_text_max_length => Integer, the maximum length of the query text
+    #     to be included in the span attributes. If the query text exceeds this
+    #     length, it will be truncated. Value 0 means no query text
+    #     will be included in the span attributes. The default value is nil that
+    #     means that the configuration will be taken from the
+    #     OTEL_RUBY_INSTRUMENTATION_MONGODB_QUERY_TEXT_MAX_LENGTH environment
+    #     variable.
     # @option options [ Hash ] :auto_encryption_options Auto-encryption related
     #   options.
     #   - :key_vault_client => Client | nil, a client connected to the MongoDB
@@ -574,8 +591,11 @@ module Mongo
 
       @connect_lock = Mutex.new
       @connect_lock.synchronize do
-        @cluster = Cluster.new(addresses, @monitoring,
-          cluster_options.merge(srv_uri: srv_uri))
+        @cluster = Cluster.new(
+          addresses,
+          @monitoring,
+          cluster_options.merge(srv_uri: srv_uri)
+        )
       end
 
       begin
@@ -623,6 +643,7 @@ module Mongo
         # applications should read these values from client, not from cluster
         max_read_retries: options[:max_read_retries],
         read_retry_interval: options[:read_retry_interval],
+        tracer: tracer,
       ).tap do |options|
         # If the client has a cluster already, forward srv_uri to the new
         # cluster to maintain SRV monitoring. If the client is brand new,
@@ -965,7 +986,10 @@ module Mongo
       cmd[:nameOnly] = !!name_only
       cmd[:filter] = filter unless filter.empty?
       cmd[:authorizedDatabases] = true if opts[:authorized_databases]
-      use(Database::ADMIN).database.read_command(cmd, opts).first[Database::DATABASES]
+      use(Database::ADMIN)
+        .database
+        .read_command(cmd, opts.merge(op_name: 'listDatabases'))
+        .first[Database::DATABASES]
     end
 
     # Returns a list of Mongo::Database objects.
@@ -1195,6 +1219,18 @@ module Mongo
       end
     end
 
+    # Get the tracer configured for this client.
+    #
+    # @return [ Tracing::Tracer | nil ] The tracer configured for this client.
+    def tracer
+      tracing_opts = @options[:tracing] || {}
+      @tracer ||= Tracing.create_tracer(
+        enabled: tracing_opts[:enabled],
+        query_text_max_length: tracing_opts[:query_text_max_length],
+        otel_tracer: tracing_opts[:tracer],
+      )
+    end
+
     private
 
     # Attempts to parse the given list of addresses, using the provided options.

data/lib/mongo/cluster.rb

@@ -126,6 +126,7 @@ module Mongo
       if options[:monitoring_io] == false && !options.key?(:cleanup)
         options[:cleanup] = false
       end
+      @tracer = options.delete(:tracer)
       @options = options.freeze
 
       # @update_lock covers @servers, @connecting, @connected, @topology and
@@ -298,7 +299,7 @@ module Mongo
       cluster = Cluster.new(
         client.cluster.addresses.map(&:to_s),
         monitoring || Monitoring.new,
-        client.cluster_options,
+        client.cluster_options
       )
       client.instance_variable_set(:@cluster, cluster)
     end
@@ -309,6 +310,8 @@ module Mongo
     # @return [ Monitoring ] monitoring The monitoring.
     attr_reader :monitoring
 
+    attr_reader :tracer
+
     # @return [ Object ] The cluster topology.
     attr_reader :topology
 

data/lib/mongo/collection/view/aggregation/behavior.rb

@@ -88,7 +88,7 @@ module Mongo
             @view.send(:server_selector)
           end
 
-          def aggregate_spec(session, read_preference)
+          def aggregate_spec(session, read_preference = nil)
             Builder::Aggregation.new(
               pipeline,
               view,

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

@@ -25,11 +25,14 @@ module Mongo
       #
       # @since 2.0.0
       class Aggregation
+        extend Forwardable
         include Behavior
 
         # @return [ Array<Hash> ] pipeline The aggregation pipeline.
         attr_reader :pipeline
 
+        def_delegators :view, :tracer
+
         # Initialize the aggregation for the provided collection view, pipeline
         # and options.
         #
@@ -80,7 +83,7 @@ module Mongo
           Aggregation.new(view, pipeline, options)
         end
 
-        def initial_query_op(session, read_preference)
+        def initial_query_op(session, read_preference = nil)
           Operation::Aggregate.new(aggregate_spec(session, read_preference))
         end
 
@@ -117,7 +120,7 @@ module Mongo
 
         end
 
-        def send_initial_query(server, context)
+        def send_initial_query(server, context, operation: nil)
           if server.load_balancer?
             # Connection will be checked in when cursor is drained.
             connection = server.pool.check_out(context: context)

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

@@ -88,19 +88,21 @@ module Mongo
             operation_timeouts: operation_timeouts,
             view: self
           )
-
-          if respond_to?(:write?, true) && write?
-            server = server_selector.select_server(cluster, nil, session, write_aggregation: true)
-            result = send_initial_query(server, context)
-
-            if use_query_cache?
-              CachingCursor.new(view, result, server, session: session, context: context)
+          op = initial_query_op(session)
+          tracer.trace_operation(op, context) do
+            if respond_to?(:write?, true) && write?
+              server = server_selector.select_server(cluster, nil, session, write_aggregation: true)
+              result = send_initial_query(server, context, operation: op)
+
+              if use_query_cache?
+                CachingCursor.new(view, result, server, session: session, context: context)
+              else
+                Cursor.new(view, result, server, session: session, context: context)
+              end
             else
-              Cursor.new(view, result, server, session: session, context: context)
-            end
-          else
-            read_with_retry_cursor(session, server_selector, view, context: context) do |server|
-              send_initial_query(server, context)
+              read_with_retry_cursor(session, server_selector, view, context: context) do |server|
+                send_initial_query(server, context, operation: op)
+              end
             end
           end
         end
@@ -167,8 +169,8 @@ module Mongo
           end
         end
 
-        def send_initial_query(server, context)
-          operation = initial_query_op(context.session)
+        def send_initial_query(server, context, operation: nil)
+          operation ||= initial_query_op(context.session)
           if server.load_balancer?
             # Connection will be checked in when cursor is drained.
             connection = server.pool.check_out(context: context)

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

@@ -192,22 +192,25 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            read_with_retry(session, selector, context) do |server|
-              Operation::Count.new(
-                selector: cmd,
-                db_name: database.name,
-                options: {:limit => -1},
-                read: read_pref,
-                session: session,
-                # For some reason collation was historically accepted as a
-                # string key. Note that this isn't documented as valid usage.
-                collation: opts[:collation] || opts['collation'] || collation,
-                comment: opts[:comment],
-              ).execute(
-                server,
-                context: context
-              )
-            end.n.to_i
+            operation = Operation::Count.new(
+              selector: cmd,
+              db_name: database.name,
+              options: {:limit => -1},
+              read: read_pref,
+              session: session,
+              # For some reason collation was historically accepted as a
+              # string key. Note that this isn't documented as valid usage.
+              collation: opts[:collation] || opts['collation'] || collation,
+              comment: opts[:comment],
+            )
+            tracer.trace_operation(operation, context) do
+              read_with_retry(session, selector, context) do |server|
+                operation.execute(
+                  server,
+                  context: context
+                )
+              end.n.to_i
+            end
           end
         end
 
@@ -294,32 +297,35 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            read_with_retry(session, selector, context) do |server|
-              cmd = { count: collection.name }
-              cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
-              if read_concern
-                cmd[:readConcern] = Options::Mapper.transform_values_to_strings(read_concern)
+            cmd = { count: collection.name }
+            cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
+            if read_concern
+              cmd[:readConcern] = Options::Mapper.transform_values_to_strings(read_concern)
+            end
+            operation = Operation::Count.new(
+              selector: cmd,
+              db_name: database.name,
+              read: read_pref,
+              session: session,
+              comment: opts[:comment],
+            )
+            tracer.trace_operation(operation, context, op_name: 'estimatedDocumentCount') do
+              read_with_retry(session, selector, context) do |server|
+                result = operation.execute(server, context: context)
+                result.n.to_i
+              end
+            rescue Error::OperationFailure::Family => exc
+              if exc.code == 26
+                # NamespaceNotFound
+                # This should only happen with the aggregation pipeline path
+                # (server 4.9+). Previous servers should return 0 for nonexistent
+                # collections.
+                0
+              else
+                raise
               end
-              result = Operation::Count.new(
-                selector: cmd,
-                db_name: database.name,
-                read: read_pref,
-                session: session,
-                comment: opts[:comment],
-              ).execute(server, context: context)
-              result.n.to_i
             end
           end
-        rescue Error::OperationFailure::Family => exc
-          if exc.code == 26
-            # NamespaceNotFound
-            # This should only happen with the aggregation pipeline path
-            # (server 4.9+). Previous servers should return 0 for nonexistent
-            # collections.
-            0
-          else
-            raise
-          end
         end
 
         # Get a list of distinct values for a specific field.
@@ -362,22 +368,25 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            read_with_retry(session, selector, context) do |server|
-              Operation::Distinct.new(
-                selector: cmd,
-                db_name: database.name,
-                options: {:limit => -1},
-                read: read_pref,
-                session: session,
-                comment: opts[:comment],
-                # For some reason collation was historically accepted as a
-                # string key. Note that this isn't documented as valid usage.
-                collation: opts[:collation] || opts['collation'] || collation,
-              ).execute(
-                server,
-                context: context
-              )
-            end.first['values']
+            operation = Operation::Distinct.new(
+              selector: cmd,
+              db_name: database.name,
+              options: {:limit => -1},
+              read: read_pref,
+              session: session,
+              comment: opts[:comment],
+              # For some reason collation was historically accepted as a
+              # string key. Note that this isn't documented as valid usage.
+              collation: opts[:collation] || opts['collation'] || collation,
+            )
+            tracer.trace_operation(operation, context) do
+              read_with_retry(session, selector, context) do |server|
+                operation.execute(
+                  server,
+                  context: context
+                )
+              end.first['values']
+            end
           end
         end
 

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

@@ -211,22 +211,24 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
-              gte_4_4 = connection.server.description.server_version_gte?('4.4')
-              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
-                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            operation = Operation::WriteCommand.new(
+              selector: cmd,
+              db_name: database.name,
+              write_concern: write_concern,
+              session: session,
+            )
+            value = tracer.trace_operation(operation, context, op_name: 'findOneAndUpdate') do
+              write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+                gte_4_4 = connection.server.description.server_version_gte?('4.4')
+                if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                  raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+                end
+                operation.txn_num = txn_num
+                operation.execute_with_connection(connection, context: context)
               end
-
-              Operation::WriteCommand.new(
-                selector: cmd,
-                db_name: database.name,
-                write_concern: write_concern,
-                session: session,
-                txn_num: txn_num,
-              ).execute_with_connection(connection, context: context)
-            end
-          end.first&.fetch('value', nil)
-          value unless value.nil? || value.empty?
+            end.first&.fetch('value', nil)
+            value unless value.nil? || value.empty?
+          end
         end
 
         # Remove documents from the collection.
@@ -275,22 +277,24 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
-              gte_4_4 = connection.server.description.server_version_gte?('4.4')
-              if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
-                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            operation = Operation::Delete.new(
+              deletes: [ delete_doc ],
+              db_name: collection.database.name,
+              coll_name: collection.name,
+              write_concern: write_concern,
+              bypass_document_validation: !!opts[:bypass_document_validation],
+              session: session,
+              let: opts[:let],
+              comment: opts[:comment],
+            )
+            tracer.trace_operation(operation, context, op_name: 'deleteMany') do
+              nro_write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+                gte_4_4 = connection.server.description.server_version_gte?('4.4')
+                if !gte_4_4 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                  raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+                end
+                operation.execute_with_connection(connection, context: context)
               end
-
-              Operation::Delete.new(
-                deletes: [ delete_doc ],
-                db_name: collection.database.name,
-                coll_name: collection.name,
-                write_concern: write_concern,
-                bypass_document_validation: !!opts[:bypass_document_validation],
-                session: session,
-                let: opts[:let],
-                comment: opts[:comment],
-              ).execute_with_connection(connection, context: context)
             end
           end
         end
@@ -592,23 +596,25 @@ module Mongo
               session: session,
               operation_timeouts: operation_timeouts(opts)
             )
-            write_with_retry(write_concern, context: context) do |connection, txn_num, context|
-              gte_4_2 = connection.server.description.server_version_gte?('4.2')
-              if !gte_4_2 && opts[:hint] && write_concern && !write_concern.acknowledged?
-                raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+            operation = Operation::Update.new(
+              updates: [ update_doc ],
+              db_name: collection.database.name,
+              coll_name: collection.name,
+              write_concern: write_concern,
+              bypass_document_validation: !!opts[:bypass_document_validation],
+              session: session,
+              let: opts[:let],
+              comment: opts[:comment],
+            )
+            tracer.trace_operation(operation, context) do
+              write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+                gte_4_2 = connection.server.description.server_version_gte?('4.2')
+                if !gte_4_2 && opts[:hint] && write_concern && !write_concern.acknowledged?
+                  raise Error::UnsupportedOption.hint_error(unacknowledged_write: true)
+                end
+                operation.txn_num = txn_num
+                operation.execute_with_connection(connection, context: context)
               end
-
-              Operation::Update.new(
-                updates: [ update_doc ],
-                db_name: collection.database.name,
-                coll_name: collection.name,
-                write_concern: write_concern,
-                bypass_document_validation: !!opts[:bypass_document_validation],
-                session: session,
-                txn_num: txn_num,
-                let: opts[:let],
-                comment: opts[:comment],
-              ).execute_with_connection(connection, context: context)
             end
           end
         end

data/lib/mongo/collection/view.rb

@@ -72,6 +72,8 @@ module Mongo
       # Delegate to the cluster for the next primary.
       def_delegators :cluster, :next_primary
 
+      def_delegators :client, :tracer
+
       alias :selector :filter
 
       # @return [ Integer | nil | The timeout_ms value that was passed as an

data/lib/mongo/collection.rb

@@ -57,6 +57,8 @@ module Mongo
     # Delegate to the cluster for the next primary.
     def_delegators :cluster, :next_primary
 
+    def_delegators :client, :tracer
+
     # Options that can be updated on a new Collection instance via the #with method.
     #
     # @since 2.1.0
@@ -410,21 +412,24 @@ module Mongo
           client: client,
           session: session
         )
-        maybe_create_qe_collections(opts[:encrypted_fields], client, session) do |encrypted_fields|
-          Operation::Create.new(
-            selector: operation,
-            db_name: database.name,
-            write_concern: write_concern,
-            session: session,
-            # Note that these are collection options, collation isn't
-            # taken from options passed to the create method.
-            collation: options[:collation] || options['collation'],
-            encrypted_fields: encrypted_fields,
-            validator: options[:validator],
-          ).execute(
-            next_primary(nil, session),
-            context: context
-          )
+        operation = Operation::Create.new(
+          selector: operation,
+          db_name: database.name,
+          write_concern: write_concern,
+          session: session,
+          # Note that these are collection options, collation isn't
+          # taken from options passed to the create method.
+          collation: options[:collation] || options['collation'],
+          validator: options[:validator],
+        )
+        tracer.trace_operation(operation, context, op_name: 'createCollection') do
+          maybe_create_qe_collections(opts[:encrypted_fields], client, session) do |encrypted_fields|
+            operation.encrypted_fields = encrypted_fields
+            operation.execute(
+              next_primary(nil, session),
+              context: context
+            )
+          end
         end
       end
     end
@@ -453,25 +458,27 @@ module Mongo
     # @since 2.0.0
     def drop(opts = {})
       client.with_session(opts) do |session|
-        maybe_drop_emm_collections(opts[:encrypted_fields], client, session) do
-          temp_write_concern = write_concern
-          write_concern = if opts[:write_concern]
-            WriteConcern.get(opts[:write_concern])
-          else
-            temp_write_concern
+        context = Operation::Context.new(
+          client: client,
+          session: session,
+          operation_timeouts: operation_timeouts(opts)
+        )
+        temp_write_concern = write_concern
+        write_concern = if opts[:write_concern]
+                          WriteConcern.get(opts[:write_concern])
+                        else
+                          temp_write_concern
+                        end
+        operation = Operation::Drop.new({
+          selector: { :drop => name },
+          db_name: database.name,
+          write_concern: write_concern,
+          session: session,
+        })
+        tracer.trace_operation(operation, context, op_name: 'dropCollection') do
+          maybe_drop_emm_collections(opts[:encrypted_fields], client, session) do
+            do_drop(operation, session, context)
           end
-          context = Operation::Context.new(
-            client: client,
-            session: session,
-            operation_timeouts: operation_timeouts(opts)
-          )
-          operation = Operation::Drop.new({
-            selector: { :drop => name },
-            db_name: database.name,
-            write_concern: write_concern,
-            session: session,
-          })
-          do_drop(operation, session, context)
         end
       end
     end
@@ -865,19 +872,22 @@ module Mongo
           session: session,
           operation_timeouts: operation_timeouts(opts)
           )
-        write_with_retry(write_concern, context: context) do |connection, txn_num, context|
-          Operation::Insert.new(
-            :documents => [ document ],
-            :db_name => database.name,
-            :coll_name => name,
-            :write_concern => write_concern,
-            :bypass_document_validation => !!opts[:bypass_document_validation],
-            :options => opts,
-            :id_generator => client.options[:id_generator],
-            :session => session,
-            :txn_num => txn_num,
-            :comment => opts[:comment]
-          ).execute_with_connection(connection, context: context)
+        operation = Operation::Insert.new(
+              :documents => [ document ],
+              :db_name => database.name,
+              :coll_name => name,
+              :write_concern => write_concern,
+              :bypass_document_validation => !!opts[:bypass_document_validation],
+              :options => opts,
+              :id_generator => client.options[:id_generator],
+              :session => session,
+              :comment => opts[:comment]
+            )
+        tracer.trace_operation(operation, context) do
+          write_with_retry(write_concern, context: context) do |connection, txn_num, context|
+            operation.txn_num = txn_num
+            operation.execute_with_connection(connection, context: context)
+          end
         end
       end
     end

data/lib/mongo/config.rb

@@ -27,6 +27,10 @@ module Mongo
     # validate the parameters and raise an error if they are invalid.
     option :validate_update_replace, default: false
 
+    # When this flag is set to true, the CSFLE will use Ruby types for
+    # decryption instead of BSON types.
+    option :csfle_convert_to_ruby_types, default: false
+
     # Set the configuration options.
     #
     # @example Set the options.

data/lib/mongo/crypt/auto_decryption_context.rb

@@ -38,6 +38,15 @@ module Mongo
 
         Binding.ctx_decrypt_init(self, @command)
       end
+
+      # Which BSON mode to use when creating documents from the outcome of
+      # the state machine. The returned value is based on the
+      # +Mongo::Config.csfle_convert_to_ruby_types+ option.
+      #
+      # @return [ Symbol, nil ] The BSON mode.
+      def bson_mode
+        Mongo::Config.csfle_convert_to_ruby_types ? nil : :bson
+      end
     end
   end
 end