mongo 2.21.3 → 2.23.0

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
@@ -1049,6 +1059,11 @@ module Mongo
     #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
     # @option options [ Hash ] :let Mapping of variables to use in the command.
     #   See the server documentation for details.
+    # @option options [ Hash ] :sort Specifies which document the operation
+    #   replaces if the query matches multiple documents. The first document
+    #   matched by the sort order will be replaced.
+    #   This option is only supported by servers >= 8.0. Older servers will
+    #   report an error for using this option.
     #
     # @return [ Result ] The response from the database.
     #
@@ -1115,6 +1130,11 @@ module Mongo
     #   May be specified as a Hash (e.g. { _id: 1 }) or a String (e.g. "_id_").
     # @option options [ Hash ] :let Mapping of variables to use in the command.
     #   See the server documentation for details.
+    # @option options [ Hash ] :sort Specifies which document the operation
+    #   updates if the query matches multiple documents. The first document
+    #   matched by the sort order will be updated.
+    #   This option is only supported by servers >= 8.0. Older servers will
+    #   report an error for using this option.
     #
     # @return [ Result ] The response from the database.
     #

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

data/lib/mongo/crypt/binding.rb

@@ -1216,7 +1216,7 @@ module Mongo
         # TODO since the binary references a C pointer, and ByteBuffer is
         # written in C in MRI, we could omit a copy of the data by making
         # ByteBuffer reference the string that is owned by libmongocrypt.
-        BSON::Document.from_bson(BSON::ByteBuffer.new(binary.to_s), mode: :bson)
+        BSON::Document.from_bson(BSON::ByteBuffer.new(binary.to_s), mode: context.bson_mode)
       end
 
       # @!method self.mongocrypt_ctx_destroy(ctx)

data/lib/mongo/crypt/context.rb

@@ -109,6 +109,16 @@ module Mongo
         end
       end
 
+      # Which BSON mode to use when creating documents from the outcome of
+      # the state machine. The default is :bson, which creates BSON::Document
+      # with BSON types. Subclasses may override this method to
+      # change this behavior.
+      #
+      # @return [ Symbol, nil ] The BSON mode.
+      def bson_mode
+        :bson
+      end
+
       private
 
       def provide_markings(timeout_ms)

data/lib/mongo/crypt/explicit_decryption_context.rb

@@ -38,6 +38,15 @@ module Mongo
         # explicit decryption
         Binding.ctx_explicit_decrypt_init(self, doc)
       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

data/lib/mongo/database/view.rb

@@ -45,6 +45,8 @@ module Mongo
       # @return [ Collection ] collection The command collection.
       attr_reader :collection
 
+      def_delegators :@database, :tracer
+
       # Get all the names of the non-system collections in the database.
       #
       # @note The set of returned collection names depends on the version of
@@ -214,27 +216,30 @@ module Mongo
           session: session,
           operation_timeouts: operation_timeouts(options)
         )
-        cursor = read_with_retry_cursor(session, server_selector, self, context: context) do |server|
-          # TODO take description from the connection used to send the query
-          # once https://jira.mongodb.org/browse/RUBY-1601 is fixed.
-          description = server.description
-          send_initial_query(server, session, context, options)
-        end
-        # On 3.0+ servers, we get just the collection names.
-        # On 2.6 server, we get collection names prefixed with the database
-        # name. We need to filter system collections out here because
-        # in the caller we don't know which server version executed the
-        # command and thus what the proper filtering logic should be
-        # (it is valid for collection names to have dots, thus filtering out
-        # collections named system.* here for 2.6 servers would actually
-        # filter out collections in the system database).
-        if description.server_version_gte?('3.0')
-          cursor.reject do |doc|
-            doc['name'].start_with?('system.') || doc['name'].include?('$')
+        op = initial_query_op(session, options)
+        tracer.trace_operation(op, context, op_name: 'listCollections') do
+          cursor = read_with_retry_cursor(session, server_selector, self, context: context) do |server|
+            # TODO take description from the connection used to send the query
+            # once https://jira.mongodb.org/browse/RUBY-1601 is fixed.
+            description = server.description
+            send_initial_query(server, session, context, options)
           end
