mongo 2.26.0 → 2.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 439e028e8b9ce062d109e1760508977f13a87dd6ee4cb9d5221a6a3108fec214
-  data.tar.gz: bb346a893717256c3eac12af4a63c718bfd4f567b1ec17b95727e45f9f8e11d5
+  metadata.gz: 39d9792c95b149dbbcb1b065df222c345eea9c84912e03de9a8994d7aea32ab8
+  data.tar.gz: b491401e88ffde8324e802267b35f75f6f92997f5746b3634612e1a9d63f11e8
 SHA512:
-  metadata.gz: 3d650edf8067fbe760d1c0526e62bef7cfda7c27284b725ffcc5a8e3c33c712011b3aa478e87db2abea876d36e332daf733d1180954ed6bd1e5003a258a05f49
-  data.tar.gz: 6832d11c4cae68a7776c8e5f7ef8e5bd9fcbda45bedf8e8cb208fdc5103060582a315cb75434e003462500b4da05deb5e71618a6856159262ff3655fbe16888d
+  metadata.gz: aad7e612834dd20849a707f6fde3d5a8101765af93df37eee119ad0418dd518b738ec8834689f0aeac267ac117aab2f89f84362f0c588f8714b96c1c87c286ef
+  data.tar.gz: 6a1c05b23598ac63e37267393de256bd0f2d250f14e881e2fda7a436a2ee2775d60e61d076c4fbaaa77230e7135f89095c55a737edca13a3434f048fdf8aa5db

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

@@ -115,15 +115,15 @@ module Mongo
 
         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)
-            initial_query_op(
-              context.session,
-              effective_read_preference(connection)
-            ).execute_with_connection(
-              connection,
-              context: context
-            )
+            server.pool.with_cursor_connection(context: context) do |connection|
+              initial_query_op(
+                context.session,
+                effective_read_preference(connection)
+              ).execute_with_connection(
+                connection,
+                context: context
+              )
+            end
           else
             server.with_connection do |connection|
               initial_query_op(

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

@@ -350,8 +350,7 @@ module Mongo
             if server.load_balancer?
               # In load balanced topology, manually check out a connection
               # so it remains checked out and pinned to the cursor.
-              connection = server.pool.check_out(context: context)
-              begin
+              server.pool.with_cursor_connection(context: context) do |connection|
                 result = send_initial_query(connection, context)
 
                 start_at_operation_time = if (doc = result.replies.first && result.replies.first.documents.first)
@@ -360,9 +359,6 @@ module Mongo
                                             nil
                                           end
                 result
-              rescue StandardError
-                server.pool.check_in(connection)
-                raise
               end
             else
               server.with_connection do |connection|

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

@@ -172,16 +172,9 @@ module Mongo
         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,
-            # unless the connection is pinned to a transaction (in which
-            # case it stays checked out for the transaction duration).
-            if context.connection_global_id
-              connection = server.pool.check_out_pinned_connection(
-                context.connection_global_id
-              )
+            server.pool.with_cursor_connection(context: context) do |connection|
+              operation.execute_with_connection(connection, context: context)
             end
-            connection ||= server.pool.check_out(context: context)
-            operation.execute_with_connection(connection, context: context)
           else
             operation.execute(server, context: context)
           end

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

@@ -73,10 +73,11 @@ module Mongo
           context = Operation::Context.new(client: client, session: session,
                                            operation_timeouts: view.operation_timeouts)
           if server.load_balancer?
-            # Connection will be checked in when cursor is drained.
-            connection = server.pool.check_out(context: context)
-            result = send_initial_query_with_connection(connection, context.session, context: context)
-            result = send_fetch_query_with_connection(connection, session) unless inline?
+            result = server.pool.with_cursor_connection(context: context) do |connection|
+              res = send_initial_query_with_connection(connection, context.session, context: context)
+              res = send_fetch_query_with_connection(connection, session) unless inline?
+              res
+            end
           else
             result = send_initial_query(server, context)
             result = send_fetch_query(server, session) unless inline?

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

@@ -739,9 +739,9 @@ module Mongo
               connection_global_id: result.connection_global_id
             )
             result = if server.load_balancer?
-                       # Connection will be checked in when cursor is drained.
-                       connection = server.pool.check_out(context: context)
-                       op.execute_with_connection(connection, context: context)
+                       server.pool.with_cursor_connection(context: context) do |connection|
+                         op.execute_with_connection(connection, context: context)
+                       end
                      else
                        op.execute(server, context: context)
                      end

