OPTIONS

db.currentOp()

Definition

db.currentOp()

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

db.currentOp() method has the following form:

db.currentOp(<operations>)

The db.currentOp() method 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 operations that match the conditions. See Behavior for details.

Behavior

If you pass in true to db.currentOp(), the method returns information on all operations, including operations on idle connections and system operations.

db.currentOp(true)

Passing in true is equivalent to passing in a query document of { '$all': true }.

If you pass a query document to db.currentOp(), the output returns information only for the current operations that match the query. You can query on the Output Fields. See Examples.

You can also specify { '$all': true } query document to return information on all in-progress operations, including operations on idle connections and system operations. If the query document includes '$all': true as well as other query conditions, only the '$all': true applies.

Access Control

On systems running with authorization, a user must have access that includes the inprog action. For example, see Create a Role to Manage Current Operations.

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" ] } },
        { "query.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:

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

Output Example

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

{
  "inprog": [
       {
         "desc" : <string>,
         "threadId" : <string>,
         "connectionId" : <number>,
         "opid" : <number>,
         "active" : <boolean>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "query" : <document>,
         "insert" : <document>,
         "planSummary": <string>,
         "client" : <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>
}

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.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"
  • "getmore"
  • "remove"
  • "killcursors"

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

Changed in version 3.0: Write operations that use the insert, update, and delete commands respectively display "insert", "update", and "delete" for op. Previous versions include these write 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". query does not appear for op of "insert", and the query document can be empty for op types such as "getmore".

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

For other commands categorized under "query", query document contains the specifics of the command.

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.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:

  • 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:

  • 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.