serverStatus.txt

============
serverStatus
============

.. default-domain:: mongodb

.. facet::
   :name: programming_language
   :values: shell

.. facet::
   :name: genre
   :values: reference

.. contents:: On this page
   :local:
   :backlinks: none
   :depth: 2
   :class: singlecol


.. |mongod-only| replace:: *Available on mongod only.*

.. |mongos-only| replace:: *Available on mongos only.*

.. |both| replace:: *Available on both mongod and mongos.*

Definition
----------

.. dbcommand:: serverStatus

   The :dbcommand:`serverStatus` command returns a document that
   provides an overview of the database's state. Monitoring
   applications can run this command at a regular interval to
   collect statistics about the instance.

Compatibility
-------------

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

.. include:: /includes/fact-environments-atlas-only.rst

.. include:: /includes/fact-environments-atlas-support-all.rst

.. include:: /includes/fact-environments-onprem-only.rst

Syntax
------

The command has the following syntax:

.. code-block:: javascript

   db.runCommand( 
      { 
        serverStatus: 1 
      } 
   )

The value (i.e. ``1`` above) does not affect the operation of the
command. The ``db.serverStatus()`` command returns a large amount of
data. To return a specific object or field from the output append the
object or field name to the command.

For example:

.. code-block:: javascript

   db.runCommand({ serverStatus: 1}).metrics
   db.runCommand({ serverStatus: 1}).metrics.commands
   db.runCommand({ serverStatus: 1}).metrics.commands.update

:binary:`~bin.mongosh` provides the :method:`db.serverStatus()`
wrapper for the :dbcommand:`serverStatus` command.

.. seealso::

   Much of the output of :dbcommand:`serverStatus` is also displayed
   dynamically by :binary:`~bin.mongostat`. See the
   :binary:`~bin.mongostat` command for more information.

Behavior
--------

.. include:: /includes/extracts/serverStatus-command-projection.rst

For example, the following operation excludes the ``repl``,
``metrics`` and ``locks`` information in the output.

.. code-block:: javascript

   db.runCommand( { serverStatus: 1, repl: 0, metrics: 0, locks: 0 } )


For example, the following operation excludes the embedded ``histogram`` 
field in the output.

.. code-block:: javascript

   db.runCommand( { serverStatus: 1, metrics: { query: { multiPlanner: { histograms: false } } } } )

The following example includes
all :ref:`server-status-repl` information in the output:

.. code-block:: javascript

   db.runCommand( { serverStatus: 1,  repl: 1 } )

Initialization
~~~~~~~~~~~~~~

The statistics reported by :dbcommand:`serverStatus` are reset when the
:binary:`~bin.mongod` server is restarted.

This command will always return a value, even on a fresh database. The
related command :method:`db.serverStatus()` does not always return a
value unless a counter has started to increment for a particular
metric.

After you run an update query, ``db.serverStatus()`` and
``db.runCommand({ serverStatus: 1})`` both return the same values.

.. code-block:: javascript
   :copyable: false

   {
      arrayFilters : Long("0"),
      failed : Long("0"),
      pipeline : Long("0"),
      total : Long("1")
   }

Include ``mirroredReads``
~~~~~~~~~~~~~~~~~~~~~~~~~

By default, the :serverstatus:`mirroredReads` information is not included in 
the output. To return :serverstatus:`mirroredReads` information, you must 
explicitly specify the inclusion:

.. code-block:: javascript

   db.runCommand( { serverStatus: 1, mirroredReads: 1 } )

.. _server-status-output:

Output
------

.. note::

   The output fields vary depending on the version of MongoDB,
   underlying operating system platform, the storage engine, and the
   kind of node, including :binary:`~bin.mongos`, :binary:`~bin.mongod` or
   :term:`replica set` member.

   For the :dbcommand:`serverStatus` output specific to the version of
   your MongoDB, refer to the appropriate version of the MongoDB Manual.

.. _server-status-asserts:

asserts
~~~~~~~

.. code-block:: javascript

   asserts : {
      regular : <num>,
      warning : <num>,
      msg : <num>,
      user : <num>,
      rollovers : <num>
   },

.. serverstatus:: asserts

   A document that reports on the number of assertions raised since the
   MongoDB process started. Assertions are internal checks for errors that 
   occur while the database is operating and can help diagnose issues with the 
   MongoDB server. Non-zero asserts values indicate assertion errors, which are 
   uncommon and not an immediate cause for concern. Errors that generate asserts 
   can be recorded in the log file or returned directly to a client application 
   for more information.

.. serverstatus:: asserts.regular

   The number of regular assertions raised since the MongoDB process
   started. Examine the MongoDB log for more information.

.. serverstatus:: asserts.warning

   This field always returns zero ``0``.

.. serverstatus:: asserts.msg

   The number of message assertions raised since the MongoDB process
   started. Examine the log file for more information about these
   messages.

.. serverstatus:: asserts.user

   The number of "user asserts" that have occurred since the last time
   the MongoDB process started. These are errors that user may
   generate, such as out of disk space or duplicate key. You can
   prevent these assertions by fixing a problem with your application
   or deployment. Examine the log file for more information about these
   messages.

.. serverstatus:: asserts.rollovers

   The number of times that the assert counters have rolled over
   since the last time the MongoDB process started. The counters will
   roll over to zero after 2\ :superscript:`30` assertions. Use this
   value to provide context to the other values in the
   :serverstatus:`asserts` data structure.

.. _server-status-bucketcatalog:

bucketCatalog
~~~~~~~~~~~~~

.. code-block:: javascript

  bucketCatalog : {
      numBuckets : <num>,
      numOpenBuckets : <num>,
      numIdleBuckets : <num>,
      memoryUsage : <num>
   }

.. versionadded:: 5.0

A document that reports metrics related to the internal storage of
time series collections.

The ``bucketCatalog`` returns the following metrics:

.. list-table::
  :header-rows: 1
  :widths: 30 70

  * - Metric
    - Description

  * - ``numBuckets``

    - The number of buckets that store time series data internally.

  * - ``numOpenBuckets``

    - The number of active, uncommitted writes to buckets.

  * - ``numIdleBuckets``

    - The number of buckets that are not full and can store incoming
      time series data.

  * - ``memoryUsage``

    - The number of bytes used by internal bucketing data structures.

.. _server-status-catalogStats:

catalogStats
~~~~~~~~~~~~

.. versionadded:: 5.1

.. code-block:: javascript

   catalogStats: {
      collections: <num>,
      capped: <num>, 
      views: <num>, 
      timeseries: <num>,
      internalCollections: <num>, 
      internalViews: <num>
   }

.. serverstatus:: catalogStats

   A document that reports statistics on collection usage via collection counts.

.. serverstatus:: catalogStats.collections

   The total number of user collections (not including system
   collections).

.. serverstatus:: catalogStats.capped

   The total number of capped user collections. 

.. serverstatus:: catalogStats.views

   The total number of user views.

.. serverstatus:: catalogStats.timeseries

   The total number of time series collections. 

.. serverstatus:: catalogStats.internalCollections

   The total number of system collections (collections on the
   ``config``, ``admin``, or ``local`` databases).

.. serverstatus:: catalogStats.internalViews

   The total number of views of system collections (collections on the
   ``config``, ``admin``, or ``local`` databases).

.. _server-status-changeStreamPreImages:

changeStreamPreImages
~~~~~~~~~~~~~~~~~~~~~

.. versionadded:: 5.0

.. code-block:: javascript

   changeStreamPreImages : {
      purgingJob : {
         totalPass : <num>,
         docsDeleted : <num>,
         bytesDeleted : <num>,
         scannedCollections : <num>,
         scannedInternalCollections : <num>,
         maxStartWallTimeMillis : <num>,
         timeElapsedMillis : <num>,
      },
      expireAfterSeconds : <num>
   }

A document that reports metrics related to 
:ref:`change stream pre-images <change-stream-pre-post-images>`.

.. serverstatus:: changeStreamPreImages.purgingJob

   .. versionadded:: 7.1

   A document that reports metrics related to the purging jobs for
   change stream pre-images. Purging jobs are background processes 
   that the system uses to remove pre-images asynchronously.

   The ``changeStreamPreImages.purgingJob`` field returns the 
   following metrics:

   .. list-table::
      :header-rows: 1
      :widths: 30 70

      * - Metric
        - Description

      * - ``totalPass``
        - Total number of deletion passes completed by the purging job. 

      * - ``docsDeleted``
        - Cumulative number of pre-image documents deleted by the purging job.

      * - ``bytesDeleted``
        - Cumulative size in bytes of all deleted documents from all 
          pre-image collections by the purging job. 

      * - ``scannedCollections``
        - Cumulative number of pre-image collections scanned by the purging job. 
            
          .. note:: 
               
             In single-tenant environments, this number is the same as 
             ``totalPass`` since each tenant has one pre-image collection.

      * - ``scannedInternalCollections``
        - Cumulative number of internal pre-image collections scanned by the 
          purging job. Internal collections are the collections within the pre-image
          collections stored in ``config.system.preimages``.
   
      * - ``maxStartWallTimeMillis``
        - Maximum wall time in milliseconds from the first document of each 
          pre-image collection. 

      * - ``timeElapsedMillis``
        - Cumulative time in milliseconds of all deletion passes by the 
          purging job.

.. serverstatus:: changeStreamPreImages.expireAfterSeconds

   .. versionadded:: 7.1

   Amount of time in seconds that MongoDB retains pre-images. If
   :parameter:`~changeStreamOptions.preAndPostImages.expireAfterSeconds`
   is not defined, this metric does not appear in the ``serverStatus``
   output.

.. _server-status-connections:

connections
~~~~~~~~~~~

.. code-block:: javascript

   connections : {
      current : <num>,
      available : <num>,
      totalCreated : <num>,
      rejected : <num>,  // Added in MongoDB 6.3
      active : <num>,
      threaded : <num>,
      exhaustIsMaster : <num>,
      exhaustHello : <num>,
      awaitingTopologyChanges : <num>,
      loadBalanced : <num> 
   },

.. serverstatus:: connections

   A document that reports on the status of the connections. Use these
   values to assess the current load and capacity requirements of the
   server.

.. serverstatus:: connections.current

   The number of incoming connections from clients to the database
   server. This number includes the current shell session. Consider
   the value of :serverstatus:`connections.available` to add more
   context to this datum.

   The value will include all incoming connections including any shell
   connections or connections from other servers, such as
   :term:`replica set` members or :binary:`~bin.mongos` instances.

.. serverstatus:: connections.available

   The number of unused incoming connections available. Consider this
   value in combination with the value of
   :serverstatus:`connections.current` to understand the connection
   load on the database, and the :doc:`/reference/ulimit` document for
   more information about system thresholds on available connections.

.. serverstatus:: connections.totalCreated

   Count of **all** incoming connections created to the server. This
   number includes connections that have since closed.

.. serverstatus:: connections.rejected

   .. versionadded:: 6.3

   The number of incoming connections the server rejected because the
   server doesn't have the capacity to accept additional connections or
   the :setting:`net.maxIncomingConnections` setting is reached.

.. serverstatus:: connections.active

   The number of active client connections to the server. Active client
   connections refers to client connections that currently have
   operations in progress.

.. serverstatus:: connections.threaded

   The number of incoming connections from clients that are assigned
   to threads that service client requests.

   .. versionadded:: 5.0

.. serverstatus:: connections.exhaustIsMaster

   The number of connections whose last request was an
   ``isMaster`` request with :ref:`exhaustAllowed <wire-msg-flags>`.

   .. note::

      If you are running MongoDB 5.0 or later, do not use the
      ``isMaster`` command. Instead, use :dbcommand:`hello`.

.. serverstatus:: connections.exhaustHello

   The number of connections whose last request was a :dbcommand:`hello`
   request with :ref:`exhaustAllowed <wire-msg-flags>`.

   .. versionadded:: 5.0

.. serverstatus:: connections.awaitingTopologyChanges

   The number of clients currently waiting in a :dbcommand:`hello` or
   ``isMaster`` request for a topology change.

   .. note::

      If you are running MongoDB 5.0 or later, do not use the
      ``isMaster`` command. Instead, use :dbcommand:`hello`.

.. serverstatus:: connections.loadBalanced

   .. versionadded:: 5.3

   The current number of incoming connections received through the 
   load balancer.

.. _server-status-defaultRWConcern:

defaultRWConcern
~~~~~~~~~~~~~~~~

The ``defaultRWConcern`` section provides information on the local copy
of the global default read or write concern settings. The data may be
stale or out of date. See :dbcommand:`getDefaultRWConcern` for more
information.

.. code-block:: javascript

   defaultRWConcern : {
     defaultReadConcern : {
       level : <string>
     },
     defaultWriteConcern : {
       w : <string> | <int>,
       wtimeout : <int>,
       j : <bool>
     },
     defaultWriteConcernSource: <string>,
     defaultReadConcernSource: <string>,
     updateOpTime : Timestamp,
     updateWallClockTime : Date,
     localUpdateWallClockTime : Date
   }

.. serverstatus:: defaultRWConcern

   The last known global default read or write concern settings.

.. serverstatus:: defaultRWConcern.defaultReadConcern

   The last known global default :ref:`read concern <read-concern>`
   setting.

   If :dbcommand:`serverStatus` does not return this field, the global
   default read concern has either not been set *or* has not yet
   propagated to the instance.

.. serverstatus:: defaultRWConcern.defaultReadConcern.level

   The last known global default :ref:`read concern level
   <read-concern-levels>` setting.

   If :dbcommand:`serverStatus` does not return this field, the global
   default for this setting has either not been set *or* has not yet
   propagated to the instance.

.. serverstatus:: defaultRWConcern.defaultWriteConcern

   The last known global default :ref:`write concern <write-concern>`
   setting.

   If :dbcommand:`serverStatus` does not return this field, the global
   default write concern has either not been set *or* has not yet
   propagated to the instance. 

.. serverstatus:: defaultRWConcern.defaultWriteConcern.w

   The last known global default :ref:`w <wc-w>` setting. 

   If :dbcommand:`serverStatus` does not return this field, the global
   default for this setting has either not been set *or* has not yet
   propagated to the instance.

.. serverstatus:: defaultRWConcern.defaultWriteConcern.wtimeout

   The last known global default :ref:`wtimeout <wc-wtimeout>` setting. 

   If :dbcommand:`serverStatus` does not return this field, the global
   default for this setting has either not been set *or* has not yet
   propagated to the instance.

.. serverstatus:: defaultRWConcern.defaultWriteConcernSource

   .. include:: /includes/fact-defaultWriteConcernSource-possible-values.rst

   .. versionadded:: 5.0

.. serverstatus:: defaultRWConcern.defaultReadConcernSource

   .. include:: /includes/fact-defaultReadConcernSource-possible-values.rst

   .. versionadded:: 5.0

.. serverstatus:: defaultRWConcern.updateOpTime

   The timestamp when the instance last updated its copy of any global
   read or write concern settings. If the
   :serverstatus:`defaultRWConcern.defaultReadConcern` and
   :serverstatus:`defaultRWConcern.defaultWriteConcern` fields are
   absent, this field indicates the timestamp when the defaults were
   last unset.

.. serverstatus:: defaultRWConcern.updateWallClockTime

   The wall clock time when the instance last updated its copy of any
   global read or write concern settings. If the
   :serverstatus:`defaultRWConcern.defaultReadConcern` and
   :serverstatus:`defaultRWConcern.defaultWriteConcern` fields are
   absent, this field indicates the time when the defaults were last
   unset.

.. serverstatus:: defaultRWConcern.localUpdateWallClockTime

   The local system wall clock time when the instance last updated its
   copy of any global read or write concern setting. If this field is
   the *only* field under :serverstatus:`defaultRWConcern`, the instance
   has never had knowledge of a global default read or write concern
   setting.

.. _server-status-electionMetrics:

electionMetrics
~~~~~~~~~~~~~~~

The ``electionMetrics`` section provides information on elections
called by this :binary:`~bin.mongod` instance in a bid to become the
primary:

.. code-block:: javascript

   electionMetrics : {
      stepUpCmd : {
         called : Long("<num>"),
         successful : Long("<num>")
      },
      priorityTakeover : {
         called : Long("<num>"),
         successful : Long("<num>")
      },
      catchUpTakeover : {
         called : Long("<num>"),
         successful : Long("<num>")
      },
      electionTimeout : {
         called : Long("<num>"),
         successful : Long("<num>")
      },
      freezeTimeout : {
         called : Long("<num>"),
         successful : Long("<num>")
      },
      numStepDownsCausedByHigherTerm : Long("<num>"),
      numCatchUps : Long("<num>"),
      numCatchUpsSucceeded : Long("<num>"),
      numCatchUpsAlreadyCaughtUp : Long("<num>"),
      numCatchUpsSkipped : Long("<num>"),
      numCatchUpsTimedOut : Long("<num>"),
      numCatchUpsFailedWithError : Long("<num>"),
      numCatchUpsFailedWithNewTerm : Long("<num>"),
      numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd : Long("<num>"),
      averageCatchUpOps : <double>
   }

.. serverstatus:: electionMetrics.stepUpCmd

   Metrics on elections that were called by the :binary:`~bin.mongod`
   instance as part of an election handoff when the primary stepped down.

   The :serverstatus:`~electionMetrics.stepUpCmd` includes both the number of elections
   called and the number of elections that succeeded.

.. serverstatus:: electionMetrics.priorityTakeover

   Metrics on elections that were called by the :binary:`~bin.mongod`
   instance because its :rsconf:`~members[n].priority` is higher
   than the primary's.

   The :serverstatus:`electionMetrics.priorityTakeover` includes both the number of
   elections called and the number of elections that succeeded.

.. serverstatus:: electionMetrics.catchUpTakeover

   Metrics on elections called by the :binary:`~bin.mongod` instance
   because it is more current than the primary.

   The :serverstatus:`~electionMetrics.catchUpTakeover` includes both the number of
   elections called and the number of elections that succeeded.

   .. seealso::

      :rsconf:`settings.catchUpTakeoverDelayMillis`

.. serverstatus:: electionMetrics.electionTimeout

   Metrics on elections called by the :binary:`~bin.mongod` instance
   because it has not been able to reach the primary within
   :rsconf:`settings.electionTimeoutMillis`.

   The :serverstatus:`~electionMetrics.electionTimeout` includes both the number of
   elections called and the number of elections that succeeded.

   .. seealso:: 
      
      :rsconf:`settings.electionTimeoutMillis`

.. serverstatus:: electionMetrics.freezeTimeout

   Metrics on elections called by the :binary:`~bin.mongod` instance
   after its :dbcommand:`freeze period <replSetFreeze>` (during which the
   member cannot seek an election) has expired.

   The :serverstatus:`electionMetrics.freezeTimeout` includes both the number of
   elections called and the number of elections that succeeded.

.. serverstatus:: electionMetrics.numStepDownsCausedByHigherTerm

   Number of times the :binary:`~bin.mongod` instance stepped down
   because it saw a higher term (specifically, other member(s)
   participated in additional elections).

.. serverstatus:: electionMetrics.numCatchUps

   Number of elections where the :binary:`~bin.mongod` instance as the
   newly-elected primary had to catch up to the highest known oplog
   entry.

.. serverstatus:: electionMetrics.numCatchUpsSucceeded

   Number of times the :binary:`~bin.mongod` instance as the
   newly-elected primary successfully caught up to the highest known
   oplog entry.

.. serverstatus:: electionMetrics.numCatchUpsAlreadyCaughtUp

   Number of times the :binary:`~bin.mongod` instance as the
   newly-elected primary concluded its catchup process because it was
   already caught up when elected.

.. serverstatus:: electionMetrics.numCatchUpsSkipped

   Number of times the :binary:`~bin.mongod` instance as the
   newly-elected primary skipped the catchup process.

.. serverstatus:: electionMetrics.numCatchUpsTimedOut

   Number of times the :binary:`~bin.mongod` instance as the
   newly-elected primary concluded its catchup process because of the
   :rsconf:`settings.catchUpTimeoutMillis` limit.

.. serverstatus:: electionMetrics.numCatchUpsFailedWithError

   Number of times the newly-elected primary's catchup process failed
   with an error.

.. serverstatus:: electionMetrics.numCatchUpsFailedWithNewTerm

   Number of times the newly-elected primary's catchup process concluded
   because another member(s) had a higher term (specifically, other
   member(s) participated in additional elections).

.. serverstatus:: electionMetrics.numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd

   Number of times the newly-elected primary's catchup process
   concluded because the :binary:`~bin.mongod` received the
   :dbcommand:`replSetAbortPrimaryCatchUp` command.

.. serverstatus:: electionMetrics.averageCatchUpOps

   Average number of operations applied during the newly-elected
   primary's catchup processes.

.. _server-status-extra-info:
.. _server-status-extra_info:
.. _server-status-extrainfo:

extra_info
~~~~~~~~~~

.. code-block:: javascript

   extra_info : {
      note : 'fields vary by platform',
      page_faults : <num>
   },

.. serverstatus:: extra_info

   A document that provides additional information about the underlying
   system.

.. serverstatus:: extra_info.note

   A string with the text ``'fields vary by platform'``

.. serverstatus:: extra_info.page_faults

   The total number of page faults. The
   :serverstatus:`extra_info.page_faults` counter may increase
   dramatically during moments of poor performance and may correlate
   with limited memory environments and larger data sets. Limited and
   sporadic page faults do not necessarily indicate an issue.

   Windows differentiates "hard" page faults involving disk I/O from
   "soft" page faults that only require moving pages in memory. MongoDB
   counts both hard and soft page faults in this statistic.

.. _server-status-flowControl:

flowControl
~~~~~~~~~~~

.. code-block:: javascript

   flowControl : {
      enabled : <boolean>,
      targetRateLimit : <int>,
      timeAcquiringMicros : Long("<num>"),
      locksPerKiloOp : <double>,  
      sustainerRate : <int>,
      isLagged : <boolean>,
      isLaggedCount : <int>,
      isLaggedTimeMicros : Long("<num>")
   },

.. serverstatus:: flowControl

   A document that returns statistics on the :ref:`flow-control`. With
   flow control enabled, as the :data:`majority commit
   <replSetGetStatus.optimes.lastCommittedOpTime>` point lag grows
   close to the :parameter:`flowControlTargetLagSeconds`, writes on the
   primary must obtain tickets before taking locks. As such, the
   metrics returned are meaningful when run on the primary.

.. serverstatus:: flowControl.enabled

   A boolean that indicates whether :ref:`flow-control` is
   enabled (``true``) or disabled (``false``).
   
   See also :parameter:`enableFlowControl`.

.. serverstatus:: flowControl.targetRateLimit

   When run on the primary, the maximum number of tickets that can be
   acquired per second.

   When run on a secondary, the returned number is a placeholder.
   
.. serverstatus:: flowControl.timeAcquiringMicros

   When run on the primary, the total time write operations have waited
   to acquire a ticket.

   When run on a secondary, the returned number is a placeholder.

.. serverstatus:: flowControl.locksPerKiloOp

   When run on the primary, an approximation of the number of locks
   taken per 1000 operations.

   When run on a secondary, the returned number is a placeholder.

.. serverstatus:: flowControl.sustainerRate

   When run on the primary, an approximation of operations applied per
   second by the secondary that is sustaining the commit point.

   When run on a secondary, the returned number is a placeholder.

.. serverstatus:: flowControl.isLagged

   When run on the primary, a boolean that indicates whether flow
   control has engaged. Flow control engages when the majority
   committed lag is greater than some percentage of the configured
   :parameter:`flowControlTargetLagSeconds`.

   Replication lag can occur without engaging flow control.
   An unresponsive :term:`secondary` might lag without the replica set
   receiving sufficient load to engage flow control, leaving 
   the :serverstatus:`flowControl.isLagged` value at ``false``.

   For additional information, see :ref:`Flow Control <flow-control>`.

.. serverstatus:: flowControl.isLaggedCount

   When run on a primary, the number of times flow control has engaged
   since the last restart. Flow control engages when the majority
   committed lag is greater than some percentage of the
   :parameter:`flowControlTargetLagSeconds`.

   When run on a secondary, the returned number is a placeholder.

.. serverstatus:: flowControl.isLaggedTimeMicros

   When run on the primary, the amount of time flow control has spent
   being engaged since the last restart. Flow control engages when the
   majority committed lag is greater than some percentage of the
   :parameter:`flowControlTargetLagSeconds`.

   When run on a secondary, the returned number is a placeholder.

.. _globalLock:
.. _globallock:
.. _global-lock:
.. _server-status-globallock:
.. _server-status-global-lock:

globalLock
~~~~~~~~~~