data/lib/mongo/cursor.rb

@@ -103,6 +103,19 @@ module Mongo
           self.class.finalize(kill_spec(@connection_global_id), cluster)
         )
       end
+    rescue Exception # rubocop:disable Lint/RescueException
+      # In load-balanced topology the connection of the initial result is
+      # checked out of the pool until the cursor is drained. If the cursor
+      # cannot be constructed, nothing will ever check the connection back
+      # in, so release it here before the error propagates. Exception (not
+      # StandardError) is rescued so that an interrupt does not permanently
+      # leak the connection. In other topologies the connection is not owned
+      # by the cursor and must not be touched here.
+      if server&.load_balancer? && result.is_a?(Operation::Result) &&
+         (connection = result.connection)
+        connection.connection_pool.check_in_if_checked_out(connection)
+      end
+      raise
     end
 
     # @api private

data/lib/mongo/database/view.rb

@@ -273,12 +273,13 @@ module Mongo
         execution_opts = {}
         execution_opts[:deserialize_as_bson] = opts.delete(:deserialize_as_bson) if opts.key?(:deserialize_as_bson)
         if server.load_balancer?
-          connection = server.pool.check_out(context: context)
-          initial_query_op(session, opts).execute_with_connection(
-            connection,
-            context: context,
-            options: execution_opts
-          )
+          server.pool.with_cursor_connection(context: context) do |connection|
+            initial_query_op(session, opts).execute_with_connection(
+              connection,
+              context: context,
+              options: execution_opts
+            )
+          end
         else
           initial_query_op(session, opts).execute(
             server,

data/lib/mongo/database.rb

@@ -339,15 +339,12 @@ module Mongo
           server = selector.select_server(cluster, nil, session)
           if server.load_balancer?
             # The connection is checked in by the cursor when it is drained.
-            connection = check_out_cursor_command_connection(server, context)
-            begin
-              op.execute_with_connection(connection, context: context, options: execution_opts)
-            rescue StandardError
-              # Release the connection before the error propagates so that
-              # a retried attempt checks out a fresh one.
-              connection.connection_pool.check_in(connection) unless connection.pinned?
-              connection = nil
-              raise
+            # If the command fails, the connection is released before the
+            # error propagates so that a retried attempt checks out a
+            # fresh one.
+            server.pool.with_cursor_connection(context: context) do |conn|
+              connection = conn
+              op.execute_with_connection(conn, context: context, options: execution_opts)
             end
           else
             op.execute(server, context: context, options: execution_opts)
@@ -366,7 +363,7 @@ module Mongo
         # If the cursor was created it owns the session and connection;
         # otherwise (error or no cursor in the response) release them here.
         unless cursor
-          connection.connection_pool.check_in(connection) if connection && !connection.pinned?
+          connection.connection_pool.check_in_if_checked_out(connection) if connection
           session.end_session if session && session.implicit?
         end
       end

data/lib/mongo/index/view.rb

@@ -421,8 +421,9 @@ module Mongo
 
       def send_initial_query(op, server, _session, context)
         if server.load_balancer?
-          connection = server.pool.check_out(context: context)
-          op.execute_with_connection(connection, context: context)
+          server.pool.with_cursor_connection(context: context) do |connection|
+            op.execute_with_connection(connection, context: context)
+          end
         else
           op.execute(server, context: context)
         end

data/lib/mongo/monitoring/event/secure.rb

@@ -37,6 +37,11 @@ module Mongo
           copydb
         ].freeze
 
+        # The hello and legacy hello command names. A constant, because
+        # sensitive? runs on every command event and an array literal would
+        # allocate on each call.
+        HELLO_COMMANDS = %w[hello ismaster isMaster].freeze
+
         # Check whether the command is sensitive in terms of command monitoring
         # spec. A command is detected as sensitive if it is in the
         # list or if it is a hello/legacy hello command, and
@@ -53,7 +58,7 @@ module Mongo
           # when speculativeAuthenticate is present, their commands AND replies
           # MUST be redacted from the events.
           # See https://github.com/mongodb/specifications/blob/master/source/command-logging-and-monitoring/command-logging-and-monitoring.md#security
-          %w[hello ismaster isMaster].include?(command_name.to_s) &&
+          HELLO_COMMANDS.include?(command_name.to_s) &&
             !!document['speculativeAuthenticate']
         end
 

data/lib/mongo/operation/map_reduce/result.rb

@@ -80,7 +80,7 @@ module Mongo
         # @since 2.0.0
         # @api public
         def successful?
