db.currentOp()

On this page

Definition

Compatibility
Behavior
Access Control
Examples
Output Example
Specific Output Examples
Output Fields

Definition

db.currentOp()

Returns a document that contains information on in-progress operations for the database instance. The db.currentOp() method wraps the database command currentOp.

Use the $currentOp aggregation stage instead of the currentOp command and its mongosh helper method db.currentOp().

Note

Starting in MongoDB 5.0, the $currentOp aggregation stage is used when running the helper method db.currentOp() with mongosh.

Given this, in the 5.0 version of the shell and with mongosh, db.currentOp() result sets are not subject to the 16MB BSON document return size document return size limit for documents of the previous legacy mongo versions.

Compatibility

This method is available in deployments hosted in the following environments:

MongoDB Atlas: The fully managed service for MongoDB deployments in the cloud

Important

This command is not supported in M0, M2, and M5 clusters. For more information, see Unsupported Commands.

MongoDB Enterprise: The subscription-based, self-managed version of MongoDB
MongoDB Community: The source-available, free-to-use, and self-managed version of MongoDB

Syntax

db.currentOp() has the following form:

db.currentOp(<operations>)

db.currentOp() can take the following optional argument:

Parameter	Type	Description
operations	boolean or document	Optional. Specifies the operations to report on. Can pass either a boolean or a document: Specify `true` to include operations on idle connections and system operations. Specify a document with query conditions to report only on those operations that match the conditions. See Behavior for details.

Behavior

db.currentOp() can accept a filter document or a boolean parameter.

If you pass a filter document to db.currentOp(), the output returns information only for the current operations that match the filter. The filter document can contain:

Field	Description
`"$ownOps"`	Boolean. If set to `true`, returns information on the current user's operations only. On `mongod` instances, users can always run `db.currentOp( { "$ownOps": true } )` to view their own operations.
`"$all"`	Boolean. If set to `true`, returns information on all operations, including operations on idle connections and system operations. If the document includes `"$all": true` along with Output Fields conditions, only the `"$all":true` applies.
<filter>	Specify filter conditions on the Output Fields. See Examples. If the document includes `"$all": true` along with Output Fields conditions, only the `"$all": true` applies.

Passing in true to db.currentOp() is equivalent to passing in a document of { "$all": true }. The following operations are equivalent:

db.currentOp(true)
db.currentOp( { "$all": true } )

db.currentOp() and the database profiler report the same basic diagnostic information for all CRUD operations, including the following:

These operations are also included in the logging of slow queries. See slowOpThresholdMs for more information about slow query logging.

Access Control

On systems running with authorization, the user must have access that includes the inprog privilege action.

Users can run db.currentOp( { "$ownOps": true } ) on mongod instances to view their own operations even without the inprog privilege action.

Tip

Examples

The following examples use the db.currentOp() method with various query documents to filter the output.

Write Operations Waiting for a Lock

The following example returns information on all write operations that are waiting for a lock:

db.currentOp(
   {
     "waitingForLock" : true,
     $or: [
        { "op" : { "$in" : [ "insert", "update", "remove" ] } },
        { "command.findandmodify": { $exists: true } }
    ]
   }
)

Active Operations with no Yields

The following example returns information on all active running operations that have never yielded:

db.currentOp(
   {
     "active" : true,
     "numYields" : 0,
     "waitingForLock" : false
   }
)

Active Operations on a Specific Database

The following example returns information on all active operations for database db1 that have been running longer than 3 seconds:

db.currentOp(
   {
     "active" : true,
     "secs_running" : { "$gt" : 3 },
     "ns" : /^db1\./
   }
)

Active Indexing Operations

The following example returns information on index creation operations on any number of fields:

db.adminCommand(
    {
      currentOp: true,
      $or: [
        { op: "command", "command.createIndexes": { $exists: true }  },
        { op: "command", "command.$truncated": /^\{ createIndexes/  },
        { op: "none", "msg" : /^Index Build/ }
      ]
    }
)

Output Example

The following is a prototype of db.currentOp() output.

The following is a prototype of the currentOp output when run on a standalone:

{
  "inprog": [
       {
         "type" : <string>,
         "host" : <string>,
         "desc" : <string>,
         "connectionId" : <number>,
         "client" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "active" : <boolean>,
         "currentOpTime" : <string>,
         "effectiveUsers" : [
            {
               "user" : <string>,
               "db" : <string>
            }
         ],
         "opid" : <number>,
         "lsid" : {
            "id" : <UUID>,
            "uid" : <BinData>
         },
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "command" : <document>,
         "queryFramework" : <string>,
         "planSummary": <string>,
         "cursor" : {                              // only for getMore operations
            "cursorId" : <NumberLong()>,
            "createdDate" : <ISODate()>,
            "lastAccessDate" : <ISODate()>,
            "nDocsReturned" : <NumberLong()>,
            "nBatchesReturned" : <NumberLong()>,
            "noCursorTimeout" : <boolean>,
            "tailable" : <boolean>,
            "awaitData" : <boolean>,
            "originatingCommand" : <document>,
            "planSummary" : <string>,
            "operationUsingCursorId" : <NumberLong()>
         },
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "dataThroughputLastSecond" : <number>,
         "dataThroughputAverage" : <number>,
         "locks" : {
             "ParallelBatchWriterMode" : <string>,
             "ReplicationStateTransition" : <string>,
             "Global" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "ParallelBatchWriterMode" : {
                "acquireCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "acquireWaitCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "timeAcquiringMicros" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                },
                "deadlockCount" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                }
             },
             "ReplicationStateTransition" : {
                ...
             },
             "Global": {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
   "fsyncLock": <boolean>,
   "info": <string>,
    "ok": <num>
}

The following is a prototype of the currentOp output when run on a primary of a replica set:

{
  "inprog": [
       {
         "type" : <string>,
         "host" : <string>,
         "desc" : <string>,
         "connectionId" : <number>,
         "client" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "lsid" : {
            "id" : <UUID>,
            "uid" : <BinData>
         },
         "transaction" : {
            "parameters" : {
               "txnNumber" : <NumberLong()>,
               "autocommit" : <boolean>,
               "readConcern" : {
                  "level" : <string>
               }
            },
            "readTimestamp" : <Timestamp>,
            "startWallClockTime" : <string>,
            "timeOpenMicros" : <NumberLong()>,
            "timeActiveMicros" : <NumberLong()>,
            "timeInactiveMicros" : <NumberLong()>,
            "expiryTime" : <string>,
         },
         "active" : <boolean>,
         "currentOpTime" : <string>,
         "effectiveUsers" : [
            {
               "user" : <string>,
               "db" : <string>
            }
         ],
         "opid" : <number>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "command" : <document>,
         "originatingCommand" : <document>,
         "queryFramework" : <string>,
         "planSummary": <string>,
         "prepareReadConflicts" : <NumberLong()>,
         "writeConflicts" : <NumberLong()>,
         "cursor" : {                              // only for getMore operations
            "cursorId" : <NumberLong()>,
            "createdDate" : <ISODate()>,
            "lastAccessDate" : <ISODate()>,
            "nDocsReturned" : <NumberLong()>,
            "nBatchesReturned" : <NumberLong()>,
            "noCursorTimeout" : <boolean>,
            "tailable" : <boolean>,
            "awaitData" : <boolean>,
            "originatingCommand" : <document>,
            "planSummary" : <string>,
            "operationUsingCursorId" : <NumberLong()>
         },
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "dataThroughputLastSecond" : <number>,
         "dataThroughputAverage" : <number>,
         "locks" : {
             "ParallelBatchWriterMode" : <string>,
             "ReplicationStateTransition" : <string>,
             "Global" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "ParallelBatchWriterMode" : {
                "acquireCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "acquireWaitCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "timeAcquiringMicros" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                },
                "deadlockCount" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                }
             },
             "ReplicationStateTransition" : {
                ...
             },
             "Global" : {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
   "fsyncLock": <boolean>,
   "info": <string>,
   "ok": <num>,
   "operationTime": <timestamp>,
   "$clusterTime": <document>
}

The following is an example of the currentOp output when run on a mongos of a sharded cluster (Fields may vary depending on the operation being reported):

{
  "inprog": [
       {
         "shard": <string>,
         "type" : <string>,
         "host" : <string>,
         "desc" : <string>,
         "connectionId" : <number>,
         "client_s" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "lsid" : {
            "id" : <UUID>,
            "uid" : <BinData>
         },
         "transaction" : {
            "parameters" : {
               "txnNumber" : <NumberLong()>,
               "autocommit" : <boolean>,
               "readConcern" : {
                  "level" : <string>
               }
            },
            "readTimestamp" : <Timestamp>,
            "startWallClockTime" : <string>,
            "timeOpenMicros" : <NumberLong()>,
            "timeActiveMicros" : <NumberLong()>,
            "timeInactiveMicros" : <NumberLong()>,
            "expiryTime" : <string>,
         },
         "active" : <boolean>,
         "currentOpTime" : <string>,
         "effectiveUsers" : [
            {
               "user" : <string>,
               "db" : <string>
            }
         ],
         "runBy" : [
            {
               "user" : <string>,
               "db" : <string>
            }
         ],
         "twoPhaseCommitCoordinator" : {
            "lsid" : {
               "id" : <UUID>,
               "uid" : <BinData>
            },
            "txnNumber" : <NumberLong>,
            "numParticipants" : <NumberLong>,
            "state" : <string>,
            "commitStartTime" : <ISODate>,
            "hasRecoveredFromFailover" : <boolean>,
            "stepDurations" : <document>,
            "decision" : <document>,
            "deadline" : <ISODate>
         }
         "opid" : <string>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "command" : <document>,
         "configTime" : <Timestamp>,           // Starting in 5.0
         "topologyTime" : <Timestamp>,           // Starting in 5.0
         "queryFramework" : <string>,            // Starting in 6.2
         "planSummary": <string>,
         "prepareReadConflicts" : <NumberLong()>,
         "writeConflicts" : <NumberLong()>,
         "cursor" : {                              // only for getMore operations
            "cursorId" : <NumberLong()>,
            "createdDate" : <ISODate()>,
            "lastAccessDate" : <ISODate()>,
            "nDocsReturned" : <NumberLong()>,
            "nBatchesReturned" : <NumberLong()>,
            "noCursorTimeout" : <boolean>,
            "tailable" : <boolean>,
            "awaitData" : <boolean>,
            "originatingCommand" : <document>,
            "planSummary" : <string>,
            "operationUsingCursorId" : <NumberLong()>
         },
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "dataThroughputLastSecond" : <number>,
         "dataThroughputAverage" : <number>,
         "locks" : {
             "ParallelBatchWriterMode" : <string>,
             "ReplicationStateTransition" : <string>,
             "Global" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "DDLDatabase" : <string>,
             "DDLCollection" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "ParallelBatchWriterMode": {
                "acquireCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "acquireWaitCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "timeAcquiringMicros" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                },
                "deadlockCount" : {
                   "r" : NumberLong(0),
                   "w" : NumberLong(0),
                   "R" : NumberLong(0),
                   "W" : NumberLong(0)
                }
             },
             "ReplicationStateTransition" : {
                ...
             },
             "Global" : {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
  "ok": <num>,
  "operationTime": <timestamp>,
  "$clusterTime": <document>
}

Specific Output Examples

These output samples illustrate currentOp output for particular operations. The fields that make up the actual output vary depending on the server's role.

Resharding Output Example

{
    type: "op",
    desc: "Resharding{Donor, Recipient, Coordinator}Service <reshardingUUID>",
    op: "command",
    ns: "<database>.<collection>",
    originatingCommand: {
        reshardCollection: "<database>.<collection>",
        key: <shardkey>,
        unique: <boolean>,
        collation: {locale: "simple"},
        // Other options to the reshardCollection command are omitted
        // to decrease the likelihood the output is truncated.
   },
   {donor, coordinator, recipient}State : "<service state>",
   approxDocumentsToCopy: NumberLong(<count>),
   approxBytesToCopy: NumberLong(<count>),
   bytesCopied: NumberLong(<count>),
   countWritesToStashCollections: NumberLong(<count>),
   countWritesDuringCriticalSection : NumberLong(<count>),
   countReadsDuringCriticalSection: NumberLong(<count>),
   deletesApplied: NumberLong(<count>),
   documentsCopied: NumberLong(<count>),
   insertsApplied: NumberLong(<count>),
   oplogEntriesFetched: NumberLong(<count>),
   oplogEntriesApplied: NumberLong(<count>),
   remainingOperationTimeEstimatedSecs: NumberLong(<count>),
   allShardsLowestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   allShardsHighestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   totalApplyTimeElapsedSecs: NumberLong(<count>),
   totalCopyTimeElapsedSecs: NumberLong(<count>),
   totalCriticalSectionTimeElapsedSecs : NumberLong(<count>),
   totalOperationTimeElapsedSecs: NumberLong(<count>),
   updatesApplied: NumberLong(<count>),
}

Global Index Example

{
    type: "op",
    desc: "GlobalIndex{Donor, Recipient, Coordinator}Service <globalIndexUUID}",
    op: "command",
    ns: "<database>.<collection>",
    originatingCommand: {
        createIndexes: "<database>.<collection>",
        key: <indexkeypattern>,
        unique: <boolean>,
        <Additional createIndexes options>
    },
   {donor, coordinator, recipient}State : "<service state>",
   approxDocumentsToScan: NumberLong(<count>),
   approxBytesToScan: NumberLong(<count>),
   bytesWrittenFromScan: NumberLong(<count>),
   countWritesToStashCollections: NumberLong(<count>),
   countWritesDuringCriticalSection : NumberLong(<count>),
   countReadsDuringCriticalSection: NumberLong(<count>),
   keysWrittenFromScan: NumberLong(<count>),
   remainingOperationTimeEstimatedSecs: NumberLong(<count>),
   allShardsLowestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   allShardsHighestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   totalCopyTimeElapsedSecs: NumberLong(<count>),
   totalCriticalSectionTimeElapsedSecs : NumberLong(<count>),
   totalOperationTimeElapsedSecs: NumberLong(<count>),
}

Output Fields

For a complete list of db.currentOp() output fields, see currentOp.

Back

db.createView

db.dropDatabase