-        else
-          cursor.reject do |doc|
-            doc['name'].start_with?("#{database.name}.system") || doc['name'].include?('$')
+          # On 3.0+ servers, we get just the collection names.
+          # On 2.6 server, we get collection names prefixed with the database
+          # name. We need to filter system collections out here because
+          # in the caller we don't know which server version executed the
+          # command and thus what the proper filtering logic should be
+          # (it is valid for collection names to have dots, thus filtering out
+          # collections named system.* here for 2.6 servers would actually
+          # filter out collections in the system database).
+          if description.server_version_gte?('3.0')
+            cursor.reject do |doc|
+              doc['name'].start_with?('system.') || doc['name'].include?('$')
+            end
+          else
+            cursor.reject do |doc|
+              doc['name'].start_with?("#{database.name}.system") || doc['name'].include?('$')
+            end
           end
         end
       end

data/lib/mongo/database.rb

@@ -74,7 +74,8 @@ module Mongo
                    :server_selector,
                    :read_concern,
                    :write_concern,
-                   :encrypted_fields_map
+                   :encrypted_fields_map,
+                   :tracer
 
     # @return [ Mongo::Server ] Get the primary server from the cluster.
     def_delegators :cluster,
@@ -267,10 +268,12 @@ module Mongo
     # @option opts :session [ Session ] The session to use for this command.
     # @option opts [ Object ] :comment A user-provided
     #   comment to attach to this command.
-    # @option options [ Integer ] :timeout_ms The operation timeout in milliseconds.
+    # @option opts [ Integer ] :timeout_ms The operation timeout in milliseconds.
     #    Must be a non-negative integer. An explicit value of 0 means infinite.
     #    The default value is unset which means the value is inherited from
     #    the database or the client.
+    # @option opts :op_name [ String | nil ] The name of the operation for
+    #    tracing purposes.
     #
     # @return [ Hash ] The result of the command execution.
     # @api private
@@ -290,14 +293,18 @@ module Mongo
           session: session,
           operation_timeouts: operation_timeouts(opts)
         )
-        read_with_retry(session, preference, context) do |server|
-          Operation::Command.new(
-            selector: operation.dup,
-            db_name: name,
-            read: preference,
-            session: session,
-            comment: opts[:comment],
-          ).execute(server, context: context)
+        operation = Operation::Command.new(
+          selector: operation.dup,
+          db_name: name,
+          read: preference,
+          session: session,
+          comment: opts[:comment],
+        )
+        op_name = opts[:op_name] || 'command'
+        tracer.trace_operation(operation, context, op_name: op_name) do
+          read_with_retry(session, preference, context) do |server|
+            operation.execute(server, context: context)
+          end
         end
       end
     end