-          !documents.nil?
+          !documents.nil? && parser.message.empty?
         end
 
         # Get the execution time of the map/reduce.
@@ -112,7 +112,11 @@ module Mongo
         # @since 2.0.0
         # @api private
         def validate!
-          documents.nil? ? raise_operation_failure : self
+          if documents.nil? || !parser.message.empty?
+            raise_operation_failure
+          else
+            self
+          end
         end
 
         # Get the cursor id.

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

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

data/lib/mongo/protocol/serializers.rb

@@ -319,16 +319,8 @@ module Mongo
           # @return [ Array<BSON::Document> ] Deserialized section.
           #
           # @since 2.5.0
-          def self.deserialize(buffer)
+          def self.deserialize(buffer, _options = {})
             raise NotImplementedError
-
-            start_size = buffer.length
-            section_size = buffer.get_int32 # get the size
-            end_size = start_size - section_size
-            buffer.get_cstring # get the identifier
-            documents = []
-            documents << BSON::Document.from_bson(buffer) until buffer.length == end_size
-            documents
           end
         end
       end

data/lib/mongo/server/app_metadata.rb

@@ -130,7 +130,6 @@ module Mongo
             doc[:driver] = driver_doc
             doc[:os] = os_doc
             doc[:platform] = platform_string
-            doc[:backpressure] = '2'
             env_doc.tap { |env| doc[:env] = env if env }
           end
       end
@@ -157,7 +156,7 @@ module Mongo
       def document
         @document ||= begin
           client = Truncator.new(client_document).document