.. code-block:: javascript

   globalLock : {
      totalTime : Long("<num>"),
      currentQueue : {
         total : <num>,
         readers : <num>,
         writers : <num>
      },
      activeClients : {
         total : <num>,
         readers : <num>,
         writers : <num>
      }
   },

.. serverstatus:: globalLock

   A document that reports on the database's lock state.

   Generally, the :ref:`locks <locks>` document provides more detailed
   data on lock uses.

.. serverstatus:: globalLock.totalTime

   The time, in microseconds, since the database last started and
   created the :serverstatus:`globalLock`. This is approximately
   equivalent to the total server uptime.

.. serverstatus:: globalLock.currentQueue

   A document that provides information concerning the number of
   operations queued because of a lock.

.. serverstatus:: globalLock.currentQueue.total

   The total number of operations queued waiting for the lock (i.e.,
   the sum of :serverstatus:`globalLock.currentQueue.readers` and
   :serverstatus:`globalLock.currentQueue.writers`).

   A consistently small queue, particularly of shorter operations,
   should cause no concern. The
   :serverstatus:`globalLock.activeClients` readers and writers
   information provides context for this data.

.. serverstatus:: globalLock.currentQueue.readers

   The number of operations that are currently queued and waiting for
   the read lock. A consistently small read queue, particularly of
   shorter operations, should cause no concern.

.. serverstatus:: globalLock.currentQueue.writers

   The number of operations that are currently queued and waiting for
   the write lock. A consistently small write queue, particularly of
   shorter operations, is no cause for concern.

.. serverstatus:: globalLock.activeClients

   A document that provides information about the number of connected
   clients and the read and write operations performed by these clients.

   Use this data to provide context for the
   :serverstatus:`globalLock.currentQueue` data.

.. serverstatus:: globalLock.activeClients.total

   The total number of internal client connections to the database
   including system threads as well as queued readers and writers.
   This metric will be higher than the total of ``activeClients.readers``
   and ``activeClients.writers`` due to the inclusion of system threads.

.. serverstatus:: globalLock.activeClients.readers

   The number of the active client connections performing read
   operations.

.. serverstatus:: globalLock.activeClients.writers

   The number of active client connections performing write operations.

.. _server-status-hedgingMetrics:

hedgingMetrics
~~~~~~~~~~~~~~

.. important::

   .. include:: /includes/hedged-reads-deprecated.rst

For :binary:`~bin.mongos` instances only.

.. code-block:: javascript

   hedgingMetrics : {
      numTotalOperations : <num>,
      numTotalHedgedOperations : <num>,
      numAdvantageouslyHedgedOperations : <num>
   },

.. serverstatus:: hedgingMetrics

   Provides metrics on :ref:`hedged reads <mongos-hedged-reads>` for
   the :binary:`~bin.mongos` instance.

   For :binary:`~bin.mongos` instances only.

.. serverstatus:: hedgingMetrics.numTotalOperations

   The total number of the operations issued with the :ref:`hedged read
   option enabled <read-preference-hedged-read>` to this
   :binary:`~bin.mongos` instance.

   For :binary:`~bin.mongos` instances only.

.. serverstatus:: hedgingMetrics.numTotalHedgedOperations

   The number of all operations for which the :binary:`~bin.mongos`
   instance :ref:`hedged the read operation <mongos-hedged-reads>`;
   i.e. sent the operation to an additional member of each queried
   shard.

   For :binary:`~bin.mongos` instances only.

.. serverstatus:: hedgingMetrics.numAdvantageouslyHedgedOperations

   The total number of the operation where the additional read sent to
   :ref:`hedge the read operation <mongos-hedged-reads>` fulfilled the
   client request.

   For :binary:`~bin.mongos` instances only.

.. _server-status-indexBuilds:

indexBuilds
~~~~~~~~~~~

.. code-block:: javascript

   indexBuilds : {
      total : <num>,
      killedDueToInsufficientDiskSpace : <num>,
      failedDueToDataCorruption : <num>
   },

.. serverstatus:: indexBuilds

   Provides metrics on :ref:`index builds <index-operations>` after the
   server last started.

.. serverstatus:: indexBuilds.total

   Total number of index builds.

.. serverstatus:: indexBuilds.killedDueToInsufficientDiskSpace

   Total number of index builds that were ended because of insufficient
   disk space. Starting in MongoDB 7.1, you can set the minimum amount
   of disk space required for building indexes using the
   :parameter:`indexBuildMinAvailableDiskSpaceMB` parameter.

   .. versionadded:: 7.1

.. serverstatus:: indexBuilds.failedDueToDataCorruption

   Total number of index builds that failed because of data corruption.

   .. versionadded:: 7.1

.. _server-status-indexBulkBuilder:

indexBulkBuilder
~~~~~~~~~~~~~~~~

.. code-block:: json

   indexBulkBuilder: {
      count: <long>, 
      resumed: <long>, 
      filesOpenedForExternalSort: <long>, 
      filesClosedForExternalSort: <long>, 
      spilledRanges: <long>, 
      bytesSpilledUncompressed: <long>,
      bytesSpilled: <long>,
      numSorted: <long>,
      bytesSorted: <long>,
      memUsage: <long>
   }

.. serverstatus:: indexBulkBuilder

   Provides metrics for index bulk builder operations.  Use these metrics to
   diagnose index build issues with :dbcommand:`createIndexes`, collection 
   cloning during initial sync, index builds that resume after startup, and
   statistics on disk usage by the external sorter.

.. serverstatus:: indexBuildBuilder.bytesSpilled

   .. versionadded:: 6.0.4

   The number of bytes written to disk by the external sorter.

.. serverstatus:: indexBuilder.bytesSpilledUncompressed

   .. versionadded:: 6.0.4

   The number of bytes to be written to disk by the external sorter 
   before compression. 

.. serverstatus:: indexBulkBuilder.count

   The number of instances of the bulk builder created.

.. serverstatus:: indexBulkBuilder.filesClosedForExternalSort

   The number of times the external sorter closed a file handle to spill data
   to disk.  Combine this value with 
   :serverstatus:`~indexBulkBuilder.filesOpenedForExternalSort` to determine
   the number of open file handles in use by the external sorter.

.. serverstatus:: indexBulkBuilder.filesOpenedForExternalSort

   The number of times the external sorter opened a file handle to spill data
   to disk.  Combine this value with 
   :serverstatus:`~indexBulkBuilder.filesClosedForExternalSort` to determine
   the number of open file handles in use by the external sorter.

.. serverstatus:: indexBulkBuilder.resumed

   The number of times the bulk builder was created for a resumable index build.

.. serverstatus:: indexBulkBuilder.spilledRanges

   .. versionadded:: 6.0.4

   The number of times the external sorter spilled to disk. 

.. serverstatus:: indexBulkBuilder.numSorted

   .. versionadded:: 6.3

   The total number of sorted documents.

.. serverstatus:: indexBulkBuilder.bytesSorted

   .. versionadded:: 6.3

   The total number of bytes for sorted documents. For example, if
   a total of 10 documents were sorted and each document is 20 bytes,
   the total number of bytes sorted is 200.

.. serverstatus:: indexBulkBuilder.memUsage

   .. versionadded:: 6.3

   The current bytes of memory allocated for building indexes.

.. _server-status-indexStats:

indexStats
~~~~~~~~~~

.. code-block:: json

   indexStats: {
      count: Long("<num>"), 
      features: {
         '2d': { count: Long("<num>"), accesses: Long("<num>") },
         '2dsphere': { count: Long("<num>"), accesses: Long("<num>") },
         '2dsphere_bucket': { count: Long("<num>"), accesses: Long("<num>") },
         collation: { count: Long("<num>"), accesses: Long("<num>") },
         compound: { count: Long("<num>"), accesses: Long("<num>") },
         hashed: { count: Long("<num>"), accesses: Long("<num>") },
         id: { count: Long("<num>"), accesses: Long("<num>") },
         normal: { count: Long("<num>"), accesses: Long("<num>") },
         partial: { count: Long("<num>"), accesses: Long("<num>") },
         single: { count: Long("<num>"), accesses: Long("<num>") },
         sparse: { count: Long("<num>"), accesses: Long("<num>") },
         text: { count: Long("<num>"), accesses: Long("<num>") },
         ttl: { count: Long("<num>"), accesses: Long("<num>") },
         unique: { count: Long("<num>"), accesses: Long("<num>") },
         wildcard: { count: Long("<num>"), accesses: Long("<num>") }
      }
   }

.. serverstatus:: indexStats

   A document that reports statistics on all indexes on databases and collections.

   .. versionadded:: 6.0

.. serverstatus:: indexStats.count

   The total number of indexes.

   .. versionadded:: 6.0

.. serverstatus:: indexStats.features

   A document that provides counters for each index type and the number of 
   accesses on each index. Each index type under ``indexStats.features`` 
   has a ``count`` field that counts the total number of indexes for that 
   type, and an ``accesses`` field that counts the number of accesses on that 
   index.

   .. versionadded:: 6.0

.. _server-status-instance-information:

Instance Information
~~~~~~~~~~~~~~~~~~~~

.. code-block:: javascript

   host : <string>,
   advisoryHostFQDNs : <array>,
   version : <string>,
   process : <'mongod'|'mongos'>,
   service : <'router'|'shard'>,
   pid : Long("<num>"),
   uptime : <num>,
   uptimeMillis : Long("<num>"),
   uptimeEstimate : Long("<num>"),
   localTime : ISODate("<Date>"),

.. serverstatus:: host

   The system's hostname. In Unix/Linux systems, this should be the
   same as the output of the ``hostname`` command.

.. serverstatus:: advisoryHostFQDNs

   An array of the system's fully qualified domain names (FQDNs).

.. serverstatus:: version

   The MongoDB version of the current MongoDB process.

.. serverstatus:: process

   The current MongoDB process. Possible values are: :binary:`~bin.mongos` or
   :binary:`~bin.mongod`.

.. serverstatus:: service 

   The role of the current MongoDB process. Possible values are ``router`` or 
   ``shard``.
   
   .. versionadded:: 8.0

.. serverstatus:: pid

   The process ID number.

.. serverstatus:: uptime

   The number of seconds that the current MongoDB process has been
   active.

.. serverstatus:: uptimeMillis

   The number of milliseconds that the current MongoDB process has been
   active.

.. serverstatus:: uptimeEstimate

   The uptime in seconds as calculated from MongoDB's internal
   course-grained time keeping system.

.. serverstatus:: localTime

   The ISODate representing the current time, according to the server,
   in UTC.

.. _locks:
.. _server-status-locks:

locks
~~~~~

.. code-block:: javascript

   locks : {
      <type> : {
            acquireCount : {
               <mode> : Long("<num>"),
               ...
            },
            acquireWaitCount : {
               <mode> : Long("<num>"),
               ...
            },
            timeAcquiringMicros : {
               <mode> : Long("<num>"),
               ...
            },
            deadlockCount : {
               <mode> : Long("<num>"),
               ...
            }
      },
      ...


.. serverstatus:: locks

   A document that reports for each lock ``<type>``, data on lock
   ``<modes>``.

   The possible lock ``<types>`` are:

   .. include:: /includes/fact-lock-types.rst

   The possible ``<modes>`` are:

   .. include:: /includes/fact-lock-modes.rst

   All values are of the ``Long()`` type.

   .. COMMENT

      these definitions are for the servers and not per operations;
      as such, they differ from those in db.currentOp.txt

.. serverstatus:: locks.<type>.acquireCount

   Number of times the lock was acquired in the specified mode.

.. serverstatus:: locks.<type>.acquireWaitCount

   Number of times the :serverstatus:`locks.<type>.acquireCount` lock
   acquisitions encountered waits because the locks were held in a
   conflicting mode.

.. serverstatus:: locks.<type>.timeAcquiringMicros

   Cumulative wait time in microseconds for the lock acquisitions.

   :serverstatus:`locks.<type>.timeAcquiringMicros` divided by
   :serverstatus:`locks.<type>.acquireWaitCount` gives an
   approximate average wait time for the particular lock mode.

.. serverstatus:: locks.<type>.deadlockCount

   Number of times the lock acquisitions encountered deadlocks.


.. _server-status-logicalSessions:

logicalSessionRecordCache
~~~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: javascript

   logicalSessionRecordCache : {
      activeSessionsCount : <num>,
      sessionsCollectionJobCount : <num>,
      lastSessionsCollectionJobDurationMillis : <num>,
      lastSessionsCollectionJobTimestamp : <Date>,
      lastSessionsCollectionJobEntriesRefreshed : <num>,
      lastSessionsCollectionJobEntriesEnded : <num>,
      lastSessionsCollectionJobCursorsClosed : <num>,
      transactionReaperJobCount : <num>,
      lastTransactionReaperJobDurationMillis : <num>,
      lastTransactionReaperJobTimestamp : <Date>,
      lastTransactionReaperJobEntriesCleanedUp : <num>,
      sessionCatalogSize : <num>  
   },

.. serverstatus:: logicalSessionRecordCache

   Provides metrics around the caching of :doc:`server sessions
   </reference/server-sessions/>`.

.. serverstatus:: logicalSessionRecordCache.activeSessionsCount

   The number of all active local sessions cached in memory by the
   :binary:`~bin.mongod` or :binary:`~bin.mongos` instance since the last
   refresh period.

   .. seealso::

      - :pipeline:`$listLocalSessions`
      - :parameter:`logicalSessionRefreshMillis`

.. serverstatus:: logicalSessionRecordCache.sessionsCollectionJobCount

   The number that tracks the number of times the refresh process has
   run on the :data:`config.system.sessions` collection.

   .. seealso::

      :parameter:`logicalSessionRefreshMillis`

.. serverstatus:: logicalSessionRecordCache.lastSessionsCollectionJobDurationMillis

   The length in milliseconds of the last refresh.

.. serverstatus:: logicalSessionRecordCache.lastSessionsCollectionJobTimestamp

   The time at which the last refresh occurred.

.. serverstatus:: logicalSessionRecordCache.lastSessionsCollectionJobEntriesRefreshed

   The number of sessions that were refreshed during the last refresh.

.. serverstatus:: logicalSessionRecordCache.lastSessionsCollectionJobEntriesEnded

   The number of sessions that ended during the last refresh.

.. serverstatus:: logicalSessionRecordCache.lastSessionsCollectionJobCursorsClosed

   The number of cursors that were closed during the last
   :data:`config.system.sessions` collection refresh.

.. serverstatus:: logicalSessionRecordCache.transactionReaperJobCount

   The number that tracks the number of times the transaction record
   cleanup process has run on the :data:`config.transactions`
   collection.

.. serverstatus:: logicalSessionRecordCache.lastTransactionReaperJobDurationMillis

   The length (in milliseconds) of the last transaction record cleanup.

.. serverstatus:: logicalSessionRecordCache.lastTransactionReaperJobTimestamp

   The time of the last transaction record cleanup.

.. serverstatus:: logicalSessionRecordCache.lastTransactionReaperJobEntriesCleanedUp

   The number of entries in the :data:`config.transactions` collection
   that were deleted during the last transaction record cleanup.

.. serverstatus:: logicalSessionRecordCache.sessionCatalogSize

   - For a :binary:`~bin.mongod` instance, 
        The size of its in-memory cache of the ``config.transactions``
        entries. This corresponds to retryable writes
        or transactions whose sessions have not expired within the
        :parameter:`localLogicalSessionTimeoutMinutes`.

   - For a :binary:`~bin.mongos` instance, 
        The number of the in-memory cache of its sessions that have had
        transactions within the most recent
        :parameter:`localLogicalSessionTimeoutMinutes` interval.

.. _memory-status:
.. _server-status-memory:

mem
~~~

.. code-block:: javascript

   mem : {
      bits : <int>,
      resident : <int>,
      virtual : <int>,
      supported : <boolean>
   },


.. serverstatus:: mem

   A document that reports on the system architecture of the
   :binary:`~bin.mongod` and current memory use.

.. serverstatus:: mem.bits

   A number, either ``64`` or ``32``, that indicates whether the
   MongoDB instance is compiled for 64-bit or 32-bit architecture.

.. serverstatus:: mem.resident

   The value of :serverstatus:`mem.resident` is roughly equivalent to
   the amount of RAM, in mebibyte (MiB), currently used by the database
   process. During normal use, this value tends to grow. In dedicated
   database servers, this number tends to approach the total amount of
   system memory.

.. serverstatus:: mem.virtual

   :serverstatus:`mem.virtual` displays the quantity, in mebibyte
   (MiB), of virtual memory used by the :binary:`~bin.mongod` process.

.. serverstatus:: mem.supported

   A boolean that indicates whether the underlying system supports
   extended memory information. If this value is false and the system
   does not support extended memory information, then other
   :serverstatus:`mem` values may not be accessible to the database
   server.


.. serverstatus:: mem.note

   The field :serverstatus:`mem.note` appears if
   :serverstatus:`mem.supported` is false.

   The :serverstatus:`mem.note` field contains the text: ``'not all mem
   info support on this platform'``.

.. _server-status-metrics:

metrics
~~~~~~~

.. code-block:: javascript

   metrics : {
      abortExpiredTransactions: {
         passes: <integer>
      },
      apiVersions: {
         <appName1>: <string>, 
         <appName2>: <string>, 
         <appName3>: <string>
      },
      aggStageCounters : {
         <aggregation stage> : Long("<num>")
      },
      changeStreams: {
         largeEventsFailed: Long("<num>"),
         largeEventsSplit: Long("<num>"),
         showExpandedEvents: Long("<num>")
      },
      commands: {
         <command>: {
            failed: Long("<num>"),
            validator: { 
              total: Long("<num>"), 
              failed: Long("<num>"), 
              jsonSchema: Long("<num>")
            }, 
            total: Long("<num>"),
            rejected: Long("<num>")    
         }
      },
      cursor : {
         moreThanOneBatch : Long("<num>"),
         timedOut : Long("<num>"),
         totalOpened : Long("<num>"),
         lifespan : {
            greaterThanOrEqual10Minutes : Long("<num>"),
            lessThan10Minutes : Long("<num>"),
            lessThan15Seconds : Long("<num>"),
            lessThan1Minute : Long("<num>"),
            lessThan1Second : Long("<num>"),
            lessThan30Seconds : Long("<num>"),
            lessThan5Seconds : Long("<num>")
         },
         open : {
            noTimeout : Long("<num>"),
            pinned : Long("<num>"),
            multiTarget : Long("<num>"),
            singleTarget : Long("<num>"),
            total : Long("<num>")
         }
      },
      document : {
         deleted : Long("<num>"),
         inserted : Long("<num>"),
         returned : Long("<num>"),
         updated : Long("<num>")
      },
      dotsAndDollarsFields : {
            inserts : Long("<num>"),
            updates : Long("<num>")
      },
      getLastError : {
         wtime : {
            num : <num>,
            totalMillis : <num>
         },
         wtimeouts : Long("<num>"),
         default : {
            unsatisfiable : Long("<num>"),
            wtimeouts : Long("<num>")
         }
      },
      mongos : {
         cursor : {
            moreThanOneBatch : Long("<num>"),
            totalOpened : Long("<num>")
         }
      },
      network : {  // Added in MongoDB 6.3
         totalEgressConnectionEstablishmentTimeMillis : Long("<num>"),
         totalIngressTLSConnections : Long("<num>"),
         totalIngressTLSHandshakeTimeMillis : Long("<num>"),
         totalTimeForEgressConnectionAcquiredToWireMicros : Long("<num>"),
         totalTimeToFirstNonAuthCommandMillis : Long("<num>")
      },
      operation : {
         killedDueToClientDisconnect : Long("<num>"),  // Added in MongoDB 7.1
         killedDueToDefaultMaxTimeMSExpired : Long("<num>"),
         killedDueToMaxTimeMSExpired : Long("<num>"),  // Added in MongoDB 7.2 
         numConnectionNetworkTimeouts : Long("<num>"),  // Added in MongoDB 6.3
         scanAndOrder : Long("<num>"),
         totalTimeWaitingBeforeConnectionTimeoutMillis : Long("<num>"),  // Added in MongoDB 6.3
         unsendableCompletedResponses : Long("<num>"),  // Added in MongoDB 7.1
         writeConflicts : Long("<num>")
      },
      operatorCounters : {
         expressions : {
            <command> : Long("<num>")
         },
         match : {
            <command> : Long("<num>")
         }
      },
      query: {
         allowDiskUseFalse: Long("<num>"),
         updateOneOpStyleBroadcastWithExactIDCount: Long("<num>"),
         lookup: {
            hashLookup: Long("<num>"),
            hashLookupSpillToDisk: Long("<num>"),
            indexedLoopJoin: Long("<num>"),
            nestedLoopJoin: Long("<num>")
         },
         multiPlanner: {
            classicCount: Long("<num>"),
            classicMicros: Long("<num>"),
            classicWorks: Long("<num>"),
            sbeCount: Long("<num>"),
            sbeMicros: Long("<num>"),
            sbeNumReads: Long("<num>"),
            histograms: {
               classicMicros: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("1073741824"), count: Long("<num>")> }>
               ],
               classicNumPlans: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("32"), count: Long("<num>") }
               ],
               classicWorks: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("32768"), count: Long("<num>") }
               ],
               sbeMicros: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("1073741824"), count: Long("<num>") }
               ],
               sbeNumPlans: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("32"), count: Long("<num>") }
               ],
               sbeNumReads: [
                  { lowerBound: Long("0"), count: Long("<num>") },
                  { < Additional histogram groups not shown. > },
                  { lowerBound: Long("32768"), count: Long("<num>") }
               ]
            }
         },
         planCache: {
            classic: { hits: Long("<num>"), misses: Long("<num>") },
            sbe: { hits: Long("<num>"), misses: Long("<num>") }
         },
         queryFramework: {
            aggregate: {
               classicHybrid: Long("<num>"),
               classicOnly: Long("<num>"),
               cqf: Long("<num>"),
               sbeHybrid: Long("<num>"),
               sbeOnly: Long("<num>")
            },
            find: { classic: Long("<num>"), cqf: Long("<num>"), sbe: Long("<num>") }
         }
      },
      queryExecutor: {
         scanned : Long("<num>"),
         scannedObjects : Long("<num>"),
         collectionScans : {
            nonTailable : Long("<num>"),
            total : Long("<num>")
         }
      },
      record : {
         moves : Long("<num>")
      },
      repl : {
         executor : {
            pool : {
               inProgressCount : <num>
            },
            queues : {
               networkInProgress : <num>,
               sleepers : <num>
            },
            unsignaledEvents : <num>,
            shuttingDown : <boolean>,
            networkInterface : <string>
         },
         apply : {
            attemptsToBecomeSecondary : Long("<num>"),
            batches : {
               num : <num>,
               totalMillis : <num>
            },
            ops : Long("<num>")
         },
         buffer : {
            count : Long("<num>"),
            maxSizeBytes : Long("<num>"),
            sizeBytes : Long("<num>")
         },
         initialSync : {
            completed : Long("<num>"),
            failedAttempts : Long("<num>"),
            failures : Long("<num>")
         },
         network : {
            bytes : Long("<num>"),
            getmores : {
               num : <num>,
               totalMillis : <num>
            },
            notPrimaryLegacyUnacknowledgedWrites : Long("<num>"),
            notPrimaryUnacknowledgedWrites : Long("<num>"),
            oplogGetMoresProcessed : {
               num : <num>,
               totalMillis : <num>
            },
            ops : Long("<num>"),
            readersCreated : Long("<num>"),
            replSetUpdatePosition : {
               num : Long("<num>")
            }
         },
         reconfig : {
            numAutoReconfigsForRemovalOfNewlyAddedFields : Long("<num>")
         },
         stateTransition : {
            lastStateTransition : <string>,
            totalOperationsKilled : Long("<num>"),
            totalOperationsRunning : Long("<num>")
         },
         syncSource : {
            numSelections : Long("<num>"),
            numTimesChoseSame : Long("<num>"),
            numTimesChoseDifferent : Long("<num>"),
            numTimesCouldNotFind : Long("<num>")
         },
         waiters : {
            opTime : Long("<num>"),
            replication : Long("<num>")
         }
      },
      storage : {
         freelist : {
            search : {
               bucketExhausted : <num>,
               requests : <num>,
               scanned : <num>
            }
         }
      },
      ttl : {
         deletedDocuments : Long("<num>"),
         passes : Long("<num>")
      }
   }

.. serverstatus:: metrics

   A document that returns various statistics that reflect the current
   use and state of a running :binary:`~bin.mongod` instance.

.. serverstatus:: metrics.abortExpiredTransactions

   Document that returns statistics on the current state of the
   ``abortExpiredTransactions`` thread.

