wip

Author: comandeo-mongo

lib/mongo/collection.rb

@@ -412,21 +412,24 @@ def create(opts = {})
           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
@@ -455,25 +458,27 @@ def create(opts = {})
     # @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)
+        )
+        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
+            temp_write_concern = write_concern
+            write_concern = if opts[:write_concern]
+              WriteConcern.get(opts[:write_concern])
+            else
+              temp_write_concern
+            end
+            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

lib/mongo/collection/view/readable.rb

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

lib/mongo/collection/view/writable.rb

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

lib/mongo/database.rb

@@ -74,7 +74,8 @@ class Database
                    :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,