-          BSON::Document.new(compression: @compressors, client: client).tap do |doc|
+          BSON::Document.new(compression: @compressors, client: client, backpressure: '2').tap do |doc|
             doc[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
             doc.update(Utils.transform_server_api(@server_api)) if @server_api
           end

data/lib/mongo/server/connection.rb

@@ -124,6 +124,13 @@ module Mongo
       # across all connections.
       attr_reader :global_id
 
+      # @return [ Hash | nil ] OpenTelemetry span attributes describing this
+      #   connection. Built once by the tracer and reused for every command
+      #   on the connection.
+      #
+      # @api private
+      attr_accessor :tracing_attributes
+
       def_delegators :server, :tracer
 
       # The connection pool from which this connection was created.

data/lib/mongo/server/connection_pool.rb

@@ -432,6 +432,30 @@ module Mongo
         check_invariants
       end
 
+      # Check a connection back into the pool only if this pool still holds
+      # it as checked out and no other owner has claimed it.
+      #
+      # Unlike #check_in, this method is safe to call when the connection may
+      # have been checked in already (e.g. by Session#unpin while handling a
+      # transient transaction error) or may be pinned to a transaction or
+      # cursor that will check it in later; in both cases it does nothing.
+      #
+      # @param [ Mongo::Server::Connection ] connection The connection.
+      #
+      # @api private
+      def check_in_if_checked_out(connection)
+        check_invariants
+
+        @lock.synchronize do
+          return if connection.pinned?
+          return unless @checked_out_connections.include?(connection)
+
+          do_check_in(connection)
+        end
+      ensure
+        check_invariants
+      end
+
       # Executes the check in after having already acquired the lock.
       #
       # @param [ Mongo::Server::Connection ] connection The connection.
@@ -758,16 +782,43 @@ module Mongo
       rescue Error::SocketError, Error::SocketTimeoutError, Error::ConnectionPerished => e
         maybe_raise_pool_cleared!(connection, e)
       ensure
-        if connection && !connection.pinned?
-          # Do not check in if the connection is pinned (the session or cursor
-          # owns it and will check it in later when unpinning). Also skip
-          # check-in if the connection was already checked in during the block
-          # (e.g. by Session#unpin after an error on the first operation).
-          checked_out = @lock.synchronize do
-            @checked_out_connections.include?(connection)
-          end
-          check_in(connection) if checked_out
+        # Do not check in if the connection is pinned (the session or cursor
+        # owns it and will check it in later when unpinning) or was already
+        # checked in during the block (e.g. by Session#unpin after an error
+        # on the first operation).
+        check_in_if_checked_out(connection) if connection
+      end
+
+      # Check out a connection for the initial command of a cursor-returning
+      # operation in load-balanced topology and yield it to the block.
+      #
+      # On success the connection remains checked out: the cursor assumes
+      # ownership and checks it in when drained or closed. If the block
+      # raises, no cursor exists to do that, so the connection is checked
+      # back in here before the error propagates, unless another owner
+      # already claimed it (it is pinned to a transaction, or Session#unpin
+      # checked it in while handling a transient transaction error).
+      #
+      # If the operation context is pinned to a connection (e.g. inside a
+      # transaction), the pinned connection is reused.
+      #
+      # @param [ Mongo::Operation::Context | nil ] :context Context of the
+      #   operation the connection is requested for, if any.
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @api private
+      def with_cursor_connection(context:)
+        if context&.connection_global_id
+          connection = check_out_pinned_connection(context.connection_global_id)
         end
+        connection ||= check_out(context: context)
+        succeeded = false
+        result = yield(connection)
+        succeeded = true
+        result
+      ensure
+        check_in_if_checked_out(connection) if connection && !succeeded
       end
 
       # Close sockets that have been open for longer than the max idle time,

data/lib/mongo/session.rb

@@ -297,6 +297,13 @@ module Mongo
     # @api private
     attr_accessor :recovery_token
 
+    # @return [ Array<Integer, String> | nil ] The transaction number and the
+    #   OpenTelemetry tracer's key for that transaction. Built once by the
+    #   tracer and reused for every operation in the transaction.
+    #
+    # @api private
+    attr_accessor :tracing_transaction_key
+
     # Error message indicating that the session was retrieved from a client with a different cluster than that of the
     # client through which it is currently being used.
     #

data/lib/mongo/tracing/open_telemetry/command_tracer.rb

@@ -23,12 +23,8 @@ module Mongo
       class CommandTracer
         include Mongo::Monitoring::Event::Secure
 
-        # Commands for which a span MUST NOT be created. The OpenTelemetry spec
-        # requires drivers to skip command spans for sensitive commands listed in
-        # the Command Logging and Monitoring spec. We additionally skip hello /
-        # legacy hello in all forms — these are handshake/heartbeat traffic and
-        # would only add noise to traces.
-        HELLO_COMMANDS = %w[hello ismaster isMaster].freeze
+        # Upper bound of the lsid string cache (see #lsid).
+        LSID_CACHE_MAX = 128
 
         # Initializes a new CommandTracer.
         #
@@ -41,6 +37,8 @@ module Mongo
           @otel_tracer = otel_tracer
           @parent_tracer = parent_tracer
           @query_text_max_length = query_text_max_length
+          @lsid_cache = {}
+          @lsid_cache_mutex = Mutex.new
         end
 
         # Starts a span for a MongoDB command.
@@ -64,55 +62,84 @@ module Mongo
         # @yield the block representing the command to be traced.
         #
         # @return [ Object ] the result of the command.
-        # rubocop:disable Lint/RescueException
-        def trace_command(message, _operation_context, connection)
-          return yield if skip_tracing?(message)
+        def trace_command(message, _operation_context, connection, &block)
+          # Read the command document and name once and pass them on: every
+          # read of message.documents allocates.
+          doc = message.documents.first
+          name = command_name(doc)
+          return yield if skip_tracing?(doc, name)
 
           # Commands should always be nested under their operation span, not directly under
           # the transaction span. Don't pass with_parent to use automatic parent resolution
           # from the currently active span (the operation span).
-          span = create_command_span(message, connection)
-          ::OpenTelemetry::Trace.with_span(span) do |s, c|
+          span = create_command_span(name, doc, connection)
+          # With no SDK and no valid parent, the API returns a span with an
+          # invalid context. It cannot be made current, recorded or
+          # propagated, so it gets no work at all, not even finishing it.
+          return yield unless span.context.valid?
+
+          trace_with_span(span, message, name, doc, &block)
+        end
+
+        private
+
+        # Runs the command with the span made current, and finishes the span.
+        # A span that is not recording is still made current, so that its
+        # context is propagated, but gets no further attributes and no
+        # outcome: the SDK would discard them.
+        #
+        # @param span [ OpenTelemetry::Trace::Span ] a span with a valid context.
+        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
+        #
+        # @return [ Object ] the result of the command.
+        #
+        # rubocop:disable Lint/RescueException
+        def trace_with_span(span, message, name, doc)
+          recording = span.recording?
+          apply_deferred_attributes(span, message, name, doc) if recording
+          ::OpenTelemetry::Trace.with_span(span) do |s, _c|
             yield.tap do |result|
-              process_command_result(result, cursor_id(message), c, s)
+              process_command_result(result, s) if recording
             end
           end
         rescue Exception => e
-          handle_command_exception(span, e)
+          handle_command_exception(span, e) if recording
           raise e
         ensure
-          span&.finish
+          span.finish
         end
         # rubocop:enable Lint/RescueException
 
-        private
-
         # Determines whether the command must not be traced. Sensitive auth
         # commands carry credentials in their payloads (SCRAM proofs, cleartext
         # passwords, etc.) and the OpenTelemetry spec requires drivers to skip
-        # command spans for them. Hello / legacy hello are also skipped to keep
-        # handshake traffic out of traces.
+        # command spans for them. Hello / legacy hello in all forms
+        # (Secure::HELLO_COMMANDS) are also skipped: they are handshake and
+        # heartbeat traffic and would only add noise to traces.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
+        # @param name [ String ] the command name.
         #
         # @return [ Boolean ] true when no command span should be created.
-        def skip_tracing?(message)
-          name = command_name(message)
+        def skip_tracing?(doc, name)
           return true if HELLO_COMMANDS.include?(name)
 
-          sensitive?(command_name: name, document: message.documents.first)
+          sensitive?(command_name: name, document: doc)
         end
 
         # Creates a span for a command.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
         # @param connection [ Mongo::Server::Connection ] the connection.
         #
         # @return [ OpenTelemetry::Trace::Span ] the created span.
-        def create_command_span(message, connection)
+        def create_command_span(name, doc, connection)
           @otel_tracer.start_span(
-            command_name(message),
-            attributes: span_attributes(message, connection),
+            name,
+            attributes: span_attributes(doc, name, connection),
             kind: :client
           )
         end
@@ -120,21 +147,17 @@ module Mongo
         # Processes the command result and updates span attributes.
         #
         # @param result [ Object ] the command result.
-        # @param cursor_id [ Integer | nil ] the cursor ID.
-        # @param context [ OpenTelemetry::Context ] the context.
         # @param span [ OpenTelemetry::Trace::Span ] the current span.
-        def process_command_result(result, cursor_id, context, span)
-          process_cursor_context(result, cursor_id, context, span)
+        def process_command_result(result, span)
+          process_cursor_context(result, span)
           maybe_trace_error(result, span)
         end
 
         # Handles exceptions that occur during command execution.
         #
-        # @param span [ OpenTelemetry::Trace::Span | nil ] the span.
+        # @param span [ OpenTelemetry::Trace::Span ] the span.
         # @param exception [ Exception ] the exception that occurred.
         def handle_command_exception(span, exception)
-          return unless span
-
           if exception.is_a?(Mongo::Error::OperationFailure)
             span.set_attribute('db.response.status_code', exception.code.to_s)
           end
@@ -142,70 +165,68 @@ module Mongo
           span.status = ::OpenTelemetry::Trace::Status.error("Unhandled exception of type: #{exception.class}")
         end
 
-        # Builds span attributes for the command.
+        # Builds the attributes passed at span creation: the cheap set the
+        # OpenTelemetry spec recommends. They are built for every span,
+        # recorded or not, and are the only ones the sampler sees. The rest
+        # are set by apply_deferred_attributes once the span is known to
+        # record.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
+        # @param name [ String ] the command name.
         # @param connection [ Mongo::Server::Connection ] the connection.
         #
         # @return [ Hash ] OpenTelemetry span attributes following MongoDB semantic conventions.
-        def span_attributes(message, connection)
-          base_attributes(message)
-            .merge(connection_attributes(connection))
-            .merge(session_attributes(message))
-            .compact
+        def span_attributes(doc, name, connection)
+          {
+            'db.system.name' => 'mongodb',
+            'db.namespace' => database(doc),
+            'db.collection.name' => collection_name(name, doc),
+            'db.command.name' => name
+          }.compact.merge(connection_attributes(connection))
         end
 
-        # Returns base database and command attributes.
+        # Sets the remaining attributes on a span that is recording. They are
+        # not visible to the sampler; only custom samplers keying on them are
+        # affected.
         #
+        # @param span [ OpenTelemetry::Trace::Span ] the span.
         # @param message [ Mongo::Protocol::Message ] the command message.
-        #
-        # @return [ Hash ] base span attributes.
-        def base_attributes(message)
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
+        def apply_deferred_attributes(span, message, name, doc)
           {
-            'db.system.name' => 'mongodb',
-            'db.namespace' => database(message),
-            'db.collection.name' => collection_name(message),
-            'db.command.name' => command_name(message),
-            'db.query.summary' => query_summary(message),
-            'db.query.text' => query_text(message)
-          }
+            'db.query.summary' => query_summary(name, doc),
+            'db.query.text' => query_text(message),
+            'db.mongodb.cursor_id' => cursor_id(name, doc),
+            'db.mongodb.lsid' => lsid(doc),
+            'db.mongodb.txn_number' => txn_number(doc)
+          }.each do |key, value|
+            span.set_attribute(key, value) unless value.nil?
+          end
         end
 