.. serverstatus:: metrics.abortExpiredTransactions.passes

   Indicates the number of successful passes aborting transactions
   older than the :parameter:`transactionLifetimeLimitSeconds` parameter.

   If the ``passes`` value stops incrementing, it indicates that the
   ``abortExpiredTransactions`` thread may be stuck.

.. serverstatus:: metrics.aggStageCounters

   A document that reports on the use of
   :ref:`aggregation pipeline stages 
   <aggregation-pipeline-operator-reference>`. The fields in 
   :serverstatus:`metrics.aggStageCounters` are the names of 
   aggregation pipeline stages. For each pipeline stage,
   :dbcommand:`serverStatus` reports the number of times that stage
   has been executed.

   *Updated in version 5.2 (and 5.0.6).*

.. _server-status-apiVersions:

.. serverstatus:: metrics.apiVersions

   A document that contains:
   
   - The name of each client application
   - The Stable API version that each application was configured with within
     the last 24-hour period
     
   Consider the following when viewing ``metrics.apiVersions``:

   - The possible returned values for each ``appname`` are:
     
     - ``default``: The command was issued without a Stable API version specified.
     - ``1``: The command was issued with Stable API version 1.
     
     .. note::
        
        You may see both return values for an ``appname`` because you can
        specify a Stable API version at the command level. Some of your
        commands may have been issued with no Stable API version, while
        others were issued with version 1.

   - API version metrics are retained for 24 hours. If
     no commands are issued with a specific API version from an 
     application in the past 24 hours, that ``appname`` and API version 
     will be removed from the metrics. This also applies to the 
     ``default`` API version metric.

   - Set the ``appname`` when connecting to a MongoDB instance by 
     specifying the ``appname`` in the connection URI. ``?appName=ZZZ`` 
     sets the ``appname`` to ``ZZZZ``.

   - Drivers accessing the Stable API can set a default ``appname``.

   - If no ``appname`` is configured, a default value will be 
     automatically populated based on the product. For example, for a 
     :compass:`MongoDB Compass </>` connection with no ``appname`` in 
     the URI, the metric returns: ``'MongoDB Compass': [ 'default' ]``.

   *New in version 5.0.* 

.. serverstatus:: metrics.operatorCounters

   A document that reports on the use of :ref:`aggregation pipeline
   <aggregation-pipeline>` operators and expressions.

.. serverstatus:: metrics.operatorCounters.expressions

   A document with a number that indicates how often
   :ref:`aggregation-expression-operators` ran.

   To get metrics for a specific operator, such as the greater-than
   operator (:expression:`$gt`), append the operator to the command:

   .. code-block:: javascript

      db.runCommand( { serverStatus: 1 } ).metrics.operatorCounters.expressions.$gt

   .. versionadded:: 5.0

.. serverstatus:: metrics.operatorCounters.match

   A document with a number that indicates how often
   :ref:`match expressions <query-projection-operators-top>` ran.

   :ref:`Match expression operators <query-projection-operators-top>`
   also increment as part of an aggregation pipeline :pipeline:`$match`
   stage. If the ``$match`` stage uses the :query:`$expr` operator, the
   counter for ``$expr`` increments, but the component counters do not
   increment. 

   Consider the following query: 

   .. code-block:: javascript
      :copyable: false

      db.matchCount.aggregate(
         [
            { $match:
               {  $expr: { $gt: [ "$_id", 0 ] } }
            }
         ]
      )

   The counter for ``$expr`` increments when the query runs. The
   counter for ``$gt`` does not. 

.. serverstatus:: metrics.changeStreams.largeEventsSplit

   The number of change stream events larger than 16 MB that were split
   into smaller fragments. Events are only split if you use the
   :pipeline:`$changeStreamSplitLargeEvent` pipeline stage.

   .. versionadded:: 7.0 (*Also available in 6.0.9*)

.. serverstatus:: metrics.changeStreams

   A document that reports information about :ref:`change stream
   <changeStreams>` events larger than 16 MB.

   .. versionadded:: 7.0

.. serverstatus:: metrics.changeStreams.largeEventsFailed

   The number of change stream events that caused a
   ``BSONObjectTooLarge`` exception because the event was larger than 16
   MB. To prevent the exception, see
   :pipeline:`$changeStreamSplitLargeEvent`.

   .. versionadded:: 7.0 (*Also available in 6.0.9 and 5.0.19*)

.. serverstatus:: metrics.changeStreams.showExpandedEvents

   The number of change stream cursors with the :ref:`showExpandedEvents 
   <change-streams-expanded-events>` option set to ``true``.

   The counter for ``showExpandedEvents`` increments when you: 
   
   - Open a change stream cursor.
   
   - Run the :dbcommand:`explain` command on a change stream cursor.

   .. versionadded:: 7.1

.. serverstatus:: metrics.commands

   A document that reports on the use of database commands. The fields
   in :serverstatus:`metrics.commands` are the names of :doc:`database
   commands </reference/command>`. For each command, the
   :dbcommand:`serverStatus` reports the total number of executions and
   the number of failed executions.

   :serverstatus:`metrics.commands` includes
   ``replSetStepDownWithForce`` (i.e. the :dbcommand:`replSetStepDown`
   command with ``force: true``) as well as the overall
   ``replSetStepDown``. In earlier versions, the command
   reported only overall ``replSetStepDown`` metrics.

.. serverstatus:: metrics.commands.<command>.failed

   The number of times ``<command>`` failed on this
   :binary:`~bin.mongod`.


.. serverstatus:: metrics.commands.<create or collMod>.validator

   For the :dbcommand:`create` and :dbcommand:`collMod` commands, a document
   that reports on non-empty ``validator`` objects passed to the command to
   specify :ref:`validation rules or expressions <schema-validation-overview>`
   for the collection.


.. serverstatus:: metrics.commands.<create or collMod>.validator.total

   The number of times a non-empty ``validator`` object was passed as an option
   to the command on this :binary:`~bin.mongod`.

.. serverstatus:: metrics.commands.<create or collMod>.validator.failed

   The number of times a call to the command on this :binary:`~bin.mongod`
   failed with a non-empty ``validator`` object due to a schema validation
   error.

.. serverstatus:: metrics.commands.<create or collMod>.validator.jsonSchema

   The number of times a ``validator`` object with a ``$jsonSchema`` was passed
   as an option to the command on this :binary:`~bin.mongod`.


.. serverstatus:: metrics.commands.<command>.total

   The number of times ``<command>`` executed on this
   :binary:`~bin.mongod`.

.. serverstatus:: metrics.commands.<command>.rejected

   The number of times ``<command>`` was rejected on this
   :binary:`~bin.mongod` because the because the command or operation
   has an associated query setting where the ``reject`` field is
   ``true``.

   To set the ``reject`` field, use ``setQuerySettings``.

   .. versionadded:: 8.0

.. serverstatus:: metrics.commands.update.pipeline

   The number of times an
   :ref:`aggregation pipeline <aggregation-pipeline-operator-reference>`
   was used to update documents on this :binary:`~bin.mongod`. Subtract
   this value from the total number of updates to get the number of
   updates made with :ref:`document <update-operators-top-level>`
   syntax.

   The ``pipeline`` counter is only available for ``update`` and
   ``findAndModify`` operations.

.. serverstatus:: metrics.commands.findAndModify.pipeline

   The number of times :method:`~db.collection.findAndModify()` was
   used in an
   :ref:`aggregation pipeline <aggregation-pipeline-operator-reference>`
   to update documents on this :binary:`~bin.mongod`.

   The ``pipeline`` counter is only available for ``update`` and
   ``findAndModify`` operations.

.. serverstatus:: metrics.commands.update.arrayFilters

   The number of times an :ref:`arrayFilter <findAndModify-arrayFilters>`
   was used to update documents on this :binary:`~bin.mongod`.

   The ``arrayFilters`` counter is only available for ``update`` and
   ``findAndModify`` operations.

.. serverstatus:: metrics.commands.findAndModify.arrayFilters

   The number of times an :ref:`arrayFilter <findAndModify-arrayFilters>`
   was used with :method:`~db.collection.findAndModify()` to update
   documents on this :binary:`~bin.mongod`.

   The ``arrayFilters`` counter is only available for ``update`` and
   ``findAndModify`` operations.

.. serverstatus:: metrics.document

   A document that reflects document access and modification patterns.
   Compare these values to the data in the :serverstatus:`opcounters`
   document, which track total number of operations.

.. serverstatus:: metrics.document.deleted

   The total number of documents deleted.

.. serverstatus:: metrics.document.inserted

   The total number of documents inserted.

.. serverstatus:: metrics.document.returned

   The total number of documents returned by queries.

.. serverstatus:: metrics.document.updated

   The total number of documents matched for update operations. This value is not 
   necessarily the same as the number of documents modified by updates.

.. serverstatus:: metrics.dotsAndDollarsFields

   A document with a number that indicates how often
   :ref:`insert <write-op-insert>` or :ref:`update <write-op-update>`
   operations ran using a dollar (``$``) prefixed name. The value does
   not report the exact number of operations.  

   When an :term:`upsert` operation creates a new document, it is
   considered to be an ``insert`` rather than an ``update``.

   .. versionadded:: 5.0

.. serverstatus:: metrics.executor

   A document that reports on various statistics for the replication
   executor.

.. serverstatus:: metrics.getLastError

   A document that reports on :ref:`write concern <write-concern>` use.

.. serverstatus:: metrics.getLastError.wtime

   A document that reports :ref:`write concern <write-concern>`
   operation counts with a ``w`` argument greater than ``1``.

.. serverstatus:: metrics.getLastError.wtime.num

   The total number of operations with a specified write concern
   (i.e. ``w``) that wait for one or more members of a replica set to
   acknowledge the write operation (i.e. a ``w`` value greater than
   ``1``.)

.. serverstatus:: metrics.getLastError.wtime.totalMillis

   The total amount of time in milliseconds that the
   :binary:`~bin.mongod` has spent performing :ref:`write concern
   <write-concern>` operations with a write concern (i.e. ``w``) that
   waits for one or more members of a replica set to acknowledge the
   write operation (i.e. a ``w`` value greater than ``1``.)

.. serverstatus:: metrics.getLastError.wtimeouts

   The number of times that :term:`write concern` operations have timed
   out as a result of the ``wtimeout`` threshold. This number
   increments for both default and non-default write concern
   specifications.

.. serverstatus:: metrics.getLastError.default

   A document that reports on when a default :ref:`write concern
   <write-concern>` was used (meaning, a non-``clientSupplied`` write
   concern). The possible origins of a default write concern are:

   - ``implicitDefault``
   - ``customDefault``
   - ``getLastErrorDefaults``

   Refer to the following table for information on
   each possible write concern origin, or ``provenance``:

   .. include:: /includes/fact-wc-provenance-table.rst

.. serverstatus:: metrics.getLastError.default.unsatisfiable

   Number of times that a non-``clientSupplied`` write concern
   returned the ``UnsatisfiableWriteConcern`` error code.

.. serverstatus:: metrics.getLastError.default.wtimeouts

   Number of times a non-``clientSupplied`` write concern timed out.

.. _server-status-metrics-mongos:

.. serverstatus:: metrics.mongos

   A document that contains metrics about :binary:`~bin.mongos`.

.. serverstatus:: metrics.mongos.cursor

   A document that contains metrics for cursors used by
   :binary:`~bin.mongos`.

.. serverstatus:: metrics.mongos.cursor.moreThanOneBatch

   The total number of cursors that have returned more than one batch
   since :binary:`~bin.mongos` started. Additional batches are retrieved
   using the :dbcommand:`getMore` command.

   .. versionadded:: 5.0

.. serverstatus:: metrics.mongos.cursor.totalOpened

   The total number of cursors that have been opened since
   :binary:`~bin.mongos` started, including cursors currently open.
   Differs from :serverstatus:`metrics.cursor.open.total`, which is the
   number of currently open cursors only.

   .. versionadded:: 5.0

.. serverstatus:: metrics.network

   .. versionadded:: 6.3

   A document that reports server network metrics.

.. serverstatus:: metrics.network.totalEgressConnectionEstablishmentTimeMillis

   .. versionadded:: 6.3

   The total time in milliseconds to establish server connections.

.. serverstatus:: metrics.network.totalIngressTLSConnections

   .. versionadded:: 6.3

   The total number of incoming connections to the server that use TLS.
   The number is cumulative and is the total after the server was
   started.

.. serverstatus:: metrics.network.totalIngressTLSHandshakeTimeMillis

   .. versionadded:: 6.3

   The total time in milliseconds that incoming connections to the
   server have to wait for the TLS network handshake to complete. The
   number is cumulative and is the total after the server was started.

.. serverstatus:: metrics.network.totalTimeForEgressConnectionAcquiredToWireMicros

   .. versionadded:: 6.3

   The total time in microseconds that operations wait between
   acquisition of a server connection and writing the bytes to send to
   the server over the network. The number is cumulative and is the
   total after the server was started.

.. serverstatus:: metrics.network.totalTimeToFirstNonAuthCommandMillis

   .. versionadded:: 6.3

   The total time in milliseconds from accepting incoming connections to
   the server and receiving the first operation that isn't part of the
   connection authentication handshake. The number is cumulative and is
   the total after the server was started.

.. serverstatus:: metrics.operation

   A document that holds counters for several types of update and query
   operations that MongoDB handles using special operation types.

.. serverstatus:: metrics.operation.killedDueToClientDisconnect

   .. versionadded:: 7.1

   Total number of operations cancelled before completion 
   because the client disconnected.

.. serverstatus:: metrics.operation.killedDueToDefaultMaxTimeMSExpired

   .. versionadded:: 8.0

   Total number of operations that timed out due to the cluster-level
   default timeout, :parameter:`defaultMaxTimeMS`. 

.. serverstatus:: metrics.operation.killedDueToMaxTimeMSExpired

   .. versionadded:: 7.2

   Total number of operations that timed out due to the operation-level
   timeout, :method:`cursor.maxTimeMS()`.

.. serverstatus:: metrics.operation.numConnectionNetworkTimeouts

   .. versionadded:: 6.3

   Total number of operations that failed because of server connection
   acquisition time out errors.

.. serverstatus:: metrics.operation.scanAndOrder

   The total number of queries that return sorted numbers that cannot
   perform the sort operation using an index.

.. serverstatus:: metrics.operation.totalTimeWaitingBeforeConnectionTimeoutMillis

   .. versionadded:: 6.3

   Total time in milliseconds that operations waited before failing
   because of server connection acquisition time out errors.

.. serverstatus:: metrics.operation.unsendableCompletedResponses
   
   .. versionadded:: 7.1

   Total number of operations that completed server-side but
   did not send their response to the client because 
   the connection between the client and server failed or disconnected.

.. serverstatus:: metrics.operation.writeConflicts

   The total number of queries that encountered write conflicts.

.. serverstatus:: metrics.query.lookup

   A document that provides detailed data on the use of the  :pipeline:`$lookup` 
   stage with the |sbe|. To learn more, see :ref:`agg-lookup-optimization-sbe`.

   These metrics are primarily intended for internal use by MongoDB.

   *New in version 6.1* 

.. serverstatus:: metrics.query.multiPlanner

   Provides detailed query planning data for the |sbe| and the classic
   query engine. For more information on the |sbe| see:
   :ref:`sbe-pipeline-optimizations`.

   These metrics are primarily intended for internal use by MongoDB.

   *New in version 6.0.0 and 5.0.9* 

.. serverstatus:: metrics.query.sort

   A document that holds counters related to sort stages.

   .. versionadded:: 6.2

.. serverstatus:: metrics.query.sort.spillToDisk

   The total number of writes to disk caused by sort stages.

   .. versionadded:: 6.2

.. serverstatus:: metrics.query.sort.totalBytesSorted

   The total amount of sorted data in bytes. 
   
   .. versionadded:: 6.2

.. serverstatus:: metrics.query.sort.totalKeysSorted

   The total number of keys used in sorts.
   
   .. versionadded:: 6.2

.. serverstatus:: query.multiPlanner.classicMicros

   Aggregates the total number of microseconds spent in the classic
   multiplanner.

.. serverstatus:: query.multiPlanner.classicWorks

   Aggregates the total number of "works" performed in the classic
   multiplanner.

.. serverstatus:: query.multiPlanner.classicCount

   Aggregates the total number of invocations of the classic
   multiplanner.

.. serverstatus:: query.multiPlanner.sbeMicros

   Aggregates the total number of microseconds spent in the |sbe-short|
   multiplanner.

.. serverstatus:: query.multiPlanner.sbeNumReads

   Aggregates the total number of reads done in the |sbe-short|
   multiplanner.

.. serverstatus:: query.multiPlanner.sbeCount

   Aggregates the total number of invocations of the |sbe-short|
   multiplanner.

.. serverstatus::  query.multiPlanner.histograms.classicMicros

   A histogram measuring the number of microseconds spent in an
   invocation of the classic multiplanner.

.. serverstatus:: query.multiPlanner.histograms.classicWorks

   A histogram measuring the number of "works" performed during an
   invocation of the classic multiplanner.

.. serverstatus::  query.multiPlanner.histograms.classicNumPlans

   A histogram measuring the number of plans in the candidate set during
   an invocation of the classic multiplanner.

.. serverstatus:: query.multiPlanner.histograms.sbeMicros

   A histogram measuring the number of microseconds spent in an
   invocation of the |sbe-short| multiplanner.

.. serverstatus:: query.multiPlanner.histograms.sbeNumReads

   A histogram measuring the number of reads during an invocation of the
   |sbe-short| multiplanner.

.. serverstatus:: query.multiPlanner.histograms.sbeNumPlans

   A histogram measuring the number of plans in the candidate set during
   an invocation of the |sbe-short| multiplanner.

.. serverstatus:: query.queryFramework.aggregate

   A document that reports on the number of aggregation operations run on each 
   :term:`query framework`. The subfields in ``query.queryFramework.aggregate``
   indicate the number of times each framework was used to perform an 
   aggregation operation.

.. serverstatus:: query.queryFramework.find

   A document that reports on the number of find operations run on each 
   :term:`query framework`. The subfields in ``query.queryFramework.find`` 
   indicate the number of times each framework was used to perform a find 
   operation.

.. serverstatus:: metrics.queryExecutor

   A document that reports data from the query execution system.

.. serverstatus:: metrics.queryExecutor.scanned

   The total number of index items scanned during queries and
   query-plan evaluation. This counter is the same as
   :data:`~explain.executionStats.totalKeysExamined` in the output of
   :method:`~cursor.explain()`.

.. serverstatus:: metrics.queryExecutor.scannedObjects

   The total number of documents scanned during queries and query-plan
   evaluation. This counter is the same as
   :data:`~explain.executionStats.totalDocsExamined` in the output of
   :method:`~cursor.explain()`.

.. serverstatus:: metrics.queryExecutor.collectionScans

   A document that reports on the number of queries that performed a
   collection scan.

.. serverstatus:: metrics.queryExecutor.collectionScans.nonTailable

   The number of queries that performed a collection scan that did not
   use a :ref:`tailable cursor <tailable-cursors-landing-page>`.

.. serverstatus:: metrics.queryExecutor.collectionScans.total

   The total number queries that performed a collection scan. The total
   consists of queries that did and did not use a :doc:`tailable cursor
   </core/tailable-cursors>`.

.. serverstatus:: metrics.record

   A document that reports on data related to record allocation in the
   on-disk memory files.

.. _server-status-replnetworkqueue:
.. _server-status-repl-network-queue:

.. serverstatus:: metrics.repl

   A document that reports metrics related to the replication process.
   :serverstatus:`metrics.repl` document appears on all
   :binary:`~bin.mongod` instances, even those that aren't members of
   :term:`replica sets <replica set>`.

.. serverstatus:: metrics.repl.apply

   A document that reports on the application of operations from the
   replication :term:`oplog`.

.. serverstatus:: metrics.repl.apply.batchSize

   The total number of oplog operations applied. The
   :serverstatus:`metrics.repl.apply.batchSize` is incremented with the
   number of operations in a batch at the batch boundaries instead of
   being incremented by one after each operation.

   For finer granularity, see :serverstatus:`metrics.repl.apply.ops`.

.. serverstatus:: metrics.repl.apply.batches

   :serverstatus:`metrics.repl.apply.batches` reports on the
   oplog application process on :term:`secondaries <secondary>`
   members of replica sets. See
   :ref:`replica-set-internals-multi-threaded-replication` for more
   information on the oplog application processes.

.. serverstatus:: metrics.repl.apply.batches.num

   The total number of batches applied across all databases.

.. serverstatus:: metrics.repl.apply.batches.totalMillis

   The total amount of time in milliseconds the :binary:`~bin.mongod` has
   spent applying operations from the oplog.

.. serverstatus:: metrics.repl.apply.ops

   The total number of :term:`oplog` operations applied.
   :serverstatus:`metrics.repl.apply.ops` is incremented after each
   operation.

   .. seealso::

      :serverstatus:`metrics.repl.apply.batchSize`

.. serverstatus:: metrics.repl.buffer

   MongoDB buffers oplog operations from the replication sync source
   buffer before applying oplog entries in a
   batch. :serverstatus:`metrics.repl.buffer` provides a way to
   track the oplog buffer. See
   :ref:`replica-set-internals-multi-threaded-replication` for more
   information on the oplog application process.

.. serverstatus:: metrics.repl.buffer.count

   The current number of operations in the oplog buffer.

.. serverstatus:: metrics.repl.buffer.maxSizeBytes

   The maximum size of the buffer. This value is a constant setting in
   the :binary:`~bin.mongod`, and is not configurable.

.. serverstatus:: metrics.repl.buffer.sizeBytes

   The current size of the contents of the oplog buffer.

.. serverstatus:: metrics.repl.network

   :serverstatus:`metrics.repl.network` reports network use by
   the replication process.

.. serverstatus:: metrics.repl.network.bytes

   :serverstatus:`metrics.repl.network.bytes` reports the total
   amount of data read from the replication sync source.

.. serverstatus:: metrics.repl.network.getmores

   :serverstatus:`metrics.repl.network.getmores` reports on the
   ``getmore`` operations, which are requests for additional results
   from the oplog :term:`cursor` as part of the oplog replication
   process.

   .. TODO move the documentation of getmore into some central place

.. serverstatus:: metrics.repl.network.getmores.num

   :serverstatus:`metrics.repl.network.getmores.num` reports the
   total number of ``getmore`` operations, which are operations that
   request an additional set of operations from the replication sync
   source.

.. serverstatus:: metrics.repl.network.getmores.totalMillis

   :serverstatus:`metrics.repl.network.getmores.totalMillis`
   reports the total amount of time required to collect data from
   ``getmore`` operations.

   .. note::

      This number can be quite large, as MongoDB will wait for more
      data even if the ``getmore`` operation does not initial return
      data.

.. serverstatus:: metrics.repl.network.getmores.numEmptyBatches

   The number of empty ``oplog`` batches a secondary receives from its
   sync source. A secondary receives an empty batch if it is fully
   synced with its source and either:

   - The ``getmore`` times out waiting for more data, or

   - The sync source's majority commit point has advanced since the
     last batch sent to this secondary.

   For a primary, if the instance was previously a secondary, the
   number reports on the empty batches received when it was a
   secondary. Otherwise, for a primary, this number is ``0``.

.. serverstatus:: metrics.repl.network.notPrimaryLegacyUnacknowledgedWrites

   The number of unacknowledged (``w: 0``) legacy write operations (see
   :ref:`wp-request-opcodes`) that failed because the current
   :binary:`~bin.mongod` is not in :replstate:`PRIMARY` state.

.. serverstatus:: metrics.repl.network.notPrimaryUnacknowledgedWrites

   The number of unacknowledged (``w: 0``) write operations that failed
   because the current :binary:`~bin.mongod` is not in
   :replstate:`PRIMARY` state.

.. serverstatus:: metrics.repl.network.oplogGetMoresProcessed

   A document that reports the number of :dbcommand:`getMore`
   commands to fetch the :term:`oplog` that a node processed as a sync
   source.

.. serverstatus:: metrics.repl.network.oplogGetMoresProcessed.num

   The number of :dbcommand:`getMore` commands to fetch the
   :term:`oplog` that a node processed as a sync source.

.. serverstatus:: metrics.repl.network.oplogGetMoresProcessed.totalMillis

   The time, in milliseconds, that a node spent processing the
   :dbcommand:`getMore` commands counted in
   :serverstatus:`metrics.repl.network.oplogGetMoresProcessed.num`. 

.. serverstatus:: metrics.repl.network.ops

   The total
   number of operations read from the replication source.

.. serverstatus:: metrics.repl.network.readersCreated

   The total number of oplog query processes created. MongoDB will
   create a new oplog query any time an error occurs in the
   connection, including a timeout, or a network
   operation. Furthermore,
   :serverstatus:`metrics.repl.network.readersCreated` will
   increment every time MongoDB selects a new source for replication.