data/lib/mongo/deprecations.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'mongo/loggable'
+
+module Mongo
+  # Used for reporting deprecated behavior in the driver. When it is possible
+  # to detect that a deprecated feature is being used, a warning should be issued
+  # through this module.
+  #
+  # The warning will be issued no more than once for that feature, regardless
+  # of how many times Mongo::Deprecations.warn is called.
+  #
+  # @example Issue a deprecation warning.
+  #   Mongo::Deprecations.warn(:old_feature, "The old_feature is deprecated, use new_feature instead.")
+  #
+  # @api private
+  module Deprecations
+    extend self
+    extend Mongo::Loggable
+
+    # Mutex for synchronizing access to warned features.
+    # @api private
+    MUTEX = Thread::Mutex.new
+
+    # Issue a warning about a deprecated feature. The warning is written to the
+    # logger, and will not be written more than once per feature.
+    #
+    # @param [ String | Symbol ] feature The deprecated feature.
+    # @param [ String ] message The deprecation message.
+    def warn(feature, message)
+      MUTEX.synchronize do
+        return if _warned?(feature)
+
+        _warned!(feature)
+        log_warn("[DEPRECATION:#{feature}] #{message}")
+      end
+    end
+
+    # Check if a warning for a given deprecated feature has already been issued.
+    #
+    # @param [ String | Symbol ] feature The deprecated feature.
+    # @param [ true | false ] prefix Whether to check for prefix matches.
+    #
+    # @return [ true | false ] If a warning has already been issued.
+    def warned?(feature, prefix: false)
+      MUTEX.synchronize { _warned?(feature, prefix: prefix) }
+    end
+
+    # Mark that a warning for a given deprecated feature has been issued.
+    #
+    # @param [ String | Symbol ] feature The deprecated feature.
+    def warned!(feature)
+      MUTEX.synchronize { _warned!(feature) }
+      nil
+    end
+
+    # Clears all memory of previously warned features.
+    def clear!
+      MUTEX.synchronize { warned_features reset: true }
+      nil
+    end
+
+    private
+
+    # Set of features that have already been warned about.
+    #
+    # @param [ true | false ] reset Whether to reset the warned features.
+    #
+    # @return [ Set<String> ] The set of warned features.
+    def warned_features(reset: false)
+      @warned_features = nil if reset
+      @warned_features ||= Set.new
+    end
+
+    # Check if a warning for a given deprecated feature has already been issued.
+    # This version is not thread-safe.
+    #
+    # @param [ String | Symbol ] feature The deprecated feature.
+    # @param [ true | false ] prefix Whether to check for prefix matches.
+    #
+    # @return [ true | false ] If a warning has already been issued.
+    def _warned?(feature, prefix: false)
+      if prefix
+        warned_features.any? { |f| f.to_s.start_with?(feature) }
+      else
+        warned_features.include?(feature.to_s)
+      end
+    end
+
+    # Mark that a warning for a given deprecated feature has been issued.
+    # This version is not thread-safe.
+    #
+    # @param [ String | Symbol ] feature The deprecated feature.
+    def _warned!(feature)
+      warned_features.add(feature.to_s)
+    end
+  end
+end

data/lib/mongo/index/view.rb

@@ -45,6 +45,7 @@ module Mongo
 
       def_delegators :@collection, :cluster, :database, :read_preference, :write_concern, :client
       def_delegators :cluster, :next_primary
+      def_delegators :client, :tracer
 
       # The index key field.
       #
@@ -221,9 +222,7 @@ module Mongo
         end
 
         client.with_session(@options.merge(options)) do |session|
-          server = next_primary(nil, session)
-
-          indexes = normalize_models(models, server)
+          indexes = normalize_models(models)
           indexes.each do |index|
             if index[:bucketSize] || index['bucketSize']
               client.log_warn("Haystack indexes (bucketSize index option) are deprecated as of MongoDB 4.4")
@@ -244,7 +243,11 @@ module Mongo
             session: session,
             operation_timeouts: operation_timeouts(options)
           )
-          Operation::CreateIndex.new(spec).execute(server, context: context)
+          operation = Operation::CreateIndex.new(spec)
+          tracer.trace_operation(operation, context, op_name: 'createIndexes') do
+            server = next_primary(nil, session)
+            operation.execute(server, context: context)
+          end
         end
       end
 
@@ -283,16 +286,18 @@ module Mongo
           session: session,
           operation_timeouts: operation_timeouts(@options)
         )
-
-        cursor = read_with_retry_cursor(session, ServerSelector.primary, self, context: context) do |server|
-          send_initial_query(server, session, context)
-        end
-        if block_given?
-          cursor.each do |doc|
-            yield doc
+        op = initial_query_op(session)
+        tracer.trace_operation(op, context, op_name: 'listIndexes') do
+          cursor = read_with_retry_cursor(session, ServerSelector.primary, self, context: context) do |server|
+            send_initial_query(op, server, session, context)
+          end
+          if block_given?
+            cursor.each do |doc|
+              yield doc
+            end
+          else
+            cursor.to_enum
           end