-        # Returns connection-related attributes.
+        # Returns connection-related attributes, built once per connection,
+        # frozen and kept on the connection. Two threads may build them at
+        # the same time; they build the same hash, so either result is fine.
         #
         # @param connection [ Mongo::Server::Connection ] the connection.
         #
         # @return [ Hash ] connection span attributes.
         def connection_attributes(connection)
-          {
+          connection.tracing_attributes ||= {
             'server.port' => connection.address.port,
             'server.address' => connection.address.host,
             'network.transport' => connection.transport.to_s,
             'db.mongodb.server_connection_id' => connection.server.description.server_connection_id,
             'db.mongodb.driver_connection_id' => connection.id
-          }
-        end
-
-        # Returns session and transaction attributes.
-        #
-        # @param message [ Mongo::Protocol::Message ] the command message.
-        #
-        # @return [ Hash ] session span attributes.
-        def session_attributes(message)
-          {
-            'db.mongodb.cursor_id' => cursor_id(message),
-            'db.mongodb.lsid' => lsid(message),
-            'db.mongodb.txn_number' => txn_number(message)
-          }
+          }.freeze
         end
 
         # Processes cursor context from the command result.
         #
         # @param result [ Object ] the command result.
-        # @param _cursor_id [ Integer | nil ] the cursor ID (unused).
-        # @param _context [ OpenTelemetry::Context ] the context (unused).
         # @param span [ OpenTelemetry::Trace::Span ] the current span.