.. serverstatus:: metrics.repl.network.replSetUpdatePosition

   A document that reports the number of ``replSetUpdatePosition``
   commands a node sent to its sync source.

.. serverstatus:: metrics.repl.network.replSetUpdatePosition.num

   The number of ``replSetUpdatePosition`` commands a node sent
   to its sync source. ``replSetUpdatePosition`` commands are internal
   replication commands that communicate replication progress from
   nodes to their sync sources.

   .. note::

      Replica set members in the :replstate:`STARTUP2` state do not send
      the ``replSetUpdatePosition`` command to their sync source.

.. serverstatus:: metrics.repl.reconfig

   A document containing the number of times that member ``newlyAdded``
   fields were automatically removed by the primary. When a member is
   first added to the replica set, the member's ``newlyAdded`` field is
   set to ``true``.

   .. versionadded:: 5.0

.. serverstatus:: metrics.repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields

   The number of times that ``newlyAdded`` member fields were
   automatically removed by the primary. When a member is first added to
   the replica set, the member's ``newlyAdded`` field is set to
   ``true``. After the primary receives the member's heartbeat response
   indicating the member state is :replstate:`SECONDARY`,
   :replstate:`RECOVERING`, or :replstate:`ROLLBACK`, the primary
   automatically removes the member's ``newlyAdded`` field. The
   ``newlyAdded`` fields are stored in the :data:`local.system.replset`
   collection.

   .. versionadded:: 5.0

.. serverstatus:: metrics.repl.stateTransition

   Information on user operations when the member undergoes one of the
   following transitions that can stop user operations:

   - The member steps up to become a primary.

   - The member steps down to become a secondary.

   - The member is actively performing a rollback.

.. serverstatus:: metrics.repl.stateTransition.lastStateTransition

   The transition being reported:

   .. list-table::
      :widths: 20 80
      :header-rows: 1

      * - State Change
        - Description

      * - ``"stepUp"``

        - The member steps up to become a primary.

      * - ``"stepDown"``
        - The member steps down to become a secondary.

      * - ``"rollback"``

        - The member is actively performing a rollback.

      * - ``""``

        - The member has not undergone any state changes.

.. serverstatus:: metrics.repl.stateTransition.totalOperationsKilled

   The total number of operations stopped during the
   :binary:`~bin.mongod` instance's state change.

   .. versionadded:: 7.3

      ``totalOperationsKilled`` replaces 
      :serverstatus:`~metrics.repl.stateTransition.userOperationsKilled`

.. serverstatus:: metrics.repl.stateTransition.totalOperationsRunning

   The total number of operations that remained running during the
   :binary:`~bin.mongod` instance's state change.

   .. versionadded:: 7.3

      ``totalOperationsRunning`` replaces
      :serverstatus:`~metrics.repl.stateTransition.userOperationsRunning`

.. serverstatus:: metrics.repl.stateTransition.userOperationsKilled

   .. deprecated:: 7.3

      :serverstatus:`~metrics.repl.stateTransition.totalOperationsKilled`
      replaces ``userOperationsKilled``.

.. serverstatus:: metrics.repl.stateTransition.userOperationsRunning

   .. deprecated:: 7.3

      :serverstatus:`~metrics.repl.stateTransition.totalOperationsRunning`
      replaces ``userOperationsRunning``.

.. serverstatus:: metrics.repl.syncSource

   Information on a replica set node's
   :ref:`sync source selection <replica-set-sync>` process.

.. serverstatus:: metrics.repl.syncSource.numSelections

   Number of times a node attempted to choose a node to sync from among
   the available sync source options. A node attempts to choose a node
   to sync from if, for example, the sync source is re-evaluated or the
   node receives an error from its current sync source.

.. serverstatus:: metrics.repl.syncSource.numTimesChoseSame

   Number of times a node kept its original sync source after
   re-evaluating if its current sync source was optimal.

.. serverstatus:: metrics.repl.syncSource.numTimesChoseDifferent

   Number of times a node chose a new sync source after re-evaluating if
   its current sync source was optimal.

.. serverstatus:: metrics.repl.syncSource.numTimesCouldNotFind

   Number of times a node could not find an available sync source when
   attempting to choose a node to sync from.

.. serverstatus:: metrics.repl.waiters.replication

   The number of threads waiting for replicated or journaled :ref:`write concern
   acknowledgments <wc-ack-behavior>`.

   .. versionadded:: 7.3

.. serverstatus:: metrics.repl.waiters.opTime

   The number of threads queued for local replication :term:`optime` assignments.

   .. versionadded:: 7.3

.. serverstatus:: metrics.storage.freelist.search.bucketExhausted

   The number of times that :binary:`~bin.mongod` has examined the free
   list without finding a large record allocation.

.. serverstatus:: metrics.storage.freelist.search.requests

   The number of times :binary:`~bin.mongod` has searched for available
   record allocations.

.. serverstatus:: metrics.storage.freelist.search.scanned

   The number of available record allocations :binary:`~bin.mongod` has
   searched.

.. serverstatus:: metrics.ttl

   A document that reports on the operation of the resource use of the
   :ref:`ttl index <ttl-collections>` process.

.. serverstatus:: metrics.ttl.deletedDocuments

   The total number of documents deleted from collections with a
   :ref:`ttl index <ttl-collections>`.

.. serverstatus:: metrics.ttl.passes

   The number of times the background process removes documents from
   collections with a :ref:`ttl index <ttl-collections>`.

.. _server-status-metrics-cursor:

.. serverstatus:: metrics.cursor

   A document that contains data regarding cursor state and use.

.. serverstatus:: metrics.cursor.moreThanOneBatch

   The total number of cursors that have returned more than one batch
   since the server process started. Additional batches are retrieved
   using the :dbcommand:`getMore` command.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.timedOut

   The total number of cursors that have timed out since the server
   process started. If this number is large or growing at a regular
   rate, this may indicate an application error.

.. serverstatus:: metrics.cursor.totalOpened

   The total number of cursors that have been opened since the server
   process started, including cursors currently open. Differs from
   :serverstatus:`metrics.cursor.open.total`, which is the number of
   currently open cursors only.

   .. versionadded:: 5.0

.. _server-status-metrics-cursor-lifespan:

.. serverstatus:: metrics.cursor.lifespan

   A document that reports the number of cursors that have lifespans
   within specified time periods. The cursor lifespan is the time period
   from when the cursor is created to when the cursor is killed using
   the :dbcommand:`killCursors` command or the cursor has no remaining
   objects in the :ref:`batch <cursor-batches>`.

   The lifespan time periods are:

   - < 1 second

   - >= 1 second to < 5 seconds

   - >= 5 seconds to < 15 seconds

   - >= 15 seconds to < 30 seconds

   - >= 30 seconds to < 1 minute

   - >= 1 minute to < 10 minutes

   - >= 10 minutes

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.greaterThanOrEqual10Minutes

   The number of cursors with a lifespan >= 10 minutes.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan10Minutes

   The number of cursors with a lifespan >= 1 minute to < 10 minutes.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan15Seconds

   The number of cursors with a lifespan >= 5 seconds to < 15 seconds.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan1Minute

   The number of cursors with a lifespan >= 30 seconds to < 1 minute.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan1Second

   The number of cursors with a lifespan < 1 second.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan30Seconds

   The number of cursors with a lifespan >= 15 seconds to < 30 seconds.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.lifespan.lessThan5Seconds

   The number of cursors with a lifespan >= 1 second to < 5 seconds.

   .. versionadded:: 5.0

.. serverstatus:: metrics.cursor.open

   A document that contains data regarding open cursors.

.. serverstatus:: metrics.cursor.open.noTimeout

   The number of open cursors with the option
   :data:`DBQuery.Option.noTimeout` set to prevent timeout after a
   period of inactivity.

.. serverstatus:: metrics.cursor.open.pinned

   The number of "pinned" open cursors.

.. serverstatus:: metrics.cursor.open.total

   The number of cursors that MongoDB is maintaining for clients.
   Because MongoDB exhausts unused cursors, typically this value small
   or zero. However, if there is a queue, or stale tailable cursors, or
   a large number of operations this value may increase.

.. serverstatus:: metrics.cursor.open.singleTarget

   The total number of cursors that only target a *single* shard. Only
   :binary:`~bin.mongos` instances report
   :serverstatus:`metrics.cursor.open.singleTarget` values.

.. serverstatus:: metrics.cursor.open.multiTarget

   The total number of cursors that only target *more than one* shard.
   Only :binary:`~bin.mongos` instances report
   :serverstatus:`metrics.cursor.open.multiTarget` values.

.. _server-status-mirroredReads:

mirroredReads
~~~~~~~~~~~~~

|mongod-only|

.. code-block:: javascript

   "mirroredReads" : {
         "seen" : <num>,
         "sent" : <num>
   },

.. serverstatus:: mirroredReads

   |mongod-only|

   A document that reports on :ref:`mirrored reads <mirrored-reads>`.
   To return :serverstatus:`mirroredReads` information, you must
   explicitly specify the inclusion:

   .. code-block:: javascript

      db.runCommand( { serverStatus: 1, mirroredReads: 1 } )

   .. serverstatus:: mirroredReads.processedAsSecondary

      .. versionadded:: 6.2

      The number of mirrored reads processed by this member while a secondary.

      .. seealso::

         :parameter:`mirrorReads` Parameter


   .. serverstatus:: mirroredReads.seen

      The number of :ref:`operations that support mirroring
      <mirrored-reads-supported-operations>` received by this member.

      .. seealso::

         :parameter:`mirrorReads` Parameter

   .. serverstatus:: mirroredReads.sent

      The number of mirrored reads sent by this member when primary.
      For example, if a read is mirrored and sent to two secondaries,
      the number of mirrored reads is ``2``.

      .. seealso:: 
         
         :parameter:`mirrorReads` Parameter


.. _server-status-network:

network
~~~~~~~

.. code-block:: javascript

   network : {
      bytesIn : Long("<num>"),
      bytesOut : Long("<num>"),
      physicalBytesIn : Long("<num>"),
      physicalBytesOut : Long("<num>"),
      numSlowDNSOperations : Long("<num>"),
      numSlowSSLOperations : Long("<num>"),
      numRequests : Long("<num>"),
      tcpFastOpen : {
         kernelSetting : Long("<num>"),
         serverSupported : <bool>,
         clientSupported : <bool>,
         accepted : Long("<num>")
      },
      compression : {
         snappy : {
            compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
            decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
         }, 
         zstd : { 
            compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
            decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
         },
         zlib : {
            compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
            decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
         }
      },
      serviceExecutors : {
         passthrough : {
            threadsRunning : <num>,
            clientsInTotal : <num>,
            clientsRunning : <num>,
            clientsWaitingForData : <num>
         },
         fixed : {
            threadsRunning : <num>,
            clientsInTotal : <num>,
            clientsRunning : <num>,
            clientsWaitingForData : <num>
         }
      },
      listenerProcessingTime : { durationMicros : <num> }  // Added in MongoDB 6.3
   }

.. serverstatus:: network

   A document that reports data on MongoDB's network use. These
   statistics measure *ingress connections* only, specifically the
   traffic seen by the :binary:`~bin.mongod` or :binary:`~bin.mongos`
   over network connections initiated by clients or other
   :binary:`~bin.mongod` or :binary:`~bin.mongos` instances. Traffic
   from network connections initiated by this :binary:`~bin.mongod` or
   :binary:`~bin.mongos` instance (specifically, *egress connections*)
   is *not* measured in these statistics.

.. serverstatus:: network.bytesIn

   The total number of logical bytes that the server has *received* over 
   network connections initiated by clients or other ``mongod`` or
   ``mongos`` instances. Logical bytes are the exact number of bytes
   that a given file contains.

.. serverstatus:: network.bytesOut

   The total number of logical bytes that the server has *sent* over 
   network connections initiated by clients or other ``mongod`` or
   ``mongos`` instances. Logical bytes correspond to the number of 
   bytes that a given file contains.

.. serverstatus:: network.physicalBytesIn

   The total number of physical bytes that the server has *received* 
   over network connections initiated by clients or other ``mongod`` or
   ``mongos`` instances. Physical bytes are the number of bytes that 
   actually reside on disk.

.. serverstatus:: network.physicalBytesOut

   The total number of physical bytes that the server has *sent* over 
   network connections initiated by clients or other ``mongod`` or
   ``mongos`` instances. Physical bytes are the number of bytes that 
   actually reside on disk.

.. serverstatus:: network.numSlowDNSOperations

   The total number of DNS resolution operations which took longer than
   1 second.
  
.. serverstatus:: network.numSlowSSLOperations

   The total number of SSL handshake operations which took longer than
   1 second.

.. serverstatus:: network.numRequests

   The total number of distinct requests that the server has received.
   Use this value to provide context for the
   :serverstatus:`network.bytesIn` and :serverstatus:`network.bytesOut`
   values to ensure that MongoDB's network utilization is consistent
   with expectations and application use.

.. serverstatus:: network.tcpFastOpen

   A document that reports data on MongoDB's support and use of 
   TCP Fast Open (TFO) connections.

.. serverstatus:: network.tcpFastOpen.kernelSetting

   *Linux only* 

   Returns the value of ``/proc/sys/net/ipv4/tcp_fastopen``:

   - ``0`` - TCP Fast Open is disabled on the system.

   - ``1`` - TCP Fast Open is enabled for outgoing connections.

   - ``2`` - TCP Fast Open is enabled for incoming connections.

   - ``3`` - TCP Fast Open is enabled for incoming and outgoing 
     connections. 

.. serverstatus:: network.tcpFastOpen.serverSupported

   - Returns ``true`` if the host operating system supports inbound
     TCP Fast Open (TFO) connections.

   - Returns ``false`` if the host operating system does *not* support
     inbound TCP Fast Open (TFO) connections.

.. serverstatus:: network.tcpFastOpen.clientSupported

   - Returns ``true`` if the host operating system supports outbound
     TCP Fast Open (TFO) connections.

   - Returns ``false`` if the host operating system does *not* support
     outbound TCP Fast Open (TFO) connections.

.. serverstatus:: network.tcpFastOpen.accepted

   The total number of accepted incoming TCP Fast Open (TFO) connections
   to the :binary:`~bin.mongod` or :binary:`~bin.mongos` since the 
   ``mongod`` or ``mongos`` last started.

.. serverstatus:: network.compression

   A document that reports on the amount of data compressed and decompressed by 
   each network compressor library.

.. serverstatus:: network.compression.snappy 

   A document that returns statistics on the number of bytes that have been 
   compressed and decompressed with the :term:`snappy` library.

.. serverstatus:: network.compression.zstd

   A document that returns statistics on the number of bytes that have been 
   compressed and decompressed with the :term:`zstd` library.

.. serverstatus:: network.compression.zlib 

   A document that returns statistics on the number of bytes that have been 
   compressed and decompressed with the :term:`zlib` library.

.. serverstatus:: network.serviceExecutors

   .. versionadded:: 5.0

   A document that reports data on the service executors, which run
   operations for client requests.

.. serverstatus:: network.serviceExecutors.passthrough

   .. versionadded:: 5.0

   A document that reports data about the threads and clients for the
   ``passthrough`` service executor. The ``passthrough`` service
   executor creates a new thread for each client and destroys the thread
   after the client ends.

.. serverstatus:: network.serviceExecutors.passthrough.threadsRunning

   .. versionadded:: 5.0

   Number of threads running in the ``passthrough`` service executor.

.. serverstatus:: network.serviceExecutors.passthrough.clientsInTotal

   .. versionadded:: 5.0

   Total number of clients allocated to the ``passthrough`` service
   executor. A client can be allocated to the ``passthrough`` service
   executor and not currently running requests.

.. serverstatus:: network.serviceExecutors.passthrough.clientsRunning

   .. versionadded:: 5.0

   Number of clients currently using the ``passthrough`` service
   executor to run requests.

.. serverstatus:: network.serviceExecutors.passthrough.clientsWaitingForData

   .. versionadded:: 5.0

   Number of clients using the ``passthrough`` service executor that are
   waiting for incoming data from the network.

.. serverstatus:: network.serviceExecutors.fixed

   .. versionadded:: 5.0

   A document that reports data about the threads and clients for the
   ``fixed`` service executor. The ``fixed`` service executor has a
   fixed number of threads. A thread is temporarily assigned to a client
   and the thread is preserved after the client ends.

.. serverstatus:: network.serviceExecutors.fixed.threadsRunning

   .. versionadded:: 5.0

   Number of threads running in the ``fixed`` service executor.

.. serverstatus:: network.serviceExecutors.fixed.clientsInTotal

   .. versionadded:: 5.0

   Total number of clients allocated to the ``fixed`` service executor.
   A client can be allocated to the ``fixed`` service executor and not
   currently running requests.

.. serverstatus:: network.serviceExecutors.fixed.clientsRunning

   .. versionadded:: 5.0

   Number of clients currently using the ``fixed`` service executor to
   run requests.

.. serverstatus:: network.serviceExecutors.fixed.clientsWaitingForData

   .. versionadded:: 5.0

   Number of clients using the ``fixed`` service executor that are
   waiting for incoming data from the network.

.. serverstatus:: network.listenerProcessingTime

   .. versionadded:: 6.3

   A document that reports the total time the database listener spends
   allocating incoming database connection requests to dedicated
   threads.

.. serverstatus:: network.listenerProcessingTime.durationMicros

   .. versionadded:: 6.3

   Total time in microseconds the database listener spends allocating
   incoming database connection requests to dedicated threads that
   perform database operations.

opLatencies
~~~~~~~~~~~

.. code-block:: javascript

   opLatencies : {
      reads : <document>,
      writes : <document>,
      commands : <document>,
      transactions : <document>
   },

.. serverstatus:: opLatencies

   A document containing operation latencies for the instance as a whole.
   See :ref:`latency-stats-document` for an description of this document.

   Starting in MongoDB 6.2, the :serverstatus:`~opLatencies` metric 
   reports for both :binary:`~bin.mongod` and :binary:`~bin.mongos` 
   instances. Latencies reported by ``mongos`` include operation latency
   time and communication time between the ``mongod`` and ``mongos`` 
   instances.

.. serverstatus:: opLatencies.reads

   Latency statistics for read requests.

.. serverstatus:: opLatencies.writes

   Latency statistics for write operations.

.. serverstatus:: opLatencies.commands

   Latency statistics for database commands.

.. serverstatus:: opLatencies.transactions

   Latency statistics for database transactions.

.. _server-status-opReadConcernCounters:

opReadConcernCounters
~~~~~~~~~~~~~~~~~~~~~

.. warning:: Removed

   Starting in version 5.0, :serverstatus:`opReadConcernCounters` is
   replaced by :serverstatus:`readConcernCounters`.

*Only for mongod instances*

.. code-block:: javascript

   opReadConcernCounters : {
      available : Long("<num>"),
      linearizable : Long("<num>"),
      local : Long("<num>"),
      majority : Long("<num>"),
      snapshot : Long("<num>"),
      none : Long("<num>")
   }

.. serverstatus:: opReadConcernCounters

   *Removed in version 5.0*. Replaced by
   :serverstatus:`readConcernCounters`.

   A document that reports on the :ref:`read concern level
   <read-concern-levels>` specified by query operations to the
   :binary:`~bin.mongod` instance since it last started.

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Specified ``w``
        - Description

      * - ``"available"``

        - Number of query operations that specified read concern level
          :readconcern:`"available"`.

      * - ``"linearizable"``

        - Number of query operations that specified read concern level
          :readconcern:`"linearizable"`.

      * - ``"local"``

        - Number of query operations that specified read
          concern level :readconcern:`"local"`.

      * - ``"majority"``

        - Number of query operations that specified read
          concern level :readconcern:`"majority"`.

      * - ``"snapshot"``

        - Number of query operations that specified read
          concern level :readconcern:`"snapshot"`.

      * - ``"none"``

        - Number of query operations that did not specify a read
          concern level and instead used the default :ref:`read concern level
          <read-concern-levels>`.

   The sum of the :serverstatus:`opReadConcernCounters` equals
   :serverstatus:`opcounters.query`.

.. _server-status-opWriteConcernCounters:

opWriteConcernCounters
~~~~~~~~~~~~~~~~~~~~~~~

*Only for mongod instances*

.. code-block:: javascript

   opWriteConcernCounters : {
      insert : {
         wmajority : Long("<num>"),
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               },
               wtag : {
                  <tag1> :  Long("<num>"),
                  ...
               }
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               }
            }
         }
      },
      update : {
         wmajority : Long("<num>"),
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               }
               wtag : {
                  <tag1> :  Long("<num>"),
                  ...
               }
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               }
            }
         }
      },
      delete : {
         wmajority :  Long("<num>")
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               },
               wtag : {
                  <tag1> :  Long("<num>"),
                  ...
               }
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {
                  <num> :  Long("<num>"),
                  ...
               }
            }
         }
      }
   }

.. serverstatus:: opWriteConcernCounters

   A document that reports on the :doc:`write concerns
   </reference/write-concern>` specified by write operations to the
   :binary:`~bin.mongod` instance since it last started.

   More specifically, the :serverstatus:`opWriteConcernCounters`
   reports on the :ref:`w: \<value\> <wc-w>` specified by the write
   operations. The journal flag option (``j``) and the timeout option
   (``wtimeout``) of the write concerns does not affect the count. The
   count is incremented even if the operation times out.

   .. note::

      .. include:: /includes/extracts/serverStatus-opWriteConcernCounters.rst

.. serverstatus:: opWriteConcernCounters.insert

   A document that reports on the :ref:`w: \<value\> <wc-w>` specified
   by insert operations to the :binary:`~bin.mongod` instance since it
   last started:

   .. note::

      .. include:: /includes/extracts/serverStatus-opWriteConcernCounters.rst

   .. code-block:: javascript

      insert : {
         wmajority : Long("<num>"),
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {},
               wtag : {}
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {}
            }
         }
      },

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Specified ``w``
        - Description

      * - ``"wmajority"``

        - Number of insert operations that specified
          :writeconcern:`w: "majority" <"majority">`.

      * - ``"wnum"``

        - Number of insert operations that specified
          :writeconcern:`w: \<num\> <\<number\>>`. The counts are
          grouped by the specific``<num>``.

      * - ``"wtag"``

        - Number of insert operations that specified
          :writeconcern:`w: \<tag\> <\<custom write concern name\>>`.
          The counts are grouped by the specific ``<tag>``.

      * - ``"none"``

        - Number of insert operations that did not specify ``w`` value.
          These operations use the default ``w`` value of 
          :ref:`"majority" <wc-default-behavior>`.

      * - ``"noneInfo"``
        - .. include:: /includes/serverStatus/details-noneInfo.rst

   The sum of the :serverstatus:`opWriteConcernCounters.insert` equals
   :serverstatus:`opcounters.insert`.

.. serverstatus:: opWriteConcernCounters.update

   A document that reports on the :ref:`w: \<value\> <wc-w>` specified
   by update operations to the :binary:`~bin.mongod` instance since it
   last started:

   .. note::

      .. include:: /includes/extracts/serverStatus-opWriteConcernCounters.rst

   .. code-block:: javascript

      update : {
         wmajority : Long("<num>"),
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {},
               wtag : {}
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {}
            }
         }
      },

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Specified ``w``
        - Description

      * - ``"wmajority"``

        - Number of update operations that specified
          :writeconcern:`w: "majority" <"majority">`.

      * - ``"wnum"``

        - Number of update operations that specified
          :writeconcern:`w: \<num\> <\<number\>>`. The counts are
          grouped by the specific ``<num>``.

      * - ``"wtag"``

        - Number of update operations that specified
          :writeconcern:`w: \<tag\> <\<custom write concern name\>>`.
          The counts are grouped by the specific ``<tag>``.

      * - ``"none"``

        - Number of update operations that did not specify ``w`` value.
          These operations use the default ``w`` value of ``1``.

      * - ``"noneInfo"``
        - .. include:: /includes/serverStatus/details-noneInfo.rst

   The sum of the :serverstatus:`opWriteConcernCounters.update` equals
   :serverstatus:`opcounters.update`.