-        else
-          cursor.to_enum
         end
       end
 
@@ -359,13 +364,17 @@ module Mongo
             write_concern: write_concern,
           }
           spec[:comment] = opts[:comment] unless opts[:comment].nil?
-          server = next_primary(nil, session)
           context = Operation::Context.new(
             client: client,
             session: session,
             operation_timeouts: operation_timeouts(opts)
           )
-          Operation::DropIndex.new(spec).execute(server, context: context)
+          op = Operation::DropIndex.new(spec)
+          op_name = name == Index::ALL ? 'dropIndexes' : 'dropIndex'
+          tracer.trace_operation(op, context, op_name: op_name) do
+            server = next_primary(nil, session)
+            op.execute(server, context: context)
+          end
         end
       end
 
@@ -394,7 +403,7 @@ module Mongo
         Options::Mapper.transform_keys_to_strings(spec)
       end
 
-      def normalize_models(models, server)
+      def normalize_models(models)
         models.map do |model|
           # Transform options first which gives us a mutable hash
           Options::Mapper.transform(model, OPTIONS).tap do |model|
@@ -403,12 +412,12 @@ module Mongo
         end
       end
 
-      def send_initial_query(server, session, context)
+      def send_initial_query(op, server, session, context)
         if server.load_balancer?
           connection = server.pool.check_out(context: context)
-          initial_query_op(session).execute_with_connection(connection, context: context)
+          op.execute_with_connection(connection, context: context)
         else
-          initial_query_op(session).execute(server, context: context)
+          op.execute(server, context: context)
         end
       end
     end

data/lib/mongo/operation/create.rb

@@ -28,6 +28,10 @@ module Mongo
     class Create
       include Specifiable
       include OpMsgExecutable
+
+      def encrypted_fields=(value)
+        @spec[:encrypted_fields] = value
+      end
     end
   end
 end

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

@@ -34,8 +34,11 @@ module Mongo
         private
 
         def get_result(connection, context, options = {})
-          # This is a Mongo::Operation::Insert::Result
-          Result.new(*dispatch_message(connection, context), @ids, context: context)
+          message = build_message(connection, context)
+          connection.tracer.trace_command(message, context, connection) do
+            result = Result.new(*dispatch_message(message, connection, context), @ids, context: context)
+            yield result
+          end
         end
 
         def selector(connection)

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

@@ -45,7 +45,7 @@ module Mongo
           add_error_labels(connection, context) do
             check_for_network_error do
               add_server_diagnostics(connection) do
-                get_result(connection, context, options).tap do |result|
+                get_result(connection, context, options) do |result|
                   if session
                     if session.in_transaction? &&
                       connection.description.load_balancer?
@@ -104,12 +104,19 @@ module Mongo
       end
 
       def get_result(connection, context, options = {})
-        result_class.new(*dispatch_message(connection, context, options), context: context, connection: connection)
+        message = build_message(connection, context)
+        connection.tracer.trace_command(message, context, connection) do
+          result = result_class.new(*dispatch_message(message, connection, context, options), context: context, connection: connection)
+          if block_given?
+            yield result
+          else
+            result
+          end
+        end
       end
 
       # Returns a Protocol::Message or nil as reply.
-      def dispatch_message(connection, context, options = {})
-        message = build_message(connection, context)
+      def dispatch_message(message, connection, context, options = {})
         message = message.maybe_encrypt(connection, context)
         reply = connection.dispatch([ message ], context, options)
         [reply, connection.description, connection.global_id]

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

@@ -233,7 +233,7 @@ module Mongo
       #
       # @since 2.0.0
       def coll_name
-        spec.fetch(COLL_NAME)
+        spec[COLL_NAME]
       end
 
       # The id of the cursor created on the server.
@@ -526,6 +526,10 @@ module Mongo
         @spec[:txn_num]
       end
 
+      def txn_num=(num)
+        @spec[:txn_num] = num
+      end
+
       # The command.
       #
       # @return [ Hash ] The command.