currentOp¶

On this page

Definition
Behavior
Access Control
Examples
Output Example
Output Fields

Definition¶

currentOp¶

Returns a document that contains information on in-progress operations for the mongod instance.

currentOp has the following form:

{ currentOp: 1 }

The mongo shell provides the db.currentOp() wrapper for the currentOp command.

Behavior¶

currentOp must run against the admin database, and it can accept several optional fields.

Field Description

"$ownOps"

Boolean. If set to true, returns information on the current user’s operations only.

On mongod instances, users are always authorized to run currentOp with "$ownOps": true to view their own operations. See access control.

New in version 3.2.9.

"$all"

Boolean. If set to true, returns information on all operations, including operations on idle connections and system operations.

"$all": true overrides any output field filters.

<filter> Specify filter conditions on the Output Fields. See Examples.

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.

Changed in version 3.2.9: On mongod instances, users can use $ownOps to view their own operations without the inprog privilege action.

copy

db.adminCommand( { currentOp: 1, "$ownOps": 1 } )

Examples¶

The following examples use the currentOp command with various query documents to filter the output.

Display All Current Operations¶

copy

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

Write Operations Waiting for a Lock¶

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

copy

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

Active Operations with no Yields¶

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

copy

db.adminCommand(
   {
     currentOp: true,
     "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:

copy

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

Active Indexing Operations¶

The following example returns information on index creation operations:

copy

db.adminCommand(
    {
      currentOp: true,
      $or: [
        { op: "command", "query.createIndexes": { $exists: true } },
        { op: "none", ns: /\.system\.indexes\b/ }
      ]
    }
)

Output Example¶

Standalone
Replica Set (Primary)
Sharded Cluster (mongos)

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

copy

{
  "inprog": [
       {
         "desc" : <string>,
         "threadId" : <string>,
         "connectionId" : <number>,
         "client" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "active" : <boolean>,
         "opid" : <number>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "query" : <document>,
         "insert" : <document>,
         "originatingCommand" : <document>,
         "planSummary": <string>,
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "locks" : {
             "Global" : <string>,
             "MMAPV1Journal" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "Global": {
                "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)
                }
             },
             "MMAPV1Journal": {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
   "fsyncLock": <boolean>,
   "info": <string>,
   "ok": 1
}

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

copy

{
  "inprog": [
       {
         "desc" : <string>,
         "threadId" : <string>,
         "connectionId" : <number>,
         "client" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "active" : <boolean>,
         "opid" : <number>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "query" : <document>,
         "insert" : <document>,
         "originatingCommand" : <document>,
         "planSummary": <string>,
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "locks" : {
             "Global" : <string>,
             "MMAPV1Journal" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "Global": {
                "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)
                }
             },
             "MMAPV1Journal": {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
   "fsyncLock": <boolean>,
   "info": <string>,
   "ok": 1
}

The following is a prototype of the currentOp output when run on a mongos of a sharded cluster:

copy

{
   "raw" : {
      <shard1>/<host>... : {
        "inprog": [
             {
               "desc" : <string>,
               "threadId" : <string>,
               "connectionId" : <number>,
               "client" : <string>,
               "appName" : <string>,
               "clientMetadata" : <document>,
               "active" : <boolean>,
               "opid" : <number>,
               "secs_running" : <NumberLong()>,
               "microsecs_running" : <number>,
               "op" : <string>,
               "ns" : <string>,
               "query" : <document>,
               "insert" : <document>,
               "originatingCommand" : <document>,
               "planSummary": <string>,
               "msg": <string>,
               "progress" : {
                   "done" : <number>,
                   "total" : <number>
               },
               "killPending" : <boolean>,
               "numYields" : <number>,
               "locks" : {
                   "Global" : <string>,
                   "Database" : <string>,
                   "Collection" : <string>,
                   "Metadata" : <string>,
                   "oplog" : <string>
               },
               "waitingForLock" : <boolean>,
               "lockStats" : {
                   "Global": {
                      "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)
                      }
                   },
                   "Database" : {
                      ...
                   },
                   ...
               }
             },
             ...
         ],
         "ok" : <number>,
         "$gleStats": <document>
      }
   },
   <shard2>/<host>... : {
     "inprog": [
        ...
         ],
         "ok" : <number>,
         "$gleStats": <document>
      }
   },
   "inprog" : [
      {
         "desc" : <string>,
         "threadId" : <string>,
         "connectionId" : <number>,
         "client_s" : <string>,
         "active" : true,
         "opid" : <string>. // format <shardname>:id

         ...

   ],
   "ok" : 1
}

Output Fields¶

currentOp.desc¶: A description of the client. This string includes the connectionId.

currentOp.threadId¶: An identifier for the thread that handles the operation and its connection.

currentOp.connectionId¶: An identifier for the connection where the operation originated.

currentOp.client¶: A string with information about where the operation originated.

currentOp.appName¶: A string with information about the type of client which made the request.

currentOp.opid¶: The identifier for the operation. You can pass this value to db.killOp() in the mongo shell to terminate the operation.

Warning

Terminate running operations with extreme caution. Only use db.killOp() to terminate operations initiated by clients and do not terminate internal database operations.

currentOp.active¶: A boolean value specifying whether the operation has started. Value is true if the operation has started or false if the operation is idle, such as an idle connection or an internal thread that is currently idle. An operation can be active even if the operation has yielded to another operation.

Changed in version 3.0: For some inactive background threads, such as an inactive signalProcessingThread, MongoDB suppresses various empty fields.

currentOp.secs_running¶

The duration of the operation in seconds. MongoDB calculates this value by subtracting the current time from the start time of the operation.

Only appears if the operation is running; i.e. if active is true.

currentOp.microsecs_running¶

New in version 2.6.

The duration of the operation in microseconds. MongoDB calculates this value by subtracting the current time from the start time of the operation.

Only appears if the operation is running; i.e. if active is true.

currentOp.op¶

A string that identifies the type of operation. The possible values are:

"none"
"update"
"insert"
"query"
"command"
"getmore"
"remove"
"killcursors"

"query" operations include read operations.

"command" operations include most commands such as the createIndexes and findandmodify.

Changed in version 3.0: Write operations that use the insert, update, and delete commands respectively display "insert", "update", and "remove" for op. Previous versions include these write commands under "query" operations.

Changed in version 3.2: Most commands including createIndexes and findandmodify display "command" for op. Previous versions of MongoDB included these commands under "query" operations.

currentOp.ns¶: The namespace the operation targets. A namespace consists of the database name and the collection name concatenated with a dot (.); that is, "<database>.<collection>".

currentOp.insert¶

Contains the document to be inserted for operations with op value of "insert". Only appears for operations with op value "insert".

Insert operations such as db.collection.insert() that use the insert command will have op value of "query".

currentOp.query¶

A document containing information on operations whose op value is not "insert". For instance, for a db.collection.find() operation, the query contains the query predicate.

query does not appear for op of "insert". query can also be an empty document.

For "update" or "remove" operations or for read operations categorized under "query", the query document contains the query predicate for the operations.

Changed in version 3.0.4: For "getmore" operations on cursors returned from a db.collection.find() or a db.collection.aggregate(), the query field contains respectively the query predicate or the issued aggregate command document. For details on the aggregate command document, see the aggregate reference page.

For other commands categorized under "query", query contains the issued command document. Refer to the specific command reference page for the details on the command document.

Changed in version 3.0: Previous versions categorized operations that used write commands under op of "query" and returned the write command information (e.g. query predicate, update statement, and update options) in query document.

currentOp.planSummary¶: A string that contains the query plan to help debug slow queries.

currentOp.client¶: The IP address (or hostname) and the ephemeral port of the client connection where the operation originates. If your inprog array has operations from many different clients, use this string to relate operations to clients.

currentOp.appName¶: New in version 3.4.

The identifier of the client application which ran the operation. If the operation was run in the MongoDB shell, the appName is always "MongoDB Shell". If the operation originated from a driver, appName may be set to a custom string.

currentOp.locks¶

Changed in version 3.0.

The locks document reports the type and mode of locks the operation currently holds. The possible lock types are as follows:

Lock Type	Description
`Global`	Represents global lock.
`MMAPV1Journal`	Represents MMAPv1 storage engine specific lock to synchronize journal writes; for non-MMAPv1 storage engines, the mode for `MMAPV1Journal` is empty.
`Database`	Represents database lock.
`Collection`	Represents collection lock.
`Metadata`	Represents metadata lock.
`oplog`	Represents lock on the oplog.

The possible modes are as follows:

Lock Mode	Description
`R`	Represents Shared (S) lock.
`W`	Represents Exclusive (X) lock.
`r`	Represents Intent Shared (IS) lock.
`w`	Represents Intent Exclusive (IX) lock.

currentOp.waitingForLock¶: Returns a boolean value. waitingForLock is true if the operation is waiting for a lock and false if the operation has the required lock.

currentOp.msg¶: The msg provides a message that describes the status and progress of the operation. In the case of indexing or mapReduce operations, the field reports the completion percentage.

currentOp.progress¶

Reports on the progress of mapReduce or indexing operations. The progress fields corresponds to the completion percentage in the msg field. The progress specifies the following information:

currentOp.progress.done¶: Reports the number completed.

currentOp.progress.total¶: Reports the total number.

currentOp.killPending¶: Returns true if the operation is currently flagged for termination. When the operation encounters its next safe termination point, the operation will terminate.

currentOp.numYields¶

numYields is a counter that reports the number of times the operation has yielded to allow other operations to complete.

Typically, operations yield when they need access to data that MongoDB has not yet fully read into memory. This allows other operations that have data in memory to complete quickly while MongoDB reads in data for the yielding operation.

currentOp.fsyncLock¶

Specifies if database is currently locked for fsync write/snapshot.

Only appears if locked; i.e. if fsyncLock is true.

currentOp.info¶: Information regarding how to unlock database from db.fsyncLock(). Only appears if fsyncLock is true.

currentOp.lockStats¶

For each lock type and mode (see currentOp.locks for descriptions of lock types and modes), returns the following information:

currentOp.lockStats.acquireCount¶: Number of times the operation acquired the lock in the specified mode.

currentOp.lockStats.acquireWaitCount¶: Number of times the operation had to wait for the acquireCount lock acquisitions because the locks were held in a conflicting mode. acquireWaitCount is less than or equal to acquireCount.

currentOp.lockStats.timeAcquiringMicros¶

Cumulative time in microseconds that the operation had to wait to acquire the locks.

timeAcquiringMicros divided by acquireWaitCount gives an approximate average wait time for the particular lock mode.

currentOp.lockStats.deadlockCount¶: Number of times the operation encountered deadlocks while waiting for lock acquisitions.

← createIndexes drop →