mongo 2.22.0 → 2.23.0

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.

data/lib/mongo/search_index/view.rb

@@ -4,6 +4,7 @@ module Mongo
   module SearchIndex
     # A class representing a view of search indexes.
     class View
+      extend Forwardable
       include Enumerable
       include Retryable
       include Collection::Helpers
@@ -21,6 +22,8 @@ module Mongo
       #   when querying the available indexes.
       attr_reader :aggregate_options
 
+      def_delegators :@collection, :tracer
+
       # Create the new search index view.
       #
       # @param [ Collection ] collection The collection.
@@ -46,23 +49,33 @@ module Mongo
       #
       # @param [ Hash ] definition The definition of the search index.
       # @param [ nil | String ] name The name to give the new search index.
+      # @param [ String ] type The type of the search index. Possible values
+      #   are 'search' and 'vectorSearch'. The default is 'search'.
       #
       # @return [ String ] the name of the new search index.
       def create_one(definition, name: nil, type: 'search')
-        create_many([ { name: name, definition: definition, type: type } ]).first
+        spec = { definition: definition, type: type }.tap do |sp|
+          sp[:name] = name unless name.nil?
+        end
+        create_many([ spec ]).first
       end
 
       # Create multiple search indexes with a single command.
       #
       # @param [ Array<Hash> ] indexes The description of the indexes to
       #   create. Each element of the list must be a hash with a definition
-      #   key, and an optional name key.
+      #   key, an optional name key, and an optional type key. The type key
+      #   must be one of 'search' or 'vectorSearch'. The default is 'search'.
       #
       # @return [ Array<String> ] the names of the new search indexes.
       def create_many(indexes)
         spec = spec_with(indexes: indexes.map { |v| validate_search_index!(v) })
-        result = Operation::CreateSearchIndexes.new(spec).execute(next_primary, context: execution_context)
-        result.first['indexesCreated'].map { |idx| idx['name'] }
+        operation = Operation::CreateSearchIndexes.new(spec)
+        context = execution_context
+        tracer.trace_operation(operation, context, op_name: 'createSearchIndexes') do
+          result = operation.execute(next_primary, context: context)
+          result.first['indexesCreated'].map { |idx| idx['name'] }
+        end
       end
 
       # Drop the search index with the given id, or name. One or the other must
@@ -78,11 +91,14 @@ module Mongo
 
         spec = spec_with(index_id: id, index_name: name)
         op = Operation::DropSearchIndex.new(spec)
+        context = execution_context
 
-        # per the spec:
-        # Drivers MUST suppress NamespaceNotFound errors for the
-        # ``dropSearchIndex`` helper.  Drop operations should be idempotent.
-        do_drop(op, nil, execution_context)
+        tracer.trace_operation(op, context, op_name: 'dropSearchIndex') do
+          # per the spec:
+          # Drivers MUST suppress NamespaceNotFound errors for the
+          # ``dropSearchIndex`` helper.  Drop operations should be idempotent.
+          do_drop(op, nil, context)
+        end
       end
 
       # Iterate over the search indexes.
@@ -124,7 +140,11 @@ module Mongo
         validate_id_or_name!(id, name)
 
         spec = spec_with(index_id: id, index_name: name, index: definition)
-        Operation::UpdateSearchIndex.new(spec).execute(next_primary, context: execution_context)
+        op = Operation::UpdateSearchIndex.new(spec)
+        context = execution_context
+        tracer.trace_operation(op, context, op_name: 'updateSearchIndex') do
+          op.execute(next_primary, context: context)
+        end
       end
 
       # The following methods are to make the view act more like an array,

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

@@ -34,21 +34,34 @@ module Mongo
           @metadata = metadata
         end
 
+        # Queries whether the current runtime is Ruby MRI or not.
+        #
+        # @return [ true | false ] whether the runtime is Ruby MRI or not.
+        def mri?
+          RUBY_ENGINE == 'ruby'
+        end
+
         # Queries whether the current runtime is JRuby or not.
         #
         # @return [ true | false ] whether the runtime is JRuby or not.
         def jruby?
-          BSON::Environment.jruby?
+          RUBY_ENGINE == 'jruby'
+        end
+
+        ENGINE_NAMES = { 'jruby' => 'JRuby', 'truffleruby' => 'TruffleRuby' }.freeze
+
+        def engine_name
+          ENGINE_NAMES[RUBY_ENGINE] || RUBY_ENGINE
         end
 
         # Returns the list of Ruby versions that identify this runtime.
         #
         # @return [ Array<String> ] the list of ruby versions
         def ruby_versions