.. serverstatus:: opWriteConcernCounters.delete

   A document that reports on the :ref:`w: \<value\> <wc-w>` specified
   by delete operations to the :binary:`~bin.mongod` instance since it
   last started:

   .. note::

      .. include:: /includes/extracts/serverStatus-opWriteConcernCounters.rst

   .. code-block:: javascript

      delete : {
         wmajority :  Long("<num>"),
         wnum : {
            <num> :  Long("<num>"),
            ...
         },
         wtag : {
            <tag1> :  Long("<num>"),
            ...
         },
         none : Long("<num>"),
         noneInfo : {
            CWWC : {
               wmajority : Long("<num>"),
               wnum : {},
               wtag : {}
            },
            implicitDefault : {
               wmajority : Long("<num>")
               wnum : {}
            }
         }
      }

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Specified ``w``
        - Description

      * - ``"wmajority"``

        - Number of delete operations that specified
          :writeconcern:`w: "majority" <"majority">`.

      * - ``"wnum"``

        - Number of delete operations that specified
          :writeconcern:`w: \<num\> <\<number\>>`. The counts are
          grouped by the specific ``<num>``.

      * - ``"wtag"``

        - Number of delete operations that specified
          :writeconcern:`w: \<tag\> <\<custom write concern name\>>`.
          The counts are grouped by the specific ``<tag>``.

      * - ``"none"``

        - Number of delete operations that did not specify ``w`` value.
          These operations use the default ``w`` value of ``1``.

      * - ``"noneInfo"``
        - .. include:: /includes/serverStatus/details-noneInfo.rst

   The sum of the :serverstatus:`opWriteConcernCounters.delete` equals
   :serverstatus:`opcounters.delete`.

.. _server-status-opcounters:

opcounters
~~~~~~~~~~



.. code-block:: javascript

   opcounters : {
      insert : Long("<num>"), 
      query : Long("<num>"),  
      update : Long("<num>"),  
      delete : Long("<num>"),  
      getmore : Long("<num>"), 
      command : Long("<num>"), 
   },

.. serverstatus:: opcounters

   A document that reports on database operations by type since the
   :binary:`~bin.mongod` instance last started.

   These numbers will grow over time until next restart. Analyze these
   values over time to track database utilization.

   .. note::

      The data in :serverstatus:`opcounters` treats operations
      that affect multiple documents, such as bulk insert or
      multi-update operations, as a single operation. See
      :serverstatus:`metrics.document` for more granular
      document-level operation tracking.

      Additionally, these values reflect received operations, and
      increment even when operations are not successful.

.. serverstatus:: opcounters.insert

   The total number of insert operations received since the
   :binary:`~bin.mongod` instance last started.

.. serverstatus:: opcounters.query

   The total number of queries received since the :binary:`~bin.mongod`
   instance last started. Starting in MongoDB 7.1, aggregations 
   count as query operations and increment this value.

.. serverstatus:: opcounters.update

   The total number of update operations received since the
   :binary:`~bin.mongod` instance last started.

.. serverstatus:: opcounters.delete

   The total number of delete operations since the :binary:`~bin.mongod`
   instance last started.

.. serverstatus:: opcounters.getmore

   The total number of :dbcommand:`getMore` operations since the
   :binary:`~bin.mongod` instance last started. This counter can be high
   even if the query count is low. Secondary nodes send
   :dbcommand:`getMore` operations as part of the replication process.

.. serverstatus:: opcounters.command

   The total number of commands issued to the database since the
   :binary:`~bin.mongod` instance last started.

   :serverstatus:`opcounters.command` counts all :ref:`commands
   <database-commands>` **except** the following:
   
   - :dbcommand:`insert`
   - :dbcommand:`update`
   - :dbcommand:`delete`
   - :dbcommand:`aggregate`

.. serverstatus:: opcounters.deprecated

   ``opQuery`` counts the number of requests for opcodes that are
   deprecated in MongoDB 5.0 but are temporarily supported. This section
   only appears in the ``db.serverStatus()`` output when a deprecated
   opcode has been used. 

   The counter is reset when ``mongod`` starts.

   .. code-block:: javascript

      deprecated: {
         opQuery: Long("<num>"),
      }

.. _server-status-opcountersrepl:
.. _server-status-opcounters-repl:

opcountersRepl
~~~~~~~~~~~~~~

.. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. code-block:: javascript

   opcountersRepl : {
      insert : Long("<num>"),  
      query : Long("<num>"),   
      update : Long("<num>"), 
      delete : Long("<num>"), 
      getmore : Long("<num>"), 
      command : Long("<num>"), 
   },

.. serverstatus:: opcountersRepl

   A document that reports on database replication operations by type
   since the :binary:`~bin.mongod` instance last started.

   These values only appear when the current host is a member of a
   replica set.

   These values will differ from the :serverstatus:`opcounters` values
   because of how MongoDB serializes operations during replication.
   See :doc:`/replication` for more information on replication.

   These numbers will grow over time in response to database use until
   next restart. Analyze these values over time to track database
   utilization.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.insert

   The total number of replicated insert operations since the
   :binary:`~bin.mongod` instance last started.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.query

   The total number of replicated queries since the :binary:`~bin.mongod`
   instance last started.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.update

   The total number of replicated update operations since the
   :binary:`~bin.mongod` instance last started.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.delete

   The total number of replicated delete operations since the
   :binary:`~bin.mongod` instance last started.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.getmore

   The total number of :dbcommand:`getMore` operations since the
   :binary:`~bin.mongod` instance last started. This counter can be high
   even if the query count is low. Secondary nodes send
   :dbcommand:`getMore` operations as part of the replication process.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst

.. serverstatus:: opcountersRepl.command

   The total number of replicated commands issued to the database since
   the :binary:`~bin.mongod` instance last started.

   .. include:: /includes/extracts/4.2-changes-opcountersRepl-type.rst


.. _server-status-oplogTruncation:

oplogTruncation
~~~~~~~~~~~~~~~

.. code-block:: javascript

   oplogTruncation : {
      totalTimeProcessingMicros : Long("<num>"),
      processingMethod : <string>,
      oplogMinRetentionHours : <double>
      totalTimeTruncatingMicros : Long("<num>"),
      truncateCount : Long("<num>")
   },

.. serverstatus:: oplogTruncation

   A document that reports on :ref:`oplog <replica-set-oplog>`
   truncations.

   The field only appears when the current instance is a member of a
   replica set and uses either the :doc:`/core/wiredtiger` or
   :doc:`/core/inmemory`.

   Available in the :doc:`/core/wiredtiger`.

.. serverstatus:: oplogTruncation.totalTimeProcessingMicros

   The total time taken, in microseconds, to scan or sample the oplog
   to determine the oplog truncation points.

   :serverstatus:`~oplogTruncation.totalTimeProcessingMicros` is only
   meaningful if the :binary:`~bin.mongod` instance started on existing
   data files (i.e. not meaningful for :doc:`/core/inmemory`).

   See :serverstatus:`oplogTruncation.processingMethod`

   Available in the :doc:`/core/wiredtiger`.

.. serverstatus:: oplogTruncation.processingMethod

   The method used at start up to determine the oplog truncation points.
   The value can be either ``"sampling"`` or ``"scanning"``.

   :serverstatus:`~oplogTruncation.processingMethod` is only meaningful
   if the :binary:`~bin.mongod` instance started on existing data files
   (i.e. not meaningful for :doc:`/core/inmemory`).

   Available in the :doc:`/core/wiredtiger`.

.. serverstatus:: oplogTruncation.oplogMinRetentionHours

   The minimum retention period for the oplog in hours. If the oplog
   has exceeded the oplog size, the :binary:`~bin.mongod` only
   truncates oplog entries older than the configured retention
   value.

   Only visible if the :binary:`~bin.mongod` is a member of a replica
   set *and*:

   - The :binary:`~bin.mongod` was started with the
     :option:`--oplogMinRetentionHours
     <mongod --oplogMinRetentionHours>` command line option *or* the 
     :setting:`storage.oplogMinRetentionHours` configuration file 
     option,

     *or*

   - The minimum retention period was configured after startup using
     :dbcommand:`replSetResizeOplog`.

.. serverstatus:: oplogTruncation.totalTimeTruncatingMicros

   The cumulative time spent, in microseconds, performing oplog truncations.

   Available in the :doc:`/core/wiredtiger`.

.. serverstatus:: oplogTruncation.truncateCount


   The cumulative number of oplog truncations.

   Available in the :doc:`/core/wiredtiger`.

.. _server-status-planCache:

planCache
~~~~~~~~~

.. versionadded:: 7.0

.. code-block:: javascript

   planCache : {
      totalQueryShapes : Long("<num>"),
      totalSizeEstimateBytes : Long("<num>"),
      classic : { 
         hits : Long("<num>"), 
         misses : Long("<num>"),
         skipped : Long("<num>") 
      },
      sbe : { 
         hits : Long("<num>"), 
         misses: Long("<num>"),
         skipped : Long("<num>")  
      }
   }

.. serverstatus:: planCache

   A document that reports query plan cache statistics.

.. serverstatus:: planCache.totalQueryShapes
      
   Approximate number of :term:`plan cache query shapes <plan cache query shape>`

   Prior to version 7.2, information on the number of plan cache query shapes was stored in 
   the ``query.planCacheTotalQueryShapes`` field.

   .. versionadded:: 7.2

.. serverstatus:: planCache.totalSizeEstimateBytes

   Total size of the plan cache in bytes.

   Prior to version 7.2, information on the plan cache size was stored in the  
   ``query.planCacheTotalSizeEstimateBytes`` field.


   .. versionadded:: 7.2

.. serverstatus:: planCache.classic.hits

   Number of classic execution engine query plans found in the query 
   cache and reused to avoid the query planning phase.

.. serverstatus:: planCache.classic.misses

   Number of classic execution engine query plans which were not found 
   in the query cache and went through the query planning phase.

.. serverstatus:: planCache.classic.skipped

   Number of classic execution engine query plans that were not found in the 
   query cache because the query is ineligible for caching.

   .. versionadded:: 7.3

.. serverstatus:: planCache.sbe.hits

   Number of |sbe-short| query plans found in the query 
   cache and reused to avoid the query planning phase.

.. serverstatus:: planCache.sbe.misses

   Number of |sbe-short| plans which were not found 
   in the query cache and went through the query planning phase.

.. serverstatus:: planCache.sbe.skipped

   Number of |sbe-short| query plans that were not found in the 
   query cache because the query is ineligible for caching.

   .. versionadded:: 7.3

.. _server-status-queryStats:

queryStats
~~~~~~~~~~

.. versionadded:: 7.1

.. code-block:: javascript

   queryStats: {
      numEvicted: Long("<num>"),
      numRateLimitedRequests: Long("<num>"),
      queryStatsStoreSizeEstimateBytes: Long("<num>"),
      numQueryStatsStoreWriteErrors: Long("<num>"),
      numHmacApplicationErrors: Long("<num>")
   },

.. serverstatus:: queryStats

   A document that contains metrics for the :pipeline:`$queryStats`
   aggregation stage.

.. serverstatus:: queryStats.numEvicted

   Number of queries that the ``$queryStats`` virtual collection has
   evicted due to space contraints.

.. serverstatus:: queryStats.numRateLimitedRequests

   Number of times that query stats were not recorded for a query due to
   rate limiting.

.. serverstatus:: queryStats.queryStatsStoreSizeEstimateBytes

   Current estimated size of objects in the ``$queryStats`` virtual
   collection.

.. serverstatus:: queryStats.numQueryStatsStoreWriteErrors

   Number of times this MongoDB process failed to store a new query
   stats key. Generally, these failures happen when the
   ``$queryStats`` virtual collection runs out of space.

.. serverstatus:: queryStats.numHmacApplicationErrors

   Number of times this MongoDB process failed to compute a one-way
   tokenized query stats key when ``$queryStats`` was called with the
   ``transformIdentifiers`` option.

.. _server-status-queryAnalyzers:                                       
                                                                        
queryAnalyzers                                  
~~~~~~~~~~~~~~

.. versionadded:: 7.0                                                   
                                                                        
.. code-block:: javascript                                              
                                                                        
   queryAnalyzers: {                                                    
     activeCollections: <integer>,
     totalCollections: <integer>,
     totalSampledReadsCount: <integer>,
     totalSampledWritesCount: <integer>,
     totalSampledReadsBytes: <integer>,
     totalSampledWritesBytes: <integer>
   }

.. serverstatus:: queryAnalyzers.activeCollections

   Number of collections the :ref:`query analyzer 
   <configureQueryAnalyzer>` actively samples.           
                                                                        
.. serverstatus:: queryAnalyzers.totalCollections
  
   Total number of sampled collections.

.. serverstatus:: queryAnalyzers.totalSampledReadsCount

   Total number of sampled read queries.

.. serverstatus:: queryAnalyzers.totalSampledWritesCount

   Total number of sampled write queries.

.. serverstatus:: queryAnalyzers.totalSampledReadsBytes
   
   Total size of sampled read queries, in bytes. This metric is
   only available when running ``serverStatus`` on ``mongod``.

.. serverstatus:: queryAnalyzers.totalSampledWritesBytes
   
   Total size of sampled write queries, in bytes. This metric is 
   only available when running ``serverStatus`` on ``mongod``.


.. _server-status-querySettings:

querySettings
~~~~~~~~~~~~~

.. versionadded:: 8.0

.. code-block:: javascript

   querySettings: {
     count: <num>,
     rejectCount: <num>,
     size: <num>,
     RejectedQueriesCount: <num>
   }

.. serverstatus:: querySettings

   Document with configuration counts and usage for query settings.

   .. include:: /includes/persistent-query-settings-avoid-index-filters-intro.rst

.. serverstatus:: querySettings.count

   Total number of query settings.

.. serverstatus:: querySettings.rejectCount

   Total number of query settings that have the ``reject`` field set to
   ``true``. To set the ``reject`` field, use ``setQuerySettings``.

.. serverstatus:: querySettings.size

   Total size in bytes for query settings.

.. serverstatus:: querySettings.RejectedQueriesCount

  Total number of queries that were rejected because of the operation
  rejection filters.

.. _server-status-readConcernCounters:

readConcernCounters
~~~~~~~~~~~~~~~~~~~

.. versionadded:: 5.0

.. code-block:: javascript

   readConcernCounters : {
      nonTransactionOps : {
         none : Long("<num>"),
         noneInfo : {
            CWRC : {
               local : Long("<num>"),
               available : Long("<num>"),
               majority : Long("<num>")
            },
            implicitDefault : {
               local : Long("<num>"),
               available : Long("<num>")
            }
         },
         local : Long("<num>"),
         available : Long("<num>"),
         majority : Long("<num>"),
         snapshot : {
            withClusterTime : Long("<num>"),
            withoutClusterTime : Long("<num>")
         },
         linearizable : Long("<num>")
      },
      transactionOps : {
         none : Long("<num>"),
         noneInfo : {
            CWRC : {
               local : Long("<num>"),
               available : Long("<num>"),
               majority : Long("<num>")
            },
            implicitDefault : {
               local : Long("<num>"),
               available : Long("<num>")
            }
         },
         local : Long("<num>"),
         majority : Long("<num>"),
         snapshot : {
            withClusterTime : Long("<num>"),
            withoutClusterTime : Long("<num>")
         }
      }
   },

.. serverstatus:: readConcernCounters

   A document that reports on the :ref:`read concern level
   <read-concern-levels>` specified by query operations. This document
   contains the :serverstatus:`readConcernCounters.nonTransactionOps`
   and :serverstatus:`readConcernCounters.transactionOps` documents.

.. serverstatus:: readConcernCounters.nonTransactionOps

   A document that reports on the :ref:`read concern level
   <read-concern-levels>` specified by non-transaction query operations
   performed after the database server last started.

.. serverstatus:: readConcernCounters.nonTransactionOps.none

   Number of non-transaction query operations that did not specify a
   read concern level and instead used either:
   
   - the default :ref:`read  concern level <read-concern-levels>`, or
   - the global default read concern configuration if it was set by the
     :dbcommand:`setDefaultRWConcern` command.

.. serverstatus:: readConcernCounters.nonTransactionOps.noneInfo

   The number of non-transaction query operations that use the global
   default read concern and an implicit-default read concern.
   
   The sum of the values in
   ``readConcernCounters.nonTransactionOps.noneInfo`` should equal the
   value of ``readConcernCounters.nonTransactionOps.none``.

.. serverstatus:: readConcernCounters.nonTransactionOps.local

   Number of non-transaction query operations that specified the
   :readconcern:`"local"` read concern level.

.. serverstatus:: readConcernCounters.nonTransactionOps.available

   Number of non-transaction query operations that specified the
   :readconcern:`"available"` read concern level.

.. serverstatus:: readConcernCounters.nonTransactionOps.majority

   Number of non-transaction query operations that specified the
   :readconcern:`"majority"` read concern level.

.. serverstatus:: readConcernCounters.nonTransactionOps.snapshot

   Document containing non-transaction query operations that specified
   the :readconcern:`"snapshot"` read concern level.

.. serverstatus:: readConcernCounters.nonTransactionOps.snapshot.withClusterTime

   Number of non-transaction query operations that specified the
   :readconcern:`"snapshot"` read concern level and the cluster time,
   which specified a point in time.

.. serverstatus:: readConcernCounters.nonTransactionOps.snapshot.withoutClusterTime

   Number of non-transaction query operations that specified the
   :readconcern:`"snapshot"` read concern level without the cluster
   time, which means a point in time was omitted and the server will
   read the most recently committed snapshot available to the node.

.. serverstatus:: readConcernCounters.nonTransactionOps.linearizable

   Number of non-transaction query operations that specified the
   :readconcern:`"linearizable"` read concern level.

.. serverstatus:: readConcernCounters.transactionOps

   A document that reports on the :ref:`read concern level
   <read-concern-levels>` specified by transaction query operations
   performed after the database server last started.

.. serverstatus:: readConcernCounters.transactionOps.none

   Number of transaction query operations that did not specify a
   read concern level and instead used the default :ref:`read concern
   level <read-concern-levels>` or the global default read or write
   concern configuration added with the :dbcommand:`setDefaultRWConcern`
   command.

.. serverstatus:: readConcernCounters.transactionOps.noneInfo

   Information about the global default read concern and
   implicit-default read concern used by transaction query operations.

.. serverstatus:: readConcernCounters.transactionOps.local

   Number of transaction query operations that specified the
   :readconcern:`"local"` read concern level.

.. serverstatus:: readConcernCounters.transactionOps.available

   Number of transaction query operations that specified the
   :readconcern:`"available"` read concern level.

.. serverstatus:: readConcernCounters.transactionOps.majority

   Number of transaction query operations that specified the
   :readconcern:`"majority"` read concern level.

.. serverstatus:: readConcernCounters.transactionOps.snapshot

   Document containing transaction query operations that specified the
   :readconcern:`"snapshot"` read concern level.

.. serverstatus:: readConcernCounters.transactionOps.snapshot.withClusterTime

   Number of transaction query operations that specified the
   :readconcern:`"snapshot"` read concern level and the cluster time,
   which specified a point in time.

.. serverstatus:: readConcernCounters.transactionOps.snapshot.withoutClusterTime

   Number of transaction query operations that specified the
   :readconcern:`"snapshot"` read concern level without the cluster
   time, which means a point in time was omitted and the server will
   read the most recently committed snapshot available to the node.

.. _server-status-readPreferenceCounters:

readPreferenceCounters
~~~~~~~~~~~~~~~~~~~~~~

*Available starting in MongoDB 7.2 (and 7.0.3, 6.0.11).*

|mongod-only|

.. code-block:: javascript

   readPreferenceCounters : {
      executedOnPrimary : { 
         primary : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }, 
         primaryPreferred : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }, 
         secondary : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         secondaryPreferred : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         nearest : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         tagged : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }
      },
      executedOnSecondary : { 
         primary : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }, 
         primaryPreferred : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }, 
         secondary : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         secondaryPreferred : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         nearest : {
            internal : Long("<num>"),
            external : Long("<num>") 
         },
         tagged : {
            internal : Long("<num>"),
            external : Long("<num>") 
         }
      }
   }

.. serverstatus:: readPreferenceCounters

   |mongod-only|

   A document that reports the number of operations received by this 
   :binary:`~bin.mongod` node with the specified 
   :ref:`read preference <read-pref-summary>`.

   The ``tagged`` sub-field refers to any read preference passed in 
   with a :ref:`tag <replica-set-read-preference-tag-sets>`.

.. serverstatus:: readPreferenceCounters.executedOnPrimary 

   |mongod-only|

   A document that counts how many internal and external read preference 
   operations the node received while serving as the primary.

.. serverstatus:: readPreferenceCounters.executedOnSecondary

   |mongod-only|

   A document that counts how many internal and external read preference 
   operations the node received while serving as a secondary.

.. _server-status-repl:

repl
~~~~

.. code-block:: javascript

   repl : {
      hosts : [
            <string>,
            <string>,
            <string>
      ],
      setName : <string>,
      setVersion : <num>,
      isWritablePrimary : <boolean>,
      secondary : <boolean>,
      primary : <hostname>,
      me : <hostname>,
      electionId : ObjectId(""),
      primaryOnlyServices: {
         ReshardingRecipientService: { state: <string>, numInstances: <num> },
         RenameCollectionParticipantService: { state: <string>, numInstances: <num> },
         ShardingDDLCoordinator: { state: <string>, numInstances: <num> },
         ReshardingDonorService: { state: <string>, numInstances: <num> }
      },
      rbid : <num>,
      replicationProgress : [
            {
               rid : <ObjectId>,
               optime : { ts: <timestamp>, term: <num> },
               host : <hostname>,
               memberId : <num>
            },
           ...
      ]
   }

.. serverstatus:: repl

   A document that reports on the replica set configuration.
   :serverstatus:`repl` only appear when the current host is a replica
   set. See :doc:`/replication` for more information on replication.

.. serverstatus:: repl.hosts

   An array of the current replica set members' hostname and port
   information (``"host:port"``).

.. serverstatus:: repl.setName

   A string with the name of the current replica set. This value
   reflects the :option:`--replSet <mongod --replSet>` command line
   argument, or :setting:`~replication.replSetName` value in the
   configuration file.

.. serverstatus:: repl.isWritablePrimary

   A boolean that indicates whether the current node is the
   :term:`primary` of the replica set.

.. serverstatus:: repl.secondary

   A boolean that indicates whether the current node is a
   :term:`secondary` member of the replica set.

.. serverstatus:: repl.primary

   The hostname and port information (``"host:port"``) of the current
   :term:`primary` member of the replica set.

.. serverstatus:: repl.me

    The hostname and port information (``"host:port"``) for the current
    member of the replica set.

.. serverstatus:: repl.primaryOnlyServices

   Document that contains the number and status of 
   instances of each primary service active on the server. Primary 
   services can only start when a server is primary but can continue running to 
   completion after the server changes state.
   
   .. versionadded:: 5.0

.. serverstatus:: repl.primaryOnlyServices.ReshardingRecipientService

   Document that contains the state and number of instances of the
   ``ReshardingRecipientService``.

   Recipients are the shards,that would own the chunks after as a 
   result of the resharding operation, according to the new 
   :manual:`shard key</core/sharding-shard-key/>` and 
   :manual:`zones</core/zone-sharding/>`.

   The resharding coordinator instructs each donor and recipient shard 
   primary, to rename the temporary sharded collection.
   The temporary collection becomes the new resharded collection.

   .. versionadded:: 5.0

.. serverstatus:: repl.primaryOnlyServices.RenameCollectionParticipantService

   Document that contains the state and number of instances of the
   ``RenameCollectionParticipantService``.

   The ``RenameCollectionParticipantService`` ensures that, after a shard 
   receives a 
   :manual:`renameCollection</reference/method/db.collection.renameCollection/>`
   request, the shard is able to resume the local rename in case of 
   system failure.

   .. versionadded:: 5.0

.. serverstatus:: repl.primaryOnlyServices.ShardingDDLCoordinator

   Document that contains the state and number of instances of the
   ``ShardingDDLCoordinator``.

   The ``ShardingDDLCoordinator`` service manages DDL operations for 
   :manual:`primary</core/replica-set-members/#std-label-replica-set-primary-member>`
   databases such as:
   :manual:`create database</core/databases-and-collections/#create-a-database>`,
   :manual:`drop database</reference/method/db.dropDatabase/>`,
   :manual:`renameCollection</reference/method/db.collection.renameCollection>`. 
   
   The ``ShardingDDLCoordinator`` ensures that one DDL operation for
   each database can happen at any one specific point in time within a 
   sharded cluster. 

   .. versionadded:: 5.0

.. serverstatus:: repl.primaryOnlyServices.ReshardingDonorService

   Document that contains the state and number of instances of the
   ``ReshardingDonorService``.

   Donors are the shards that own chunks of the sharded collection
   before the rename operation completes.

   The resharding coordinator instructs each donor and recipient shard 
   primary, to rename the temporary sharded collection.
   The temporary collection becomes the new resharded collection.

   .. versionadded:: 5.0

