db.currentOp()¶

On this page

Definition
Behavior
Access Control
Examples
Output Example
Output Fields

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.

copy

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 you specify in the query document other conditions as well as '$all': true, 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:

copy

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

Active Operations with no Yields¶

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

copy

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:

copy

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

Active Indexing Operations¶

The following example returns information on index creation operations:

copy

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

Output Example¶

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

copy

{
  "inprog": [
       {
         "opid" : <number>,
         "active" : <boolean>,
         "secs_running" : <NumberLong()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "query" : <document>,
         "insert" : <document>,
         "planSummary": <string>,
         "client" : <string>,
         "desc" : <string>,
         "threadId" : <string>,
         "connectionId" : <number>,
         "locks" : {
             "^" : <string>,
             "^local" : <string>,
             "^<database>" : <string>
         },
         "waitingForLock" : <boolean>,
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "lockStats" : {
             "timeLockedMicros" : {
                 "R" : <NumberLong()>,
                 "W" : <NumberLong()>,
                 "r" : <NumberLong()>,
                 "w" : <NumberLong()>
             },
             "timeAcquiringMicros" : {
                 "R" : <NumberLong()>,
                 "W" : <NumberLong()>,
                 "r" : <NumberLong()>,
                 "w" : <NumberLong()>
             }
         }
       },
       ...
   ]
}

Output Fields¶

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 queued and waiting for a lock to run. active may be true even if the operation has yielded to another operation.

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"

The "query" type includes operations that use the insert, update, and delete commands. Write operations that do not use the aforementioned write commands will show with the appropriate "insert", "update", or "remove" value.

currentOp.ns¶: The namespace the operation targets. A namespace consists of the database name and the collection name concatenated with a dot (.); i.e., "<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.

Write operations that use the insert, update, and delete commands have op value of "query" and the corresponding query contains information on these operations.

Changed in version 2.6.11: 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.

copy

"query" : {
            "update" : "grades",
            "updates" : [
               {
                  "q" : {
                     "x" : {
                        "$gt" : 70
                     }
                  },
                  "u" : {
                     "$set" : {
                        "y" : 1
                     }
                  },
                  "multi" : true,
                  "upsert" : false
               }
            ],
            "ordered" : true
         }

The document can be empty for op types such as "getmore".

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.

For some commands, including findAndModify and db.eval(), the client will be 0.0.0.0:0, rather than an actual client.

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

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

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

currentOp.locks¶

New in version 2.2.

The locks document reports by databases the types of locks the operation currently holds. The possible lock types are:

R represents the global read lock,
W represents the global write lock,
r represents the database specific read lock, and
w represents the database specific write lock.

currentOp.locks.^¶: ^ reports on the use of the global lock for the mongod instance. All operations must hold the global lock for some phases of operation.

currentOp.locks.^local¶: ^local reports on the lock for the local database. MongoDB uses the local database for a number of operations, but the most frequent use of the local database is for the oplog used in replication.

currentOp.locks.^<database>¶: locks.^<database> reports on the lock state for the database that this operation targets.

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.lockStats¶

New in version 2.2.

The lockStats document reflects the amount of time the operation has spent both acquiring and holding locks. lockStats reports data on a per-lock type, with the following possible lock types:

R represents the global read lock,
W represents the global write lock,
r represents the database specific read lock, and
w represents the database specific write lock.

currentOp.timeLockedMicros¶

The timeLockedMicros document reports the amount of time the operation has spent holding a specific lock.

For operations that require more than one lock, like those that lock the local database to update the oplog, then the values in this document can be longer than this value may be longer than the total length of the operation (i.e. secs_running.)

currentOp.timeLockedMicros.R¶: Reports the amount of time in microseconds the operation has held the global read lock.

currentOp.timeLockedMicros.W¶: Reports the amount of time in microseconds the operation has held the global write lock.

currentOp.timeLockedMicros.r¶: Reports the amount of time in microseconds the operation has held the database specific read lock.

currentOp.timeLockedMicros.w¶: Reports the amount of time in microseconds the operation has held the database specific write lock.

currentOp.timeAcquiringMicros¶

The timeAcquiringMicros document reports the amount of time the operation has spent waiting to acquire a specific lock.

currentOp.timeAcquiringMicros.R¶: Reports the mount of time in microseconds the operation has waited for the global read lock.

currentOp.timeAcquiringMicros.W¶: Reports the mount of time in microseconds the operation has waited for the global write lock.

currentOp.timeAcquiringMicros.r¶: Reports the mount of time in microseconds the operation has waited for the database specific read lock.

currentOp.timeAcquiringMicros.w¶: Reports the mount of time in microseconds the operation has waited for the database specific write lock.

← db.createCollection() db.dropDatabase() →