-          if jruby?
-            [ "JRuby #{JRUBY_VERSION}", "like Ruby #{RUBY_VERSION}" ]
-          else
+          if mri?
             [ "Ruby #{RUBY_VERSION}" ]
+          else
+            [ "#{engine_name} #{RUBY_ENGINE_VERSION}", "like Ruby #{RUBY_VERSION}" ]
           end
         end
 

data/lib/mongo/server/connection.rb

@@ -139,6 +139,8 @@ module Mongo
       # across all connections.
       attr_reader :global_id
 
+      def_delegators :server, :tracer
+
       # The connection pool from which this connection was created.
       # May be nil.
       #
@@ -388,6 +390,22 @@ module Mongo
         self
       end
 
+      # Get the transport type for this connection.
+      #
+      # @return [ Symbol | nil ] The transport type, :tcp or :unix, or nil
+      #  if no socket.
+      # @api private
+      def transport
+        return nil if @socket.nil?
+
+        case @socket
+        when Mongo::Socket::Unix
+          :unix
+        else
+          :tcp
+        end
+      end
+
       private
 
       def deliver(message, client, options = {})

data/lib/mongo/server/description/features.rb

@@ -74,16 +74,44 @@ module Mongo
         SERVER_TOO_OLD = "Server at (%s) reports wire version (%s), but this version of the Ruby driver " +
                            "requires at least (%s)."
 
+        # Warning message if the server version is deprecated.
+        SERVER_DEPRECATED = 'Server at (%s) reports wire version (%s), but support for that wire version ' \
+                              'is deprecated and will be removed in a future version of the Ruby driver. ' \
+                              'Please upgrade your MongoDB server to a newer version soon.'
+
         # Error message if the driver is too old for the version of the server.
         #
         # @since 2.5.0
         DRIVER_TOO_OLD = "Server at (%s) requires wire version (%s), but this version of the Ruby driver " +
                            "only supports up to (%s)."
 
+        # An empty range constant, for use in DEPRECATED_WIRE_VERSIONS.
+        EMPTY_RANGE = (0...0).freeze
+
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (6..25).freeze
+        DRIVER_WIRE_VERSIONS = 6..25
+
+        # The wire protocol versions that are deprecated in this version of the
+        # driver. Support for these versions will be removed in the future.
+        #
+        # If there are multiple currently-deprecated wire versions, this should
+        # be set to a range of those versions.
+        #
+        # If there is only a single currently-deprecated wire version, this should
+        # be set to a range where the min and max are the same value.
+        #
+        # If there are no currently-deprecated wire versions, this should be
+        # set to an empty range (e.g. the EMPTY_RANGE constant).
+        DEPRECATED_WIRE_VERSIONS = 6..7
+
+        # make sure the deprecated versions are valid
+        if DEPRECATED_WIRE_VERSIONS.min
+          if DRIVER_WIRE_VERSIONS.min > DEPRECATED_WIRE_VERSIONS.max
+            raise ArgumentError, 'DEPRECATED_WIRE_VERSIONS must be empty, or be within DRIVER_WIRE_VERSIONS'
+          end
+        end
 
         # Create the methods for each mapping to tell if they are supported.
         #
@@ -131,20 +159,21 @@ module Mongo
         end
 
         # Check that there is an overlap between the driver supported wire
-        #   version range and the server wire version range.
-        #
-        # @example Verify the wire version overlap.
-        #   features.check_driver_support!
+        # version range and the server wire version range. Also checks to see
+        # if the server is using a deprecated wire version.
         #
         # @raise [ Error::UnsupportedFeatures ] If the wire version range is
         #   not covered by the driver.
-        #
-        # @since 2.5.1
         def check_driver_support!
-          if DRIVER_WIRE_VERSIONS.min > @server_wire_versions.max
+          if DEPRECATED_WIRE_VERSIONS.include?(@server_wire_versions.max)
+            feature = "wire_version:#{@address}"
+            Mongo::Deprecations.warn(feature, SERVER_DEPRECATED % [@address, @server_wire_versions.max])
+
+          elsif DRIVER_WIRE_VERSIONS.min > @server_wire_versions.max
             raise Error::UnsupportedFeatures.new(SERVER_TOO_OLD % [@address,
                                                                    @server_wire_versions.max,
                                                                    DRIVER_WIRE_VERSIONS.min])
+
           elsif DRIVER_WIRE_VERSIONS.max < @server_wire_versions.min
             raise Error::UnsupportedFeatures.new(DRIVER_TOO_OLD % [@address,
                                                                    @server_wire_versions.min,