.. serverstatus:: repl.rbid

   :term:`Rollback <rollback>` identifier. Used to determine if a rollback has
   happened for this :binary:`~bin.mongod` instance.

.. serverstatus:: repl.replicationProgress

   An array with one document for each member of the replica set that
   reports replication process to this member. Typically this is the
   primary, or secondaries if using chained replication.

   To include this output, you must pass the ``repl`` option to the
   :dbcommand:`serverStatus`, as in the following:

   .. code-block:: javascript

      db.serverStatus({ "repl": 1 })
      db.runCommand({ "serverStatus": 1, "repl": 1 })

   The content of the :serverstatus:`repl.replicationProgress` section
   depends on the source of each member's replication. This section
   supports internal operation and is for internal and diagnostic use only.

.. serverstatus:: repl.replicationProgress[n].rid

   An ObjectId used as an ID for the members of the replica
   set. For internal use only.

.. serverstatus:: repl.replicationProgress[n].optime

   Information regarding the last operation from the :term:`oplog` that
   the member applied, as reported from this member.

.. serverstatus:: repl.replicationProgress[n].host

   The name of the host in ``[hostname]:[port]`` format for the member
   of the replica set.

.. serverstatus:: repl.replicationProgress[n].memberID

   The integer identifier for this member of the replica set.

.. _server-status-security:

security
~~~~~~~~

.. code-block:: javascript

   security : {
      authentication : {
         saslSupportedMechsReceived : <num>,
         mechanisms : {
            MONGODB-X509 : {
               speculativeAuthenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               },
               authenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               }
            },
            SCRAM-SHA-1 : {
               speculativeAuthenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               },
               authenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               }
            },
            SCRAM-SHA-256 : {
               speculativeAuthenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               },
               authenticate : {
                  received : Long("<num>"),
                  successful : Long("<num>")
               }
             }
          }
        },
        SSLServerSubjectName: <string>,
        SSLServerHasCertificateAuthority: <boolean>,
        SSLServerCertificateExpirationDate: <date>
   },

.. serverstatus:: security

   A document that reports on:

   - The number of times a given authentication mechanism has been used
     to authenticate against the :binary:`~bin.mongod` or
     :binary:`~bin.mongos` instance.

   - The :binary:`mongod` / :binary:`mongos` instance's TLS/SSL
     certificate. (Only appears for :binary:`~bin.mongod` or
     :binary:`~bin.mongos` instance with support for TLS)

   .. serverstatus:: security.authentication.saslSupportedMechsReceived

      .. versionadded:: 5.0

      The number of times a :dbcommand:`hello` request includes a valid
      :data:`hello.saslSupportedMechs` field.

   .. serverstatus:: security.authentication.mechanisms

      A document that reports on the number of times a given
      authentication mechanism has been used to authenticate against the
      :binary:`~bin.mongod` or :binary:`~bin.mongos` instance. The
      values in the document distinguish standard authentication and
      speculative authentication. [#speculative-auth]_

      .. note::

         The fields in the ``mechanisms`` document depend on the
         configuration of the :parameter:`authenticationMechanisms`
         parameter. The ``mechanisms`` document includes a field for
         each authentication mechanism supported by your
         :binary:`~bin.mongod` or :binary:`~bin.mongos` instance.

         The following example shows the shape of the ``mechanisms``
         document for a deployment that only supports :doc:`x.509
         </core/security-x.509/>` authentication.

   .. serverstatus:: security.authentication.mechanisms.MONGODB-X509

      A document that reports on the number of times
      :ref:`x.509 <security-auth-x509>` has been used to
      authenticate against the
      :binary:`~bin.mongod` or :binary:`~bin.mongos` instance.

      Includes total number of ``x.509`` authentication attempts and the
      subset of those attempts which were speculative.
      [#speculative-auth]_

   .. serverstatus:: security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.received

      Number of speculative authentication attempts received using
      :ref:`x.509 <security-auth-x509>`. Includes both successful and
      failed speculative authentication attempts. [#speculative-auth]_

   .. serverstatus:: security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.successful

      Number of successful speculative authentication attempts received
      using x.509. [#speculative-auth]_

   .. serverstatus:: security.authentication.mechanisms.MONGODB-X509.authenticate.received

      Number of successful and failed authentication attempts
      received using x.509.  This value includes speculative 
      authentication attempts received using x.509.

   .. serverstatus:: security.authentication.mechanisms.MONGODB-X509.authenticate.successful

      Number of successful authentication attempts received using
      x.508. This value includes successful speculative authentication 
      attempts which used x.509.

   .. [#speculative-auth]

      Speculative authentication minimizes the number of network round
      trips during the authentication process to optimize performance.

   .. serverstatus:: security.SSLServerSubjectName

      The subject name associated with the
      :binary:`mongod` / :binary:`mongos` instance's TLS/SSL
      certificate.

   .. serverstatus:: security.SSLServerHasCertificateAuthority

      A boolean that is:

      - ``true`` when the :binary:`mongod` / :binary:`mongos`
        instance's TLS/SSL certificate is associated with a certificate
        authority.

      - ``false`` when the TLS/SSL certificate is self-signed.

   .. serverstatus:: security.SSLServerCertificateExpirationDate

      The expiration date and time of the
      :binary:`mongod` / :binary:`mongos` instance's TLS/SSL
      certificate.

.. _server-status-sharding:

sharding
~~~~~~~~

.. code-block:: javascript

   {
      configsvrConnectionString : 'csRS/cfg1.example.net:27019,cfg2.example.net:27019,cfg2.example.net:27019',
      lastSeenConfigServerOpTime : {
         ts : <timestamp>,
         t : Long("<num>")
      },
      maxChunkSizeInBytes : Long("<num>")
   }

.. serverstatus:: sharding

   A document with data regarding the sharded cluster. The
   :serverstatus:`~sharding.lastSeenConfigServerOpTime` is present only
   for a :binary:`~bin.mongos` or a shard member, not for a config
   server.

.. serverstatus:: sharding.configsvrConnectionString

   The connection string for the config servers.

.. serverstatus:: sharding.lastSeenConfigServerOpTime

   The latest optime of the CSRS primary that the :program:`mongos` or
   the shard member has seen. The optime document includes:

   .. include:: /includes/fact-optime.rst

   The :serverstatus:`~sharding.lastSeenConfigServerOpTime` is present
   only if the sharded cluster uses CSRS.

.. serverstatus:: sharding.maxChunkSizeInBytes

   The maximum :ref:`size limit <sharding-chunk-size>` for a range to
   migrate. If this value has been updated recently on the config 
   server, the :serverstatus:`~sharding.maxChunkSizeInBytes` may not 
   reflect the most recent value.

.. _server-status-sharding-statistics:

shardingStatistics
~~~~~~~~~~~~~~~~~~

.. tabs::

   tabs:

      - id: shard
        name: Shard
        content: |

         When run on a member of a shard:

         .. code-block:: javascript

            shardingStatistics : {
               countStaleConfigErrors : Long("<num>"),
               countDonorMoveChunkStarted : Long("<num>"),
               countDonorMoveChunkCommitted : Long("<num>"),
               countDonorMoveChunkAborted : Long("<num>"),
               totalDonorMoveChunkTimeMillis : Long("<num>"),
               totalDonorChunkCloneTimeMillis : Long("<num>"),
               totalCriticalSectionCommitTimeMillis : Long("<num>"),
               totalCriticalSectionTimeMillis : Long("<num>"),
               countDocsClonedOnRecipient : Long("<num>"),
               countBytesClonedOnRecipient : Long("<num>"),
               countDocsClonedOnCatchUpOnRecipient : Long("<num>"),
               countBytesClonedOnCatchUpOnRecipient : Long("<num>"),
               countDocsClonedOnDonor : Long("<num>"),
               countRecipientMoveChunkStarted : Long("<num>"),
               countDocsDeletedByRangeDeleter : Long("<num>"),
               countDonorMoveChunkLockTimeout : Long("<num>"),
               unfinishedMigrationFromPreviousPrimary : Long("<num>"),
               chunkMigrationConcurrency : Long("<num>"),
               catalogCache : {
                  numDatabaseEntries : Long("<num>"),
                  numCollectionEntries : Long("<num>"),
                  countStaleConfigErrors : Long("<num>"),
                  totalRefreshWaitTimeMicros : Long("<num>"),
                  numActiveIncrementalRefreshes : Long("<num>"),
                  countIncrementalRefreshesStarted : Long("<num>"),
                  numActiveFullRefreshes : Long("<num>"),
                  countFullRefreshesStarted : Long("<num>"),
                  countFailedRefreshes : Long("<num>")
               },
               rangeDeleterTasks : <num>,
               resharding : {
                  countStarted : Long("1"),
                   countSucceeded : Long("1"),
                   countFailed : Long("0"),
                   countCanceled : Long("0"),
                   lastOpEndingChunkImbalance : Long("0"),
                   active : {
                           documentsCopied : Long("0"),
                           bytesCopied : Long("0"),
                           countWritesToStashCollections : Long("0"),
                           countWritesDuringCriticalSection : Long("0"),
                           countReadsDuringCriticalSection : Long("0"),
                           oplogEntriesFetched : Long("0"),
                           oplogEntriesApplied : Long("0"),
                           insertsApplied : Long("0"),
                           updatesApplied : Long("0"),
                           deletesApplied : Long("0")
                   },
                   oldestActive : {
                           coordinatorAllShardsHighestRemainingOperationTimeEstimatedMillis : Long("0"),
                           coordinatorAllShardsLowestRemainingOperationTimeEstimatedMillis : Long("0"),
                           recipientRemainingOperationTimeEstimatedMillis : Long("0")
                   },
                   latencies : {
                           collectionCloningTotalRemoteBatchRetrievalTimeMillis : Long("0"),
                           collectionCloningTotalRemoteBatchesRetrieved : Long("0"),
                           collectionCloningTotalLocalInsertTimeMillis : Long("0"),
                           collectionCloningTotalLocalInserts : Long("0"),
                           oplogFetchingTotalRemoteBatchRetrievalTimeMillis : Long("0"),
                           oplogFetchingTotalRemoteBatchesRetrieved : Long("0"),
                           oplogFetchingTotalLocalInsertTimeMillis : Long("0"),
                           oplogFetchingTotalLocalInserts : Long("0"),
                           oplogApplyingTotalLocalBatchRetrievalTimeMillis : Long("0"),
                           oplogApplyingTotalLocalBatchesRetrieved : Long("0"),
                           oplogApplyingTotalLocalBatchApplyTimeMillis : Long("0"),
                           oplogApplyingTotalLocalBatchesApplied : Long("0")
                   },
                   currentInSteps : {
                           countInstancesInCoordinatorState1Initializing : Long("0"),
                           countInstancesInCoordinatorState2PreparingToDonate : Long("0"),
                           countInstancesInCoordinatorState3Cloning : Long("0"),
                           countInstancesInCoordinatorState4Applying : Long("0"),
                           countInstancesInCoordinatorState5BlockingWrites : Long("0"),
                           countInstancesInCoordinatorState6Aborting : Long("0"),
                           countInstancesInCoordinatorState7Committing : Long("-1"),
                           countInstancesInRecipientState1AwaitingFetchTimestamp : Long("0"),
                           countInstancesInRecipientState2CreatingCollection : Long("0"),
                           countInstancesInRecipientState3Cloning : Long("0"),
                           countInstancesInRecipientState4Applying : Long("0"),
                           countInstancesInRecipientState5Error : Long("0"),
                           countInstancesInRecipientState6StrictConsistency : Long("0"),
                           countInstancesInRecipientState7Done : Long("0"),
                           countInstancesInDonorState1PreparingToDonate : Long("0"),
                           countInstancesInDonorState2DonatingInitialData : Long("0"),
                           countInstancesInDonorState3DonatingOplogEntries : Long("0"),
                           countInstancesInDonorState4PreparingToBlockWrites : Long("0"),
                           countInstancesInDonorState5Error : Long("0"),
                           countInstancesInDonorState6BlockingWrites : Long("0"),
                           countInstancesInDonorState7Done : Long("0")
                   }
                }
               }
            },

      - id: mongos
        name: mongos
        content: |

         When run on a :binary:`~bin.mongos`:

         .. code-block:: javascript

            shardingStatistics : {
               numHostsTargeted: {
                  find : {
                     allShards: Long("<num>"),
                     manyShards: Long("<num>"),
                     oneShard: Long("<num>"),
                     unsharded: Long("<num>") 
                           },
                  insert: { 
                     allShards: Long("<num>"),
                     manyShards: Long("<num>"),
                     oneShard: Long("<num>"),
                     unsharded: Long("<num>") 
                           },
                  update: { 
                     allShards: Long("<num>"),
                     manyShards: Long("<num>"),
                     oneShard: Long("<num>"),
                     unsharded: Long("<num>") 
                           },
                  delete: { 
                     allShards: Long("<num>"),
                     manyShards: Long("<num>"),
                     oneShard: Long("<num>"),
                     unsharded: Long("<num>") 
                           },
                  aggregate: { 
                     allShards: Long("<num>"),
                     manyShards: Long("<num>"),
                     oneShard: Long("<num>"),
                     unsharded: Long("<num>") 
                           }
                  }
               },
               catalogCache : {
                  numDatabaseEntries : Long("<num>"),
                  numCollectionEntries : Long("<num>"),
                  countStaleConfigErrors : Long("<num>"),
                  totalRefreshWaitTimeMicros : Long("<num>"),
                  numActiveIncrementalRefreshes : Long("<num>"),
                  countIncrementalRefreshesStarted : Long("<num>"),
                  numActiveFullRefreshes : Long("<num>"),
                  countFullRefreshesStarted : Long("<num>"),
                  countFailedRefreshes : Long("<num>")
               }
            }


.. serverstatus:: shardingStatistics

   A document which contains metrics on metadata refresh on sharded
   clusters.

.. serverstatus:: shardingStatistics.countStaleConfigErrors

   The total number of times that threads hit stale config exception.
   Since a stale config exception triggers a refresh of the metadata,
   this number is roughly proportional to the number of metadata
   refreshes.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countDonorMoveChunkStarted

   The total number of times that MongoDB starts the
   :dbcommand:`moveChunk` command or :dbcommand:`moveRange` command on
   the primary node of the shard as part of the :ref:`range migration
   procedure <range-migration-procedure>`. This increasing number does not
   consider whether the chunk migrations succeed or not.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countDonorMoveChunkCommitted

   The total number of chunk migrations that MongoDB commits on the
   primary node of the shard.

   .. include:: /includes/chunk-migrations.rst

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.countDonorMoveChunkAborted

   The total number of chunk migrations that MongoDB aborts on the
   primary node of the shard. 

   .. include:: /includes/chunk-migrations.rst

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.totalDonorMoveChunkTimeMillis

   Cumulative time in milliseconds to move chunks from the current shard
   to another shard. For each chunk migration, the time starts when a
   :dbcommand:`moveRange` or :dbcommand:`moveChunk` command starts, and
   ends when the chunk is moved to another shard in a :ref:`range
   migration procedure <range-migration-procedure>`.

   *Only available on a shard.*

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.totalDonorChunkCloneTimeMillis

   The cumulative time, in milliseconds, that the :ref:`clone phase of
   the range migration procedure <range-migration-procedure>` takes on
   the primary node of the shard.  Specifically, for each migration on
   this shard, the tracked time starts with the :dbcommand:`moveRange`
   and :dbcommand:`moveChunk` commands and ends before the destination
   shard enters a ``catchup`` phase to apply changes that occurred
   during the :ref:`range migration procedure <range-migration-procedure>`.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.totalCriticalSectionCommitTimeMillis

   The cumulative time, in milliseconds, that the :ref:`update metadata
   phase of the range migrations procedure <range-migration-procedure>`
   takes on the primary node of the shard. During the update metadata
   phase, MongoDB blocks all operations on the collection.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.totalCriticalSectionTimeMillis

   The cumulative time, in milliseconds, that the :ref:`catch-up
   phase and the update metadata phase of the range migration procedure
   <range-migration-procedure>` takes on the primary node of the shard. 

   To calculate the duration of the catch-up phase, subtract
   :serverstatus:`~shardingStatistics.totalCriticalSectionCommitTimeMillis` from
   :serverstatus:`~shardingStatistics.totalCriticalSectionTimeMillis`:

   .. code-block:: none

      totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countDocsClonedOnRecipient

   The cumulative, always-increasing count of documents that MongoDB
   clones on the primary node of the recipient shard.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countBytesClonedOnRecipient

   The cumulative number of bytes that MongoDB clones on the primary
   node of the recipient shard during the :ref:`range migration procedure
   <range-migration-procedure>`. 

   .. include:: /includes/chunk-migrations-data-copy.rst

   *Only available on a shard.*

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.countDocsClonedOnCatchUpOnRecipient

   The cumulative number of documents that MongoDB clones on the primary
   node of the recipient shard during the catch-up phase of the
   :ref:`range migration procedure <range-migration-procedure>`. 

   .. include:: /includes/chunk-migrations-data-copy.rst

   *Only available on a shard.*

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.countBytesClonedOnCatchUpOnRecipient

   The cumulative number of bytes that MongoDB clones on the primary
   node of the recipient shard during the catch-up phase of the
   :ref:`range migration procedure <range-migration-procedure>`. 

   .. include:: /includes/chunk-migrations-data-copy.rst

   *Only available on a shard.*

   .. include:: /includes/chunk-migrations-version-list.rst

.. serverstatus:: shardingStatistics.countDocsClonedOnDonor

   The cumulative, always-increasing count of documents that MongoDB
   clones on the primary node of the donor shard. 

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countRecipientMoveChunkStarted

   Cumulative, always-increasing count of chunks this member, acting as
   the primary of the recipient shard, has started to receive (whether
   the move has succeeded or not).

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.countDocsDeletedByRangeDeleter

   The cumulative, always-increasing count of documents that MongoDB
   deletes on the primary node of the donor shard during chunk
   migration. 

   *Only present when run on a shard.*

   .. versionchanged:: 7.1

.. serverstatus:: shardingStatistics.countDonorMoveChunkLockTimeout

   The cumulative, always-increasing count of chunk migrations that MongoDB
   aborts on the primary node of the donor shard due to lock acquisition
   timeouts.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.unfinishedMigrationFromPreviousPrimary

   The number of unfinished migrations left by the previous
   primary after an election. This value is only updated after
   the newly-elected :binary:`~bin.mongod` completes the transition to
   primary.

   *Only present when run on a shard.*

.. serverstatus:: shardingStatistics.chunkMigrationConcurrency

   The number of threads on the source shard and the receiving shard for
   performing :ref:`chunk migration <migrate-chunks-sharded-cluster>`
   operations.

   *Only present when run on a shard.*

   *Available starting in MongoDB 6.3 (and 5.0.15).*

.. serverstatus:: shardingStatistics.catalogCache

   A document with statistics about the cluster's routing information cache.

.. serverstatus:: shardingStatistics.catalogCache.numDatabaseEntries

   The total number of database entries that are currently in the
   catalog cache.

.. serverstatus:: shardingStatistics.catalogCache.numCollectionEntries

   The total number of collection entries (across all databases) that
   are currently in the catalog cache.

.. serverstatus:: shardingStatistics.catalogCache.countStaleConfigErrors

   The total number of times that threads hit stale config exception. A
   stale config exception triggers a refresh of the metadata.

.. serverstatus:: shardingStatistics.catalogCache.totalRefreshWaitTimeMicros

   The cumulative time, in microseconds, that threads had to wait for a
   refresh of the metadata.

.. serverstatus:: shardingStatistics.catalogCache.numActiveIncrementalRefreshes

   The number of incremental catalog cache refreshes that are currently
   waiting to complete.

.. serverstatus:: shardingStatistics.countIncrementalRefreshesStarted

   The cumulative number of incremental refreshes that have started.

.. serverstatus:: shardingStatistics.catalogCache.numActiveFullRefreshes

   The number of full catalog cache refreshes that are currently
   waiting to complete.

.. serverstatus:: shardingStatistics.catalogCache.countFullRefreshesStarted

   The cumulative number of full refreshes that have started.

.. serverstatus:: shardingStatistics.catalogCache.countFailedRefreshes

   The cumulative number of full or incremental refreshes that have failed.

.. serverstatus:: shardingStatistics.rangeDeleterTasks

   The current total of the queued chunk range deletion tasks that are
   ready to run or are running as part of the :ref:`range migration
   procedure <range-migration-procedure>`.

   Inspect the documents in the :data:`config.rangeDeletions` collection
   for information about the chunk ranges pending deletion from a shard
   after a chunk migration.

   *Only present when run on a shard member.*

.. serverstatus:: shardingStatistics.resharding

   A document with statistics about :ref:`resharding operations
   <sharding-resharding>`.

   Each shard returns its own resharding operation statistics. If a
   shard is not involved in a resharding operation, then that shard will
   not contain statistics about the resharding operation.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.countStarted

   The sum of
   :serverstatus:`~shardingStatistics.resharding.countSucceeded`,
   :serverstatus:`~shardingStatistics.resharding.countFailed`,
   and
   :serverstatus:`~shardingStatistics.resharding.countCanceled`.
   The sum is further incremented by ``1`` if a :ref:`resharding
   operation <sharding-resharding>` has started but has not yet
   completed. Sum is set to 0 when :binary:`~bin.mongod` is started or
   restarted.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.countSucceeded

   Number of successful :ref:`resharding operations
   <sharding-resharding>`. Number is set to 0 when :binary:`~bin.mongod`
   is started or restarted.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.countFailed

   Number of failed :ref:`resharding operations <sharding-resharding>`.
   Number is set to 0 when :binary:`~bin.mongod` is started or
   restarted.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.countCanceled

   Number of canceled :ref:`resharding operations
   <sharding-resharding>`. Number is set to 0 when :binary:`~bin.mongod`
   is started or restarted.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.active.resharding.documentsCopied

   Number of documents copied from donor shards to recipient shards for
   the current :ref:`resharding operation <sharding-resharding>`. Number
   is set to 0 when a new resharding operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

   *Updated in version 6.1*

.. serverstatus:: shardingStatistics.resharding.active.bytesCopied

   Number of bytes copied from donor shards to recipient shards for the
   current :ref:`resharding operation <sharding-resharding>`. Number is
   set to 0 when a new resharding operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

   *Updated in version 6.1*

.. serverstatus:: shardingStatistics.resharding.active.countWritesToStashCollections

   During resharding, the number of writes to the recipient stash
   collections.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.active.countWritesDuringCriticalSection

   Number of writes perfomed in the critical section for the current
   :ref:`resharding operation <sharding-resharding>`. The critical
   section prevents new incoming writes to the collection currently
   being resharded. Number is set to 0 when a new resharding operation
   starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

   *Updated in version 6.1*

.. serverstatus:: shardingStatistics.resharding.active.countReadsDuringCriticalSection

   During resharding, the number of reads attempted during the donor's
   critical section.

   .. versionadded:: 6.1


.. serverstatus:: shardingStatistics.resharding.active.oplogEntriesFetched

   Number of entries fetched from the :term:`oplog` for the current
   :ref:`resharding operation <sharding-resharding>`. Number is set to 0
   when a new resharding operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   *Updated in version 6.1*

.. serverstatus:: shardingStatistics.resharding.active.oplogEntriesApplied

   Number of entries applied to the :term:`oplog` for the current
   :ref:`resharding operation <sharding-resharding>`. Number is set to 0
   when a new resharding operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

   *Updated in version 6.1* 

.. serverstatus:: shardingStatistics.resharding.active.insertsApplied

   The total number of insert operations applied during resharding.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.active.updatesApplied

   The total number of update operations applied during resharding.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.active.deletesApplied

   The total number of delete operations applied during resharding.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.oldestActive.coordinatorAllShardsHighestRemainingOperationTimeEstimatedMillis

   Calculated across all shards, the highest estimate of the number of
   seconds remaining. If the time estimate cannot be computed, the 
   value is set to -1.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.oldestActive.coordinatorAllShardsLowestRemainingOperationTimeEstimatedMillis

   Calculated across all shards, the lowest estimate of the number of
   seconds remaining. If the time estimate cannot be computed, the 
   value is set to -1.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.oldestActive.recipientRemainingOperationTimeEstimatedMillis

   Estimated remaining time, in milliseconds, for the current resharding
   operation. Prior to :ref:`resharding <sharding-resharding>`, or when
   the time cannot be calculated, the value is set to -1.

   If a shard is involved in multiple resharding operations, this field
   contains the remaining time estimate for the oldest resharding
   operation where this shard is a recipient.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.oldestActive.totalOperationTimeElapsedMillis

   Total elapsed time, in milliseconds, for the current :ref:`resharding
   operation <sharding-resharding>`. Time is set to 0 when a new
   resharding operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.latencies

   Timing metrics for resharding operations.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchRetrievalTimeMillis

   Total time recipients spent retrieving batches of documents from
   donors, in milliseconds.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchesRetrieved

   Total number of batches of documents recipients retrieved from
   donors.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.latencies.collectionCloningTotalLocalInsertTimeMillis

   Total time recipients spent inserting batches of documents from
   donors, in milliseconds.

   .. versionadded:: 6.1
 
.. serverstatus:: shardingStatistics.resharding.latencies.collectionCloningTotalLocalInserts

   Total number of batches of documents from donors that recipients
   inserted.

   .. versionadded:: 6.1
   
.. serverstatus:: shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchRetrievalTimeMillis

   Total time recipients spent retrieving batches of oplog entries from
   donors, in milliseconds.

   .. versionadded:: 6.1
 
.. serverstatus:: shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchesRetrieved

   Total number of batches of oplog entries recipients retrieved from
   donors.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInsertTimeMillis

   Total time recipients spent inserting batches of oplog entries from
   donors, in milliseconds.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInserts

   Total number of batches of oplog entries from donors that recipients
   inserted.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchRetrievalTimeMillis

   Total time recipients spent retrieving batches of oplog entries that
   were inserted during fetching, in milliseconds.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesRetrieved

   Total number of batches of oplog entries that were inserted during
   fetching that recipients retrieved.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchApplyTimeMillis

   Total time recipients spent applying batches of oplog entries, in
   milliseconds.

   .. versionadded:: 6.1
    
.. serverstatus:: shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesApplied

   Total number of batches of oplog entries that recipients applied.

   .. versionadded:: 6.1

.. serverstatus:: shardingStatistics.resharding.totalApplyTimeElapsedMillis

   Total elapsed time, in milliseconds, for the apply step of the
   current :ref:`resharding operation <sharding-resharding>`. In the
   apply step, recipient shards modify their data based on new incoming
   writes from donor shards. Time is set to 0 when a new resharding
   operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.totalCriticalSectionTimeElapsedMillis

   Total elapsed time, in milliseconds, for the critical section of the
   current :ref:`resharding operation <sharding-resharding>`. The
   critical section prevents new incoming writes to the collection
   currently being resharded. Time is set to 0 when a new resharding
   operation starts.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.donorState

   State of the donor shard for the current :ref:`resharding operation
   <sharding-resharding>`. Number is set to 0 when a new
   resharding operation starts.

   .. list-table::
      :header-rows: 1
      :widths: 15 20 40

      * - Number Returned
        - Meaning
        - Description

      * - 0
        - ``unused``
        - The shard is not a donor in the current resharding operation.

      * - 1
        - ``preparing-to-donate``
        - The donor shard is preparing to donate data to the recipient
          shards.

      * - 2
        - ``donating-initial-data``
        - The donor shard is donating data to the recipient shards.

      * - 3
        - ``donating-oplog-entries``
        - The donor shard is donating :term:`oplog` entries to the
          recipient shards.

      * - 4
        - ``preparing-to-block-writes``
        - The donor shard is about to prevent new incoming write
          operations to the collection that is being resharded.

      * - 5
        - ``error``
        - An error occurred during the resharding operation.

      * - 6
        - ``blocking-writes``
        - The donor shard is preventing new incoming write operations
          and the donor shard has notified all recipient shards that new
          incoming writes are prevented.

      * - 7
        - ``done``
        - The donor shard has dropped the old sharded collection and the
          resharding operation is complete.

   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.recipientState

   State of the recipient shard for the current :ref:`resharding
   operation <sharding-resharding>`. Number is set to 0 when a new
   resharding operation starts.

   .. list-table::
      :header-rows: 1
      :widths: 15 20 40

      * - Number Returned
        - Meaning
        - Description

      * - 0
        - ``unused``
        - Shard is not a recipient in the current resharding operation.

      * - 1
        - ``awaiting-fetch-timestamp``
        - The recipient shard is waiting for the donor shards to be
          prepared to donate their data

      * - 2
        - ``creating-collection``
        - The recipient shard is creating the new sharded collection.

      * - 3
        - ``cloning``
        - The recipient shard is receiving data from the donor shards.

      * - 4
        - ``applying``
        - The recipient shard is applying :term:`oplog` entries to
          modify its copy of the data based on the new incoming writes
          from donor shards.

      * - 5
        - ``error``
        - An error occurred during the resharding operation.

      * - 6
        - ``strict-consistency``
        - The recipient shard has all data changes stored in a temporary
          collection.

      * - 7
        - ``done``
        - The resharding operation is complete.


   *Only present when run on a shard or config server. Returns 0 on a
   config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.numHostsTargeted

   Indicates the number of shards targeted for ``CRUD`` operations and 
   aggregation commands. When a ``CRUD`` operation or aggregation
   command is run, the following metrics will be incremented.

   .. include:: /includes/fact-server-status-num-hosts-targeted.rst

   .. note:: 

      Running the :dbcommand:`serverStatus` command on :binary:`mongos` 
      will provide insight into the CRUD and aggregation operations that
      run on a sharded cluster.

      Multi-shard operations can either be 
      :ref:`scatter-gather<sharding-query-patterns>`
      or shard specific. Multi-shard scatter-gather operations can
      :ref:`consume more resources<sharding-troubleshooting-scatter-gather>`.
      By using the 
      :serverstatus:`shardingStatistics.numHostsTargeted`
      metrics you can tune the aggregation queries that run on a 
      sharded cluster.

.. serverstatus:: shardingStatistics.resharding.coordinatorState

   State of the resharding coordinator for the current :ref:`resharding
   operation <sharding-resharding>`. The resharding coordinator is a
   thread that runs on the :ref:`config server
   <sharding-config-server>` primary. Number is set to 0
   when a new resharding operation starts.

   .. list-table::
      :header-rows: 1
      :widths: 15 20 40

      * - Number Returned
        - Meaning
        - Description

      * - 0
        - ``unused``
        - The shard is not the coordinator in the current resharding
          operation.

      * - 1
        - ``initializing``
        - The resharding coordinator has inserted the coordinator
          document into ``config.reshardingOperations`` and has added
          the ``reshardingFields`` to the ``config.collections`` entry
          for the original collection.

      * - 2
        - ``preparing-to-donate``
        - The resharding coordinator

          - has created a ``config.collections`` entry for the temporary
            resharding collection.
          - has inserted entries into ``config.chunks`` for ranges based
            on the new shard key.
          - has inserted entries into ``config.tags`` for any zones
            associated with the new shard key.

          The coordinator informs participant shards to begin the
          resharding operation. The coordinator then waits until all
          donor shards have picked a ``minFetchTimestamp`` and are ready
          to donate.

      * - 3
        - ``cloning``
        - The resharding coordinator informs donor shards to donate data
          to recipient shards. The coordinator waits for all recipients
          to finish cloning the data from the donor.

      * - 4
        - ``applying``
        - The resharding coordinator informs recipient shards to modify
          their copies of data based on new incoming writes from donor
          shards. The coordinator waits for all recipients to finish
          applying :term:`oplog` entries.

      * - 5
        - ``blocking-writes``
        - The resharding coordinator informs donor shards to prevent new
          incoming write operations to the collection being resharded.
          The coordinator then waits for all recipients to have all data
          changes.

      * - 6
        - ``aborting``
        - An unrecoverable error occurred during the resharding
          operation or the :dbcommand:`abortReshardCollection` command
          (or the :method:`sh.abortReshardCollection()` method) was run.

      * - 6
        - ``committing``
        - The resharding coordinator removes the ``config.collections``
          entry for the temporary resharding collection. The coordinator
          then adds the ``recipientFields`` to the source collection's
          entry.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.opStatus

   Status for the current :ref:`resharding operation
   <sharding-resharding>`.

   .. list-table::
      :header-rows: 1
      :widths: 10 40

      * - Number Returned
        - Description

      * - -1
        - Resharding operation not in progress.

      * - 0
        - Resharding operation succeeded.

      * - 1
        - Resharding operation failed.

      * - 2
        - Resharding operation canceled.

   *Only present when run on a shard or config server.*

   .. versionadded:: 5.0

.. serverstatus:: shardingStatistics.resharding.lastOpEndingChunkImbalance

   This field contains the highest numeric difference for 
   (``maxNumChunksInShard - minNumChunksInShard``) among all 
   :ref:`zones <zone-sharding>` for the 
   collection that was processed by the most recent
   :ref:`resharding operation <resharding_process>`.

   See :ref:`sharding-chunk-size`.

   *Only updated on config servers.*

   .. versionadded:: 5.0

.. _server-status-sharded-index-consistency:

shardedIndexConsistency
~~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: javascript

   shardedIndexConsistency : {
      numShardedCollectionsWithInconsistentIndexes : Long("<num>")
   },

.. serverstatus:: shardedIndexConsistency

   *Available only on config server instances.*

   A document that returns results of index consistency checks for
   sharded collections.

   The returned metrics are meaningful only when run on the primary of
   the :ref:`config server replica set <sharding-config-server>` for a 
   sharded cluster.

   .. seealso::

      - :parameter:`enableShardedIndexConsistencyCheck` parameter
      - :parameter:`shardedIndexConsistencyCheckIntervalMS` parameter

.. serverstatus:: shardedIndexConsistency.numShardedCollectionsWithInconsistentIndexes

   *Available only on config server instances.*

   Number of sharded collections whose indexes are inconsistent across
   the shards. A sharded collection has an inconsistent index if the
   collection does not have the exact same indexes (including the index
   options) on each shard that contains chunks for the collection.

   To investigate if a sharded collection has inconsistent indexes, see
   :ref:`manage-indexes-find-inconsistent-indexes`.

   The returned metrics are meaningful only when run on the primary of
   the :ref:`config server replica set
   <sharding-config-server>` for a sharded cluster.

   .. seealso::

      - :parameter:`enableShardedIndexConsistencyCheck` parameter
      - :parameter:`shardedIndexConsistencyCheckIntervalMS` parameter

.. _server-status-storage-engine:

storageEngine
~~~~~~~~~~~~~

.. code-block:: javascript

   storageEngine : {
      name : <string>,
      supportsCommittedReads : <boolean>,
      persistent : <boolean>
   },

.. serverstatus:: storageEngine

   A document with data about the current storage engine.

.. serverstatus:: storageEngine.name

   The name of the current storage engine.

.. serverstatus:: storageEngine.supportsCommittedReads

   A boolean that indicates whether the storage engine supports
   :readconcern:`"majority"` :doc:`read concern
   </reference/read-concern>`.

.. serverstatus:: storageEngine.persistent

   A boolean that indicates whether the :doc:`storage engine
   </core/storage-engines>` does or does not persist data to disk.

.. _server-status-tcmalloc:

tcmalloc
~~~~~~~~

.. note:: 
   
   ``tcmalloc`` metrics that are only for internal use are omitted from this 
   page.

.. code-block:: javascript
   
   tcmalloc : {
      usingPerCPUCaches : <boolean>,  // Added in MongoDB 8.0
      maxPerCPUCacheSizeBytes : <integer>, // Added in MongoDB 8.0
      generic : {
         current_allocated_bytes : <integer>, 
         heap_size : <integer>,
         peak_memory_usage : <integer>  // Added in MongoDB 8.0
      },
      tcmalloc : {
         central_cache_free : <integer>, 
         cpu_free : <integer>,  // Added in MongoDB 8.0
         release_rate : <integer>, 
         total_bytes_held : <integer>,  // Added in MongoDB 8.0
         cpuCache : { 
            0 : {
               overflows : <integer>,  // Added in MongoDB 8.0
               underflows : <integer>  // Added in MongoDB 8.0
            },
         }
      },
      tcmalloc_derived : {
         total_free_bytes : <integer>  // Added in MongoDB 8.0
      }
   }

.. serverstatus:: tcmalloc 
   
   .. include:: /includes/fact-tcmalloc-upgrade-note.rst

   A document that contains information on memory allocation for the server.
   By default, ``tcmalloc`` metrics are included in the ``serverStatus`` output. 
   To change the verbosity of the ``tcmalloc`` section, specify an integer 
   between ``0`` and ``3`` (inclusive):

   - If you set verbosity to ``0``, ``tcmalloc`` metrics aren't included in the 
     ``serverStatus`` output.
   - If you set verbosity to ``1``, the ``serverStatus`` output includes the 
     default ``tcmalloc`` metrics.
   - If you set verbosity to ``2``, the ``serverStatus`` output includes default 
     ``tcmalloc`` metrics and the :serverstatus:`tcmalloc.tcmalloc.cpuCache` 
     section.
   - If you set verbosity to ``3``, the ``serverStatus`` output includes all 
     ``tcmalloc`` metrics.
   
   If you specify a value higher than ``3``, MongoDB sets the ``verbosity`` 
   to ``3``.
   
   For example, to call ``serverStatus`` with ``verbosity`` set to ``2``, run 
   the following command: 
   
   .. code-block:: javascript
      
      db.runCommand( { serverStatus: 1, tcmalloc: 2 } )
      
   .. seealso:: 
      
      `TCMalloc Stats <https://google.github.io/tcmalloc/stats.html>`__

.. serverstatus:: tcmalloc.usingPerCPUCaches

   A boolean that indicates whether TCMalloc is running with per-CPU caches. 
   If ``tcmalloc.usingPerCPUCaches`` is ``false``, ensure that: 

   - You :ref:`disabled glibc rseq <tcmalloc-disable-glibc-rseq>`. 
   - You're using Linux :ref:`kernel version <tcmalloc-kernel-version>` 4.18 or 
     later.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.maxPerCPUCacheSizeBytes

   Maximum size, in bytes, of each CPU cache.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.generic.peak_memory_usage 

   Maximum amount of memory, in bytes, allocated by MongoDB at any point.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.generic.current_allocated_bytes 

   Total number of bytes that are currently allocated to memory and actively 
   used by MongoDB.

.. serverstatus:: tcmalloc.generic.heap_size

   Amount of memory, in bytes, allocated from the operating system. This value 
   includes memory that's currently in use and memory that's been
   allocated but isn't in use.

.. serverstatus:: tcmalloc.tcmalloc.central_cache_free

   Amount of memory, in bytes, held in the central free list. The central free 
   list is a structure that manages free memory for reuse.

.. serverstatus:: tcmalloc.tcmalloc.cpu_free

   Amount of free memory, in bytes, available across all CPU caches. 

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.tcmalloc.total_bytes_held 

   Amount of memory, in bytes, currently held in caches.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.tcmalloc.release_rate

   Rate, in bytes per second, at which unused memory is released to the 
   operating system. The :parameter:`tcmallocReleaseRate` parameter determines 
   the value of ``tcmalloc.tcmalloc.release_rate``.

.. serverstatus:: tcmalloc.tcmalloc.cpuCache 

   A document that provides data on each CPU cache. 
   
   ``cpuCache`` metrics are excluded at the default verbosity level. To view 
   ``cpuCache`` metrics, you must set the ``tcmalloc`` verbosity to at least 
   ``2``.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.tcmalloc.cpuCache.N.overflows 

   Number of overflows that the CPU cache experienced. Overflows occur when a 
   user deallocates memory and the cache is full.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.tcmalloc.cpuCache.N.underflows 

   Number of underflows that the CPU cache experienced. Underflows occur when a 
   user allocates memory and the cache is empty.

   .. versionadded:: 8.0

.. serverstatus:: tcmalloc.tcmalloc_derived.total_free_bytes 

   Amount of memory remaining before ``tcmalloc`` has to request for more memory 
   from the operating system.

   .. versionadded:: 8.0

.. _server-status-transactions:

transactions
~~~~~~~~~~~~

.. tabs::

   tabs:

      - id: mongod
        name: mongod
        content: |

           .. code-block:: javascript

              transactions : {
                 retriedCommandsCount : Long("<num>"),
                 retriedStatementsCount : Long("<num>"),
                 transactionsCollectionWriteCount : Long("<num>"),
                 currentActive : Long("<num>"),
                 currentInactive : Long("<num>"),
                 currentOpen : Long("<num>"),
                 totalAborted : Long("<num>"),
                 totalCommitted : Long("<num>"),
                 totalStarted : Long("<num>"),
                 totalPrepared : Long("<num>"),
                 totalPreparedThenCommitted : Long("<num>"),
                 totalPreparedThenAborted :  Long("<num>"),
                 currentPrepared :  Long("<num>"),
                 lastCommittedTransaction : <document>
              },

      - id: mongos
        name: mongos
        content: |

           .. code-block:: javascript

              transactions : {
                 currentOpen : Long("<num>"),  
                 currentActive : Long("<num>"),  
                 currentInactive : Long("<num>"),
                 totalStarted : Long("<num>"),
                 totalCommitted : Long("<num>"),
                 totalAborted : Long("<num>"),
                 abortCause : {
                    <String1> : Long("<num>"),
                    <String2> : Long("<num>"),
                    ...
                 },
                 totalContactedParticipants : Long("<num>"),
                 totalParticipantsAtCommit : Long("<num>"),
                 totalRequestsTargeted : Long("<num>"),
                 commitTypes : {
                    noShards : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    },
                    singleShard : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    },
                    singleWriteShard : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    },
                    readOnly : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    },
                    twoPhaseCommit : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    },
                    recoverWithToken : {
                       initiated : Long("<num>"),
                       successful : Long("<num>"),
                       successfulDurationMicros : Long("<num>")
                    }
                 }
              },