-        def process_cursor_context(result, _cursor_id, _context, span)
+        def process_cursor_context(result, span)
           cursor_id = normalize_cursor_id(result.cursor_id)
           return unless cursor_id.positive?
 
@@ -242,51 +263,56 @@ module Mongo
 
         # Generates a summary string for the query.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ String ] summary in format "command_name db.collection" or "command_name db".
-        def query_summary(message)
-          if (coll_name = collection_name(message))
-            "#{command_name(message)} #{database(message)}.#{coll_name}"
+        def query_summary(name, doc)
+          if (coll_name = collection_name(name, doc))
+            "#{name} #{database(doc)}.#{coll_name}"
           else
-            "#{command_name(message)} #{database(message)}"
+            "#{name} #{database(doc)}"
           end
         end
 
-        # Extracts the collection name from the command message.
+        # Extracts the collection name from the command document.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ String | nil ] the collection name, or nil if not applicable.
-        def collection_name(message)
-          case command_name(message)
+        def collection_name(name, doc)
+          case name
           when 'getMore'
-            message.documents.first['collection'].to_s
+            doc['collection'].to_s
           when 'listCollections', 'listDatabases', 'commitTransaction', 'abortTransaction'
             nil
           else
-            value = message.documents.first.values.first
+            # The first value, read without building an array of all of them.
+            value = doc.each_value { |v| break v } # rubocop:disable Lint/UnreachableLoop -- first value only
             # Return nil if the value is not a string (e.g., for admin commands that have numeric values)
             value.is_a?(String) ? value : nil
           end
         end
 
-        # Extracts the command name from the message.
+        # Extracts the command name, the first key of the command document,
+        # without building an array of all keys.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ String ] the command name.
-        def command_name(message)
-          message.documents.first.keys.first.to_s
+        def command_name(doc)
+          doc.each_key { |key| return key.to_s } # rubocop:disable Lint/UnreachableLoop -- first key only
+          ''
         end
 
-        # Extracts the database name from the message.
+        # Extracts the database name from the command document.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ String ] the database name.
-        def database(message)
-          message.documents.first['$db'].to_s
+        def database(doc)
+          doc['$db'].to_s
         end
 
         # Checks if query text capture is enabled.
@@ -298,34 +324,47 @@ module Mongo
 
         # Extracts the cursor ID from getMore commands.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param name [ String ] the command name.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ Integer | nil ] the cursor ID, or nil if not a getMore command.
-        def cursor_id(message)
-          return unless command_name(message) == 'getMore'
+        def cursor_id(name, doc)
+          return unless name == 'getMore'
 
