Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

397 lines (288 sloc) 12.326 kb
==============
db.currentOp()
==============
.. default-domain:: mongodb
Definition
----------
.. method:: db.currentOp()
Returns a :term:`document` that contains information on in-progress
operations for the database instance.
:method:`db.currentOp()` method has the following form:
.. code-block:: javascript
db.currentOp(<operations>)
The :method:`db.currentOp()` method can take the following *optional*
argument:
.. include:: /includes/apiargs/method-db.currentOp-param.rst
.. _currentOp-behavior:
Behavior
--------
If you pass in ``true`` to :method:`db.currentOp()`, the method returns
information on all operations, including operations on idle
connections and system operations.
.. code-block:: javascript
db.currentOp(true)
Passing in ``true`` is equivalent to passing in a query document of ``{
'$all': true }``.
If you pass a query document to :method:`db.currentOp()`, the output
returns information only for the current operations that match the
query. You can query on the :ref:`currentOp-output-fields`. See
:ref:`currentOp-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 :setting:`~security.authorization`, a user must
have access that includes the :authaction:`inprog` action. For example,
see :ref:`create-role-to-manage-ops`.
.. _currentOp-examples:
Examples
--------
The following examples use the :method:`db.currentOp()` method with
various query documents to filter the output.
.. include:: /includes/example-filter-current-op.rst
Output Example
--------------
The following is an prototype of :method:`db.currentOp()` output.
.. code-block:: javascript
{
"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>
}
.. _currentOp-output-fields:
Output Fields
-------------
.. data:: currentOp.desc
A description of the client. This string includes the
:data:`~currentOp.connectionId`.
.. data:: currentOp.threadId
An identifier for the thread that handles the operation and its
connection.
.. data:: currentOp.connectionId
An identifier for the connection where the operation originated.
.. data:: currentOp.opid
The identifier for the operation. You can pass this value to
:method:`db.killOp()` in the :program:`mongo` shell to terminate the
operation.
.. include:: /includes/warning-terminating-operations.rst
.. data:: 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.
.. versionchanged:: 3.0
For some inactive background threads, such as an inactive
``signalProcessingThread``, MongoDB suppresses various empty
fields.
.. data:: 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
:data:`~currentOp.active` is ``true``.
.. data:: currentOp.microsecs_running
.. versionadded:: 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
:data:`~currentOp.active` is ``true``.
.. data:: 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 :dbcommand:`createIndexes` command and the
:dbcommand:`findandmodify` command.
.. versionchanged:: 3.0
Write operations that use the :dbcommand:`insert`,
:dbcommand:`update`, and :dbcommand:`delete` commands
respectively display ``"insert"``, ``"update"``, and ``"delete"``
for :data:`~currentOp.op`. Previous versions include these write
commands under ``"query"`` operations.
.. data:: currentOp.ns
The :term:`namespace` the operation targets. A namespace consists of
the :term:`database` name and the :term:`collection` name
concatenated with a dot (``.``); that is,
``"<database>.<collection>"``.
.. data:: currentOp.insert
Contains the document to be inserted for operations with
:data:`~currentOp.op` value of ``"insert"``. Only appears for
operations with :data:`~currentOp.op` value ``"insert"``.
Insert operations such as :method:`db.collection.insert()` that use
the :dbcommand:`insert` command will have :data:`~currentOp.op` value
of ``"query"``.
.. data:: currentOp.query
A document containing information on operations whose
:data:`~currentOp.op` value is *not* ``"insert"``.
:data:`~currentOp.query` does not appear for :data:`~currentOp.op`
of ``"insert"``, and the :data:`~currentOp.query` document can be
empty for :data:`~currentOp.op` types such as ``"getmore"``.
For :data:`"update" <currentOp.op>` or :data:`"remove"
<currentOp.op>` operations or for read operations categorized under
:data:`"query" <currentOp.op>`, the :data:`~currentOp.query`
document contains the query predicate for the operations.
For other commands categorized under :data:`"query" <currentOp.op>`,
:data:`~currentOp.query` document contains the specifics of the
command.
.. versionchanged:: 3.0
Previous versions categorized operations that used write
commands under :data:`~currentOp.op` of ``"query"`` and returned
the write command information (e.g. query predicate, update
statement, and update options) in :data:`~currentOp.query`
document.
.. data:: currentOp.planSummary
A string that contains the query plan to help debug slow queries.
.. data:: 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.
.. data:: currentOp.locks
.. versionchanged:: 3.0
The :data:`~currentOp.locks` document reports the type and mode of
locks the operation currently holds. The possible lock types are as
follows:
.. include:: /includes/fact-lock-types.rst
The possible modes are as follows:
.. include:: /includes/fact-lock-modes.rst
.. data:: currentOp.waitingForLock
Returns a boolean value. :data:`~currentOp.waitingForLock` is ``true`` if the
operation is waiting for a lock and ``false`` if the operation has
the required lock.
.. data:: currentOp.msg
The :data:`~currentOp.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.
.. data:: currentOp.progress
Reports on the progress of mapReduce or indexing operations. The
:data:`~currentOp.progress` fields corresponds to the completion percentage in
the :data:`~currentOp.msg` field. The :data:`~currentOp.progress` specifies the following
information:
.. data:: currentOp.progress.done
Reports the number completed.
.. data:: currentOp.progress.total
Reports the total number.
.. data:: 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.
.. data:: currentOp.numYields
:data:`~currentOp.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.
.. data:: currentOp.fsyncLock
Specifies if database is currently locked for :method:`fsync
write/snapshot <db.fsyncLock()>`.
Only appears if locked; i.e. if :data:`~currentOp.fsyncLock` is
``true``.
.. data:: currentOp.info
Information regarding how to unlock database from
:method:`db.fsyncLock()`. Only appears if
:data:`~currentOp.fsyncLock` is ``true``.
.. data:: currentOp.lockStats
For each lock type and mode (see :data:`currentOp.locks` for
descriptions of lock types and modes), returns the following
information:
.. COMMENT
these definitions are for per operations and not for server,
as such, they differ from those in serverStatus.txt
.. data:: currentOp.lockStats.acquireCount
Number of times the operation acquired the lock in the specified
mode.
.. data:: currentOp.lockStats.acquireWaitCount
Number of times the operation had to wait for the
:data:`~currentOp.lockStats.acquireCount` lock acquisitions
because the locks were held in a conflicting mode.
:data:`~currentOp.lockStats.acquireWaitCount` is less than or
equal to :data:`~currentOp.lockStats.acquireCount`.
.. data:: currentOp.lockStats.timeAcquiringMicros
Cumulative time in microseconds that the operation had to wait to
acquire the locks.
:data:`~currentOp.lockStats.timeAcquiringMicros` divided by
:data:`~currentOp.lockStats.acquireWaitCount` gives an
approximate average wait time for the particular lock mode.
.. data:: currentOp.lockStats.deadlockCount
Number of times the operation encountered deadlocks while waiting
for lock acquisitions.
Jump to Line
Something went wrong with that request. Please try again.