.. serverstatus:: transactions
   
   When run on a :binary:`~bin.mongod`, a document with data about the
   :ref:`retryable wrties <retryable-writes>` and
   :ref:`transactions <transactions>`.

   When run on a :binary:`~bin.mongos`, a document with data about the
   :ref:`transactions <transactions>` run on the instance.

.. serverstatus:: transactions.retriedCommandsCount

   |mongod-only|

   The total number of retry attempts that have been received after the
   corresponding retryable write command has already been committed.
   That is, a retryable write is attempted even though the write has
   previously succeeded and has an associated record for the
   transaction and session in the :data:`config.transactions`
   collection, such as when the initial write response to the client is
   lost.

   .. note::

      MongoDB does not re-execute the committed writes.

   The total is across all sessions.

   The total does not include any retryable writes that may happen
   internally as part of a chunk migration.

.. serverstatus:: transactions.retriedStatementsCount

   |mongod-only|

   The total number of write statements associated with the retried
   commands in :serverstatus:`transactions.retriedCommandsCount`.

   .. note::

      MongoDB does not re-execute the committed writes.

   The total does not include any retryable writes that may happen
   internally as part of a chunk migration.

.. serverstatus:: transactions.transactionsCollectionWriteCount

   |mongod-only|

   The total number of writes to the :data:`config.transactions`
   collection, triggered when a new retryable write statement is
   committed.

   For update and delete commands, since only single document
   operations are retryable, there is one write per statement.

   For insert operations, there is one write per batch of documents
   inserted, except when a failure leads to each document being
   inserted separately.

   The total includes writes to a server's :data:`config.transactions`
   collection that occur as part of a migration.

.. serverstatus:: transactions.currentActive

   |both|

   The total number of open transactions currently executing a command.

.. serverstatus:: transactions.currentInactive

   |both|


   The total number of open transactions that are not currently
   executing a command.

.. serverstatus:: transactions.currentOpen

   |both|

   The total number of open transactions. A transaction is opened when
   the first command is run as a part of that transaction, and stays
   open until the transaction either commits or aborts.

.. serverstatus:: transactions.totalAborted

   For the :binary:`~bin.mongod`, the total number of transactions
   aborted on this instance since its last startup.

   For the :binary:`~bin.mongos`, the total number of transactions
   aborted through this instance since its last startup.

.. serverstatus:: transactions.totalCommitted

   For the :binary:`~bin.mongod`, the total number of transactions
   committed on the instance since its last startup.

   For the :binary:`~bin.mongos`,the total number of transactions
   committed through this instance since its last startup.

.. serverstatus:: transactions.totalStarted

   For the :binary:`~bin.mongod`, the total number of transactions
   started on this instance since its last startup.

   For the :binary:`~bin.mongos`, the total number of transactions
   started on this instance since its last startup.

.. serverstatus:: transactions.abortCause

   |mongos-only|

   Breakdown of the :serverstatus:`transactions.totalAborted` by cause.
   If a client issues an explicit ``abortTransaction``, the cause is
   listed as ``abort``.

   For example:

   .. code-block:: javascript

      totalAborted : Long("5"),
      abortCause : {
         abort : Long("1"),
         DuplicateKey : Long("1"),
         StaleConfig : Long("3"),
         SnapshotTooOld : Long("1")
      },

.. serverstatus:: transactions.totalContactedParticipants

   |mongos-only|

   The total number of shards contacted for all transactions started
   through this :binary:`~bin.mongos` since its last startup.

   The number of shards contacted during the transaction processes can
   include those shards that may not be included as part of the commit.

.. serverstatus:: transactions.totalParticipantsAtCommit

   |mongos-only|

   Total number of shards involved in the commit for all transactions
   started through this :binary:`~bin.mongos` since its last startup.

.. serverstatus:: transactions.totalRequestsTargeted

   |mongos-only|

   Total number of network requests targeted by the
   :binary:`~bin.mongos` as part of its transactions.

.. serverstatus:: transactions.commitTypes

   |mongos-only|

   Breakdown of the commits by types. For example:

   .. code-block:: javascript
      :copyable: false

      noShards : {
         initiated : Long("0"),
         successful : Long("0"),
         successfulDurationMicros : Long("0")
      },
      singleShard : {
         initiated : Long("5"),
         successful : Long("5"),
         successfulDurationMicros : Long("203118")
      },
      singleWriteShard : {
         initiated : Long("0"),
         successful : Long("0"),
         successfulDurationMicros : Long("0")
      },
      readOnly : {
         initiated : Long("0"),
         successful : Long("0"),
         successfulDurationMicros : Long("0")
      },
      twoPhaseCommit : {
         initiated : Long("1"),
         successful : Long("1"),
         successfulDurationMicros : Long("179616")
      },
      recoverWithToken : {
         initiated : Long("0"),
         successful : Long("0"),
         successfulDurationMicros : Long("0")
      }

   The types of commit are:

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Type
        - Description

      * - ``noShards``

        - Commits of transactions that did not contact any shards.

      * - ``singleShard``

        - Commits of transactions that affected a single shard.

      * - ``singleWriteShard``

        - Commits of transactions that contacted multiple shards but
          whose write operations only affected a single shard.

      * - ``readOnly``

        - Commits of transactions that only involved read operations.

      * - ``twoPhaseCommit``

        - Commits of transactions that included writes to multiple
          shards

      * - ``recoverWithToken``

        - Commits that recovered the outcome of transactions from
          another instance or after this instance was restarted.

   For each commit type, the command returns the following metrics:

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Metrics
        - Description

      * - ``initiated``

        - Total number of times that commits of this type were
          initiated.

      * - ``successful``

        - Total number of times that commits of this type succeeded.

      * - ``successfulDurationMicros``

        - Total time, in microseconds, taken by successful commits of
          this type.

.. serverstatus:: transactions.totalPrepared

   |mongod-only|

   The total number of transactions in prepared state on this server
   since the :binary:`mongod <bin.mongod>` process's last startup.

.. serverstatus:: transactions.totalPreparedThenCommitted

   |mongod-only|

   The total number of transactions that were prepared and committed on
   this server since the :binary:`mongod <bin.mongod>` process's last
   startup.

.. serverstatus:: transactions.totalPreparedThenAborted

   |mongod-only|

   The total number of transactions that were prepared and aborted on
   this server since the :binary:`mongod <bin.mongod>` process's last
   startup.

.. serverstatus:: transactions.currentPrepared

   |mongod-only|

   The current number of transactions in prepared state on this server.