-          message.documents.first['getMore'].value
+          doc['getMore'].value
         end
 
-        # Extracts the logical session ID from the command.
+        # Extracts the logical session ID from the command, as a UUID string.
+        # The string is formatted once per session id and kept in a small
+        # cache, cleared when it reaches LSID_CACHE_MAX entries.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
         #
-        # @return [ BSON::Binary | nil ] the session ID, or nil if not present.
-        def lsid(message)
-          lsid_doc = message.documents.first['lsid']
+        # @return [ String | nil ] the session ID, or nil if not present.
+        def lsid(doc)
+          lsid_doc = doc['lsid']
           return unless lsid_doc
 
-          lsid_doc['id'].to_uuid
+          binary = lsid_doc['id']
+          key = binary.data
+          cached = @lsid_cache_mutex.synchronize { @lsid_cache[key] }
+          return cached if cached
+
+          uuid = binary.to_uuid
+          @lsid_cache_mutex.synchronize do
+            @lsid_cache.clear if @lsid_cache.size >= LSID_CACHE_MAX
+            @lsid_cache[key] = uuid
+          end
+          uuid
         end
 
         # Extracts the transaction number from the command.
         #
-        # @param message [ Mongo::Protocol::Message ] the command message.
+        # @param doc [ Hash ] the command document.
         #
         # @return [ Integer | nil ] the transaction number, or nil if not present.
-        def txn_number(message)
-          txn_num = message.documents.first['txnNumber']
+        def txn_number(doc)
+          txn_num = doc['txnNumber']
           return unless txn_num
 
           txn_num.value

data/lib/mongo/tracing/open_telemetry/operation_tracer.rb

@@ -37,6 +37,8 @@ module Mongo
         def initialize(otel_tracer, parent_tracer)
           @otel_tracer = otel_tracer
           @parent_tracer = parent_tracer
+          @operation_names = {}
+          @operation_names_mutex = Mutex.new
         end
 
         # Trace a MongoDB operation.
@@ -53,21 +55,43 @@ module Mongo
         # @yield the block representing the operation to be traced.
         #
         # @return [ Object ] the result of the operation.
-        #
-        # rubocop:disable Lint/RescueException
         def trace_operation(operation, operation_context, op_name: nil, &block)
           span = create_operation_span(operation, operation_context, op_name)
-          execute_with_span(span, operation, &block)
+          # With no SDK and no valid parent, the API returns a span with an
+          # invalid context. It cannot be made current, recorded or
+          # propagated, so it gets no work at all, not even finishing it.
+          return yield unless span.context.valid?
+
+          trace_with_span(span, operation, &block)
+        end
+
+        private
+
+        # Runs the operation with the span made current, and finishes the span.
+        # A span that is not recording is still made current, so that the
+        # command spans created within it nest under it, but gets no further
+        # attributes and no outcome: the SDK would discard them.
+        #
+        # @param span [ OpenTelemetry::Trace::Span ] a span with a valid context.
+        # @param operation [ Mongo::Operation ] the operation.
+        #
+        # @return [ Object ] the result of the operation.
+        #
+        # rubocop:disable Lint/RescueException
+        def trace_with_span(span, operation, &block)
+          recording = span.recording?
+          if recording && !operation.cursor_id.nil?
+            span.set_attribute('db.mongodb.cursor_id', operation.cursor_id)
+          end
+          execute_with_span(span, operation, recording, &block)
         rescue Exception => e
-          handle_span_exception(span, e)
+          handle_span_exception(span, e) if recording
           raise e
         ensure
-          span&.finish
+          span.finish
         end
         # rubocop:enable Lint/RescueException
 
-        private
-
         # Creates an OpenTelemetry span for the operation.
         #
         # @param operation [ Mongo::Operation ] the operation.
@@ -89,14 +113,15 @@ module Mongo
         #
         # @param span [ OpenTelemetry::Trace::Span ] the span.
         # @param operation [ Mongo::Operation ] the operation.
+        # @param recording [ true | false ] whether the span is recording.
         #
         # @yield the block to execute.
         #
         # @return [ Object ] the result of the block.
-        def execute_with_span(span, operation)
+        def execute_with_span(span, operation, recording)
           ::OpenTelemetry::Trace.with_span(span) do |s, c|
             yield.tap do |result|
-              process_cursor_context(result, operation.cursor_id, c, s)
+              process_cursor_context(result, operation.cursor_id, c, s, recording)
             end
           end
         end