.. serverstatus:: transactions.lastCommittedTransaction

   |mongod-only|

   The details of the last transaction committed when the
   :binary:`mongod <bin.mongod>` is primary.

   When returned from a secondary,
   :serverstatus:`~transactions.lastCommittedTransaction` returns the
   details of the last transaction committed when that secondary was a
   primary.

   .. code-block:: javascript
      :copyable: false

      lastCommittedTransaction : {
         operationCount : Long("1"),
         oplogOperationBytes : Long("211"),
         writeConcern : {
            w : "majority",
            wtimeout : 0
         }
      }

   .. list-table::
      :header-rows: 1
      :widths: 20 80

      * - Metrics
        - Description

      * - ``operationCount``
        - The number of write operations in the transaction.

      * - ``oplogOperationBytes``

        - The size of the corresponding oplog entry or entries for
          the transaction. [#oplog-change]_

      * - ``writeConcern``
        - The write concern used for the transaction.

.. [#oplog-change]

   MongoDB creates as many oplog entries as necessary to encapsulate all write 
   operations in a transaction. See :ref:`txn-oplog-size-limit` for details.


transportSecurity
~~~~~~~~~~~~~~~~~

.. code-block:: javascript

   transportSecurity : {
      1.0 : Long("<num>"),
      1.1 : Long("<num>"),
      1.2 : Long("<num>"),
      1.3 : Long("<num>"),
      unknown : Long("<num>")
   },

.. serverstatus:: transportSecurity.<version>

   The cumulative number of TLS <version> connections that have been
   made to this :binary:`~bin.mongod` or :binary:`~bin.mongos`
   instance. The value is reset upon restart.

.. _server-status-watchdog:

watchdog
~~~~~~~~

.. code-block:: javascript

   watchdog : {
      checkGeneration : Long("<num>"),
      monitorGeneration : Long("<num>"),
      monitorPeriod : <num>
   }

.. note::

   The ``watchdog`` section is only present if the :ref:`Storage Node Watchdog
   <storage-node-watchdog>` is enabled.

.. serverstatus:: watchdog

   A document reporting the status of the
   :ref:`Storage Node Watchdog <storage-node-watchdog>`.

.. serverstatus:: watchdog.checkGeneration

   The number of times the directories have been checked since startup.
   Directories are checked multiple times every ``monitoringPeriod``.

.. serverstatus:: watchdog.monitorGeneration

   The number of times the status of all filesystems used by
   :binary:`~bin.mongod` has been examined. This is incremented once
   every ``monitoringPeriod``.

.. serverstatus:: watchdog.monitorPeriod

   The value set by :parameter:`watchdogPeriodSeconds`. This is the
   period between status checks.

.. _server-status-wiredTiger:

wiredTiger
~~~~~~~~~~

``wiredTiger`` information only appears if using the :doc:`WiredTiger
</core/wiredtiger>` storage engine. Some of the statistics roll up for the server.

.. code-block:: javascript

   {
      uri : 'statistics:',
      async : {
         current work queue length : <num>,
         maximum work queue length : <num>,
         number of allocation state races : <num>,
         number of flush calls : <num>,
         number of operation slots viewed for allocation : <num>,
         number of times operation allocation failed : <num>,
         number of times worker found no work : <num>,
         total allocations : <num>,
         total compact calls : <num>,
         total insert calls : <num>,
         total remove calls : <num>,
         total search calls : <num>,
         total update calls : <num>
      },
      block-manager : {
         blocks pre-loaded : <num>,
         blocks read : <num>,
         blocks written : <num>,
         bytes read : <num>,
         bytes written : <num>,
         bytes written for checkpoint : <num>,
         mapped blocks read : <num>,
         mapped bytes read : <num>
      },
      cache : {
         application threads page read from disk to cache count : <num>,
         application threads page read from disk to cache time (usecs) : <num>,
         application threads page write from cache to disk count : <num>,
         application threads page write from cache to disk time (usecs) : <num>,
         bytes belonging to page images in the cache : <num>,
         bytes belonging to the cache overflow table in the cache : <num>,
         bytes currently in the cache : <num>,
         bytes dirty in the cache cumulative : <num>,
         bytes not belonging to page images in the cache : <num>,
         bytes read into cache : <num>,
         bytes written from cache : <num>,
         cache overflow cursor application thread wait time (usecs) : <num>,
         cache overflow cursor internal thread wait time (usecs) : <num>,
         cache overflow score : <num>,
         cache overflow table entries : <num>,
         cache overflow table insert calls : <num>,
         cache overflow table max on-disk size : <num>,
         cache overflow table on-disk size : <num>,
         cache overflow table remove calls : <num>,
         checkpoint blocked page eviction : <num>,
         eviction calls to get a page : <num>,
         eviction calls to get a page found queue empty : <num>,
         eviction calls to get a page found queue empty after locking : <num>,
         eviction currently operating in aggressive mode : <num>,
         eviction empty score : <num>,
         eviction passes of a file : <num>,
         eviction server candidate queue empty when topping up : <num>,
         eviction server candidate queue not empty when topping up : <num>,
         eviction server evicting pages : <num>,
         eviction server slept, because we did not make progress with eviction : <num>,
         eviction server unable to reach eviction goal : <num>,
         eviction server waiting for a leaf page : <num>,
         eviction server waiting for an internal page sleep (usec) : <num>,
         eviction server waiting for an internal page yields : <num>,
         eviction state : <num>,
         eviction walk target pages histogram - 0-9 : <num>,
         eviction walk target pages histogram - 10-31 : <num>,
         eviction walk target pages histogram - 128 and higher : <num>,
         eviction walk target pages histogram - 32-63 : <num>,
         eviction walk target pages histogram - 64-128 : <num>,
         eviction walks abandoned : <num>,
         eviction walks gave up because they restarted their walk twice : <num>,
         eviction walks gave up because they saw too many pages and found no candidates : <num>,
         eviction walks gave up because they saw too many pages and found too few candidates : <num>,
         eviction walks reached end of tree : <num>,
         eviction walks started from root of tree : <num>,
         eviction walks started from saved location in tree : <num>,
         eviction worker thread active : <num>,
         eviction worker thread created : <num>,
         eviction worker thread evicting pages : <num>,
         eviction worker thread removed : <num>,
         eviction worker thread stable number : <num>,
         files with active eviction walks : <num>,
         files with new eviction walks started : <num>,
         force re-tuning of eviction workers once in a while : <num>,
         forced eviction - pages evicted that were clean count : <num>,
         forced eviction - pages evicted that were clean time (usecs) : <num>,
         forced eviction - pages evicted that were dirty count : <num>,
         forced eviction - pages evicted that were dirty time (usecs) : <num>,
         forced eviction - pages selected because of too many deleted items count : <num>,
         forced eviction - pages selected count : <num>,
         forced eviction - pages selected unable to be evicted count : <num>,
         forced eviction - pages selected unable to be evicted time : <num>,
         hazard pointer blocked page eviction : <num>,
         hazard pointer check calls : <num>,
         hazard pointer check entries walked : <num>,
         hazard pointer maximum array length : <num>,
         in-memory page passed criteria to be split : <num>,
         in-memory page splits : <num>,
         internal pages evicted : <num>,
         internal pages split during eviction : <num>,
         leaf pages split during eviction : <num>,
         maximum bytes configured : <num>,
         maximum page size seen at eviction : <num>,
         modified pages evicted : <num>,
         modified pages evicted by application threads : <num>,
         operations timed out waiting for space in cache : <num>,
         overflow pages read into cache : <num>,
         page split during eviction deepened the tree : <num>,
         page written requiring cache overflow records : <num>,
         pages currently held in the cache : <num>,
         pages evicted by application threads : <num>,
         pages queued for eviction : <num>,
         pages queued for eviction post lru sorting : <num>,
         pages queued for urgent eviction : <num>,
         pages queued for urgent eviction during walk : <num>,
         pages read into cache : <num>,
         pages read into cache after truncate : <num>,
         pages read into cache after truncate in prepare state : <num>,
         pages read into cache requiring cache overflow entries : <num>,
         pages read into cache requiring cache overflow for checkpoint : <num>,
         pages read into cache skipping older cache overflow entries : <num>,
         pages read into cache with skipped cache overflow entries needed later : <num>,
         pages read into cache with skipped cache overflow entries needed later by checkpoint : <num>,
         pages requested from the cache : <num>,
         pages seen by eviction walk : <num>,
         pages selected for eviction unable to be evicted : <num>,
         pages walked for eviction : <num>,
         pages written from cache : <num>,
         pages written requiring in-memory restoration : <num>,
         percentage overhead : <num>,
         tracked bytes belonging to internal pages in the cache : <num>,
         tracked bytes belonging to leaf pages in the cache : <num>,
         tracked dirty bytes in the cache : <num>,
         tracked dirty pages in the cache : <num>,
         unmodified pages evicted : <num>
      },
      capacity : {
         background fsync file handles considered : <num>,
         background fsync file handles synced : <num>,
         background fsync time (msecs) : <num>,
         bytes read : <num>,
         bytes written for checkpoint : <num>,
         bytes written for eviction : <num>,
         bytes written for log : <num>,
         bytes written total : <num>,
         threshold to call fsync : <num>,
         time waiting due to total capacity (usecs) : <num>,
         time waiting during checkpoint (usecs) : <num>,
         time waiting during eviction (usecs) : <num>,
         time waiting during logging (usecs) : <num>,
         time waiting during read (usecs) : <num>
      },
      connection : {
         auto adjusting condition resets : <num>,
         auto adjusting condition wait calls : <num>,
         detected system time went backwards : <num>,
         files currently open : <num>,
         memory allocations : <num>,
         memory frees : <num>,
         memory re-allocations : <num>,
         pthread mutex condition wait calls : <num>,
         pthread mutex shared lock read-lock calls : <num>,
         pthread mutex shared lock write-lock calls : <num>,
         total fsync I/Os : <num>,
         total read I/Os : <num>,
         total write I/Os : <num>
      },
      cursor : {
         cached cursor count : <num>,
         cursor bulk loaded cursor insert calls : <num>,
         cursor close calls that result in cache : <num>,
         cursor create calls : <num>,
         cursor insert calls : <num>,
         cursor insert key and value bytes : <num>,
         cursor modify calls : <num>,
         cursor modify key and value bytes affected : <num>,
         cursor modify value bytes modified : <num>,
         cursor next calls : <num>,
         cursor operation restarted : <num>,
         cursor prev calls : <num>,
         cursor remove calls : <num>,
         cursor remove key bytes removed : <num>,
         cursor reserve calls : <num>,
         cursor reset calls : <num>,
         cursor search calls : <num>,
         cursor search near calls : <num>,
         cursor sweep buckets : <num>,
         cursor sweep cursors closed : <num>,
         cursor sweep cursors examined : <num>,
         cursor sweeps : <num>,
         cursor truncate calls : <num>,
         cursor update calls : <num>,
         cursor update key and value bytes : <num>,
         cursor update value size change : <num>,
         cursors reused from cache : <num>,
         open cursor count : <num>
      },
      data-handle : {
         connection data handle size : <num>,
         connection data handles currently active : <num>,
         connection sweep candidate became referenced : <num>,
         connection sweep dhandles closed : <num>,
         connection sweep dhandles removed from hash list : <num>,
         connection sweep time-of-death sets : <num>,
         connection sweeps : <num>,
         session dhandles swept : <num>,
         session sweep attempts : <num>
      },
      lock : {
         checkpoint lock acquisitions : <num>,
         checkpoint lock application thread wait time (usecs) : <num>,
         checkpoint lock internal thread wait time (usecs) : <num>,
         dhandle lock application thread time waiting (usecs) : <num>,
         dhandle lock internal thread time waiting (usecs) : <num>,
         dhandle read lock acquisitions : <num>,
         dhandle write lock acquisitions : <num>,
         durable timestamp queue lock application thread time waiting (usecs) : <num>,
         durable timestamp queue lock internal thread time waiting (usecs) : <num>,
         durable timestamp queue read lock acquisitions : <num>,
         durable timestamp queue write lock acquisitions : <num>,
         metadata lock acquisitions : <num>,
         metadata lock application thread wait time (usecs) : <num>,
         metadata lock internal thread wait time (usecs) : <num>,
         read timestamp queue lock application thread time waiting (usecs) : <num>,
         read timestamp queue lock internal thread time waiting (usecs) : <num>,
         read timestamp queue read lock acquisitions : <num>,
         read timestamp queue write lock acquisitions : <num>,
         schema lock acquisitions : <num>,
         schema lock application thread wait time (usecs) : <num>,
         schema lock internal thread wait time (usecs) : <num>,
         table lock application thread time waiting for the table lock (usecs) : <num>,
         table lock internal thread time waiting for the table lock (usecs) : <num>,
         table read lock acquisitions : <num>,
         table write lock acquisitions : <num>,
         txn global lock application thread time waiting (usecs) : <num>,
         txn global lock internal thread time waiting (usecs) : <num>,
         txn global read lock acquisitions : <num>,
         txn global write lock acquisitions : <num>
      },
      log : {
         busy returns attempting to switch slots : <num>,
         force archive time sleeping (usecs) : <num>,
         log bytes of payload data : <num>,
         log bytes written : <num>,
         log files manually zero-filled : <num>,
         log flush operations : <num>,
         log force write operations : <num>,
         log force write operations skipped : <num>,
         log records compressed : <num>,
         log records not compressed : <num>,
         log records too small to compress : <num>,
         log release advances write LSN : <num>,
         log scan operations : <num>,
         log scan records requiring two reads : <num>,
         log server thread advances write LSN : <num>,
         log server thread write LSN walk skipped : <num>,
         log sync operations : <num>,
         log sync time duration (usecs) : <num>,
         log sync_dir operations : <num>,
         log sync_dir time duration (usecs) : <num>,
         log write operations : <num>,
         logging bytes consolidated : <num>,
         maximum log file size : <num>,
         number of pre-allocated log files to create : <num>,
         pre-allocated log files not ready and missed : <num>,
         pre-allocated log files prepared : <num>,
         pre-allocated log files used : <num>,
         records processed by log scan : <num>,
         slot close lost race : <num>,
         slot close unbuffered waits : <num>,
         slot closures : <num>,
         slot join atomic update races : <num>,
         slot join calls atomic updates raced : <num>,
         slot join calls did not yield : <num>,
         slot join calls found active slot closed : <num>,
         slot join calls slept : <num>,
         slot join calls yielded : <num>,
         slot join found active slot closed : <num>,
         slot joins yield time (usecs) : <num>,
         slot transitions unable to find free slot : <num>,
         slot unbuffered writes : <num>,
         total in-memory size of compressed records : <num>,
         total log buffer size : <num>,
         total size of compressed records : <num>,
         written slots coalesced : <num>,
         yields waiting for previous log file close : <num>
      },
      perf : {
         file system read latency histogram (bucket 1) - 10-49ms : <num>,
         file system read latency histogram (bucket 2) - 50-99ms : <num>,
         file system read latency histogram (bucket 3) - 100-249ms : <num>,
         file system read latency histogram (bucket 4) - 250-499ms : <num>,
         file system read latency histogram (bucket 5) - 500-999ms : <num>,
         file system read latency histogram (bucket 6) - 1000ms+ : <num>,
         file system write latency histogram (bucket 1) - 10-49ms : <num>,
         file system write latency histogram (bucket 2) - 50-99ms : <num>,
         file system write latency histogram (bucket 3) - 100-249ms : <num>,
         file system write latency histogram (bucket 4) - 250-499ms : <num>,
         file system write latency histogram (bucket 5) - 500-999ms : <num>,
         file system write latency histogram (bucket 6) - 1000ms+ : <num>,
         operation read latency histogram (bucket 1) - 100-249us : <num>,
         operation read latency histogram (bucket 2) - 250-499us : <num>,
         operation read latency histogram (bucket 3) - 500-999us : <num>,
         operation read latency histogram (bucket 4) - 1000-9999us : <num>,
         operation read latency histogram (bucket 5) - 10000us+ : <num>,
         operation write latency histogram (bucket 1) - 100-249us : <num>,
         operation write latency histogram (bucket 2) - 250-499us : <num>,
         operation write latency histogram (bucket 3) - 500-999us : <num>,
         operation write latency histogram (bucket 4) - 1000-9999us : <num>,
         operation write latency histogram (bucket 5) - 10000us+ : <num>
      },
      reconciliation : {
         fast-path pages deleted : <num>,
         page reconciliation calls : <num>,
         page reconciliation calls for eviction : <num>,
         pages deleted : <num>,
         split bytes currently awaiting free : <num>,
         split objects currently awaiting free : <num>
      },
      session : {
         open session count : <num>,
         session query timestamp calls : <num>,
         table alter failed calls : <num>,
         table alter successful calls : <num>,
         table alter unchanged and skipped : <num>,
         table compact failed calls : <num>,
         table compact successful calls : <num>,
         table create failed calls : <num>,
         table create successful calls : <num>,
         table drop failed calls : <num>,
         table drop successful calls : <num>,
         table import failed calls : <num>,
         table import successful calls : <num>,
         table rebalance failed calls : <num>,
         table rebalance successful calls : <num>,
         table rename failed calls : <num>,
         table rename successful calls : <num>,
         table salvage failed calls : <num>,
         table salvage successful calls : <num>,
         table truncate failed calls : <num>,
         table truncate successful calls : <num>,
         table verify failed calls : <num>,
         table verify successful calls : <num>
      },
      thread-state : {
         active filesystem fsync calls : <num>,
         active filesystem read calls : <num>,
         active filesystem write calls : <num>
      },
      thread-yield : {
         application thread time evicting (usecs) : <num>,
         application thread time waiting for cache (usecs) : <num>,
         connection close blocked waiting for transaction state stabilization : <num>,
         connection close yielded for lsm manager shutdown : <num>,
         data handle lock yielded : <num>,
         get reference for page index and slot time sleeping (usecs) : <num>,
         log server sync yielded for log write : <num>,
         page access yielded due to prepare state change : <num>,
         page acquire busy blocked : <num>,
         page acquire eviction blocked : <num>,
         page acquire locked blocked : <num>,
         page acquire read blocked : <num>,
         page acquire time sleeping (usecs) : <num>,
         page delete rollback time sleeping for state change (usecs) : <num>,
         page reconciliation yielded due to child modification : <num>
      },
      transaction : {
         Number of prepared updates : <num>,
         Number of prepared updates added to cache overflow : <num>,
         Number of prepared updates resolved : <num>,
         durable timestamp queue entries walked : <num>,
         durable timestamp queue insert to empty : <num>,
         durable timestamp queue inserts to head : <num>,
         durable timestamp queue inserts total : <num>,
         durable timestamp queue length : <num>,
         number of named snapshots created : <num>,
         number of named snapshots dropped : <num>,
         prepared transactions : <num>,
         prepared transactions committed : <num>,
         prepared transactions currently active : <num>,
         prepared transactions rolled back : <num>,
         query timestamp calls : <num>,
         read timestamp queue entries walked : <num>,
         read timestamp queue insert to empty : <num>,
         read timestamp queue inserts to head : <num>,
         read timestamp queue inserts total : <num>,
         read timestamp queue length : <num>,
         rollback to stable calls : <num>,
         rollback to stable updates aborted : <num>,
         rollback to stable updates removed from cache overflow : <num>,
         set timestamp calls : <num>,
         set timestamp durable calls : <num>,
         set timestamp durable updates : <num>,
         set timestamp oldest calls : <num>,
         set timestamp oldest updates : <num>,
         set timestamp stable calls : <num>,
         set timestamp stable updates : <num>,
         transaction begins : <num>,
         transaction checkpoint currently running : <num>,
         transaction checkpoint generation : <num>,
         transaction checkpoint max time (msecs) : <num>,
         transaction checkpoint min time (msecs) : <num>,
         transaction checkpoint most recent time (msecs) : <num>,
         transaction checkpoint scrub dirty target : <num>,
         transaction checkpoint scrub time (msecs) : <num>,
         transaction checkpoint total time (msecs) : <num>,
         transaction checkpoints : <num>,
         transaction checkpoints skipped because database was clean : <num>,
         transaction failures due to cache overflow : <num>,
         transaction fsync calls for checkpoint after allocating the transaction ID : <num>,
         transaction fsync duration for checkpoint after allocating the transaction ID (usecs) : <num>,
         transaction range of IDs currently pinned : <num>,
         transaction range of IDs currently pinned by a checkpoint : <num>,
         transaction range of IDs currently pinned by named snapshots : <num>,
         transaction range of timestamps currently pinned : <num>,
         transaction range of timestamps pinned by a checkpoint : <num>,
         transaction range of timestamps pinned by the oldest active read timestamp : <num>,
         transaction range of timestamps pinned by the oldest timestamp : <num>,
         transaction read timestamp of the oldest active reader : <num>,
         transaction sync calls : <num>,
         transactions committed : <num>,
         transactions rolled back : <num>,
         update conflicts : <num>
      },
      concurrentTransactions : {
         write : {
            out : <num>,
            available : <num>,
            totalTickets : <num>
         },
         read : {
            out : <num>,
            available : <num>,
            totalTickets : <num>
         },
         monitor : { 
            timesDecreased: <num>, 
            timesIncreased: <num>, 
            totalAmountDecreased: <num>, 
            totalAmountIncreased: <num>
         }
      },
      snapshot-window-settings : {
         total number of SnapshotTooOld errors : <num>,
         max target available snapshots window size in seconds : <num>,
         target available snapshots window size in seconds : <num>,
         current available snapshots window size in seconds : <num>,
         latest majority snapshot timestamp available : <string>,
         oldest majority snapshot timestamp available : <string>
      }
   }

.. note::

   The following is not an exhaustive list.

.. serverstatus:: wiredTiger.uri

   A string. For internal use by MongoDB.

.. serverstatus:: wiredTiger.async

   A document that returns statistics related to the asynchronous
   operations API. This is unused by MongoDB.

.. serverstatus:: wiredTiger.block-manager

   A document that returns statistics on the block manager operations.

.. serverstatus:: wiredTiger.cache

   A document that returns statistics on the cache and page evictions
   from the cache.

   The following describes some of the key
   :serverstatus:`wiredTiger.cache` statistics:

   .. serverstatus:: wiredTiger.cache.maximum bytes configured

      Maximum cache size.

   .. serverstatus:: wiredTiger.cache.bytes currently in the cache

      Size in bytes of the data currently in cache. This value should
      not be greater than the ``maximum bytes configured`` value.

   .. serverstatus:: wiredTiger.cache.unmodified pages evicted

      Main statistics for page eviction.

   .. serverstatus:: wiredTiger.cache.tracked dirty bytes in the cache

      Size in bytes of the dirty data in the cache. This value should
      be less than the ``bytes currently in the cache`` value.

   .. serverstatus:: wiredTiger.cache.pages read into cache

      Number of pages read into the cache.
      :serverstatus:`wiredTiger.cache.pages read into cache` with
      the :serverstatus:`wiredTiger.cache.pages written from
      cache` can provide an overview of the I/O activity.

   .. serverstatus:: wiredTiger.cache.pages written from cache

      Number of pages written from the cache.
      :serverstatus:`wiredTiger.cache.pages written from cache`
      with the :serverstatus:`wiredTiger.cache.pages read into
      cache` can provide an overview of the I/O activity.

   .. include:: /includes/extracts/wt-cache-setting.rst

.. serverstatus:: wiredTiger.connection

   A document that returns statistics related to WiredTiger connections.

.. serverstatus:: wiredTiger.cursor

   A document that returns statistics on WiredTiger cursor.

.. serverstatus:: wiredTiger.data-handle

   A document that returns statistics on the data handles and sweeps.

.. serverstatus:: wiredTiger.log

   A document that returns statistics on WiredTiger's write ahead log
   (i.e. the journal).

   .. seealso::

      :ref:`journaling-wiredTiger`

.. serverstatus:: wiredTiger.reconciliation

   A document that returns statistics on the reconciliation process.

.. serverstatus:: wiredTiger.session

   A document that returns the open cursor count and open session count
   for the session.

.. serverstatus:: wiredTiger.thread-yield

   A document that returns statistics on yields during page
   acquisitions.

.. serverstatus:: wiredTiger.transaction

   A document that returns statistics on transaction checkpoints and
   operations.

   .. serverstatus:: wiredTiger.transaction.transaction checkpoint most recent time (msecs)

      Amount of time, in milliseconds, to create the most recent
      checkpoint. An increase in this value under stead write load may
      indicate saturation on the I/O subsystem.

.. serverstatus:: wiredTiger.concurrentTransactions

   .. versionchanged:: 7.0

   A document that returns information about: 

   - The number of concurrent read transactions (read tickets) allowed 
     into the WiredTiger storage engine.
   - The number of concurrent write transactions (write tickets) allowed 
     into the WiredTiger storage engine. 
   - Any adjustments that the system has made to the number
     of allowed concurrent transactions (tickets).
   
   These settings are MongoDB-specific. To change the settings for 
   concurrent reads and write transactions (read and write tickets), see
   :parameter:`storageEngineConcurrentReadTransactions` and
   :parameter:`storageEngineConcurrentWriteTransactions`.

   .. important::

      .. include:: /includes/7.0-concurrent-transactions.rst

.. _server-status-writebacksqueued:
.. _server-status-write-backs-queued:

writeBacksQueued
~~~~~~~~~~~~~~~~

.. code-block:: javascript

   writeBacksQueued : <boolean>,

.. serverstatus:: writeBacksQueued

   A boolean that indicates whether there are operations from a
   :binary:`~bin.mongos` instance queued for retrying. Typically, this
   value is false.  See also :term:`writeBacks`.