@@ -106,8 +131,6 @@ module Mongo
         # @param span [ OpenTelemetry::Trace::Span ] the span.
         # @param exception [ Exception ] the exception.
         def handle_span_exception(span, exception)
-          return unless span
-
           span.record_exception(exception)
           span.status = ::OpenTelemetry::Trace::Status.error(
             "Unhandled exception of type: #{exception.class}"
@@ -115,16 +138,28 @@ module Mongo
         end
 
         # Returns the operation name from the provided name or operation class.
+        # The name derived from the class is cached per class. There are few
+        # operation classes, so the cache needs no bound. It is guarded by a
+        # mutex because not every Ruby runtime makes Hash writes thread-safe.
         #
         # @param operation [ Mongo::Operation ] the operation.
         # @param op_name [ String | nil ] optional operation name.
         #
         # @return [ String ] the operation name in lowercase.
         def operation_name(operation, op_name = nil)
-          op_name || operation.class.name.split('::').last.downcase
+          return op_name if op_name
+
+          klass = operation.class
+          @operation_names_mutex.synchronize do
+            @operation_names[klass] ||= klass.name.split('::').last.downcase
+          end
         end
 
-        # Builds span attributes for the operation.
+        # Builds the attributes passed at span creation. The cursor id is set
+        # by trace_with_span once the span is known to record.
+        # db.operation.summary is outside the spec's recommended creation set,
+        # but it is the span name, which is built anyway, and an attribute
+        # passed at creation is cheaper than one set later.
         #
         # @param operation [ Mongo::Operation ] the operation.
         # @param op_name [ String | nil ] optional operation name.
@@ -136,8 +171,7 @@ module Mongo
             'db.namespace' => operation.db_name.to_s,
             'db.collection.name' => collection_name(operation),
             'db.operation.name' => operation_name(operation, op_name),
-            'db.operation.summary' => operation_span_name(operation, op_name),
-            'db.mongodb.cursor_id' => operation.cursor_id,
+            'db.operation.summary' => operation_span_name(operation, op_name)
           }.compact
         end
 
@@ -150,7 +184,8 @@ module Mongo
         # @param cursor_id [ Integer | nil ] the cursor ID before the operation.
         # @param context [ OpenTelemetry::Context ] the OpenTelemetry context.
         # @param span [ OpenTelemetry::Trace::Span ] the current span.
-        def process_cursor_context(result, cursor_id, context, span)
+        # @param recording [ true | false ] whether the span is recording.
+        def process_cursor_context(result, cursor_id, context, span, recording)
           return unless result.is_a?(Cursor)
 
           if result.id.zero?
@@ -159,7 +194,7 @@ module Mongo
           elsif result.id && cursor_id.nil?
             # New cursor created, store its context.
             cursor_context_map[result.id] = context
-            span.set_attribute('db.mongodb.cursor_id', result.id)
+            span.set_attribute('db.mongodb.cursor_id', result.id) if recording
           end
         end
 

data/lib/mongo/tracing/open_telemetry/tracer.rb

@@ -200,6 +200,9 @@ module Mongo
         # Generates a unique key for transaction tracking.
         #
         # Returns nil for implicit sessions or sessions not in a transaction.
+        # Every operation in a transaction needs the key, so it is cached on
+        # the session together with the transaction number it was built for.
+        # Two threads may build it at the same time; they build the same key.
         #
         # @param session [ Mongo::Session ] the session.
         #
@@ -207,7 +210,13 @@ module Mongo
         def transaction_map_key(session)
           return if session.nil? || session.implicit? || !session.in_transaction?
 
-          "#{session.session_id['id'].to_uuid}-#{session.txn_num}"
+          txn_num = session.txn_num
+          cached = session.tracing_transaction_key
+          return cached[1] if cached && cached[0] == txn_num
+
+          key = "#{session.session_id['id'].to_uuid}-#{txn_num}"
+          session.tracing_transaction_key = [ txn_num, key ].freeze
+          key
         end
 
         private

data/lib/mongo/version.rb

@@ -5,5 +5,5 @@ module Mongo
   #
   # Note that this file is automatically updated via `rake candidate:create`.
   # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '2.26.0'
+  VERSION = '2.26.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongo
 version: !ruby/object:Gem::Version
-  version: 2.26.0
+  version: 2.26.1
 platform: ruby
 authors:
 - The MongoDB Ruby Team
@@ -561,7 +561,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 4.0.23
 specification_version: 4
 summary: Ruby driver for MongoDB
 test_files: []