serverStatus（数据库命令）

排除所有可选字段

从MongoDB 7.0.38 开始，您可以通过指定 none: 1 从 serverStatus 输出中排除所有可选字段。排除所有可选字段后，您可以指定要包含的字段。

此示例使用 none 最初从输出中排除所有可选字段，然后包含 locks文档。

db.runCommand({ serverStatus: 1, none: 1, locks: 1 })

初始化

The statistics reported by serverStatus are reset when the mongod server is restarted.

此命令始终返回一个值，即使对新数据库也是如此。相关命令 db.serverStatus() 并不总是返回值，除非特定指标的计数器开始增加。

运行更新查询后，db.serverStatus() 和db.runCommand({ serverStatus: 1}) 都返回相同的值。

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

包括 latchAnalysis

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

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

更改tcmalloc 详细程度

默认情况下，输出中包含 tcmalloc 信息。本部分提供数据库的内存分配统计信息。要更改 tcmalloc 部分的详细程度，请指定一个介于 0 和2（含）之间的整数：

db.runCommand( { serverStatus: 1, tcmalloc: <int> } )

该命令的行为如下：

• 默认情况下，tcmalloc 设置为 1。

• 传递较大的整数值会提高详细程度。

• 传递 0 或 false 将忽略输出中的 tcmalloc 部分。

• 传递任何其他输入都会采用默认设置。

有关 MongoDB 如何分配内存的更多信息，请参阅 TCMalloc。

断言

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

asserts

一个文档，其中报告自 MongoDB 进程启动以来引发的断言数量。断言是对数据库运行时发生的错误的内部检查，可以帮助诊断 MongoDB 服务器的问题。非零断言值表示断言错误，这种错误并不常见，也不是什么值得立即关注的问题。生成断言的错误可以记录在日志文件中，或直接返回到客户端应用程序以获取更多信息。

asserts.regular

自 MongoDB 进程启动以来提出的常规断言数量。检查 MongoDB 日志以获取更多信息。

asserts.warning

该字段始终返回零值 0。

asserts.msg

自 MongoDB 进程启动以来提出的消息断言数量。检查日志文件以获取有关这些消息的详细信息。

asserts.user

自上次启动 MongoDB 进程以来发生的“用户断言”的数量。这些是用户可能生成的错误，例如磁盘空间不足或重复密钥。您可以通过修复应用程序或部署的问题来防止这些断言。服务器日志中关于“用户断言”的信息可能有限。要了解有关“用户断言”来源的更多信息，请检查应用程序日志中的应用程序错误。

asserts.rollovers

自上次启动MongoDB进程以来断言计数器滚动的次数。在 个2³⁰ 断言后，计数器将翻转为零。使用此值可为asserts 数据结构中的其他值提供上下文。

batchedDeletes

batchedDeletes: {
   batches: <num>,
   docs: <num>,
   stagedSizeBytes: <num>,
   timeInBatchMillis: <num>,
   refetchesDueToYield: <num>
},

报告与所有批量删除相关的指标的文档。

batchedDeletes 返回以下指标：

bucketCatalog

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

报告时间序列集合的内部存储相关指标的文档。

bucketCatalog 返回以下指标：

您还可以使用 $collStats 聚合管道阶段来查找时间序列指标。要了解更多信息，请参阅时间序列集合上的 storageStats 输出。

catalogStats

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

catalogStats

通过集合计数报告集合使用情况统计信息的文档。

catalogStats.collections

用户集合总数（不包括系统集合）。

catalogStats.capped

固定大小用户集合的总数。

catalogStats.views

用户浏览总数。

catalogStats.timeseries

时间序列集合的总数。

catalogStats.internalCollections

系统集合（config、admin 或 local 数据库上的集合）的总数。

catalogStats.internalViews

系统集合（config、admin或 local 数据库上的集合）的视图总数。

catalogStats.csfle

7.0.1版本新增。

The total number of collections configured for Client-Side Field Level Encryption (collections with an encrypted validator).

catalogStats.queryableEncryption

7.0.1版本新增。

The total number of collections configured for Queryable Encryption (collections with encryptedFields).

catalogStats.systemProfile

所有数据库上的 profile 集合总数。

连接

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>
},

connections

报告连接状态的一份文档。使用这些值来评估服务器当前的负载和容量要求。

connections.current

The number of incoming connections from clients to the database server. This includes connections from the current shell session and from other servers, such as replica set members and mongos instances. Consider the value of connections.available for additional context.

connections.available

The number of unused incoming connections available. Consider this value in combination with the value of connections.current to understand the connection load on the database, and the UNIX ulimit Settings for Self-Managed Deployments document for more information about system thresholds on available connections.

connections.totalCreated

创建到服务器的所有传入连接的计数。此数字包括已关闭的连接。

connections.rejected

6.3版本新增。

服务器因服务器没有能力接受更多连接或达到 net.maxIncomingConnections 设置而拒绝的传入连接的数量。

connections.active

与服务器的活跃客户端连接数。活跃客户端连接系指当前正在进行操作的客户端连接。

connections.threaded

为客户端请求提供服务的线程所分配的客户端传入连接数。

版本 5.0 中的新增功能。

connections.exhaustIsMaster

最后一个请求是指定 exhausAllowed 的 isMaster 请求的连接的数量。

注意

如果运行的是 MongoDB 5.0 或更高版本，请勿使用 isMaster 命令。请改用 hello。

connections.exhaustHello

最后请求是指定 ExhaustAllowed 的 hello 请求的连接的数量。

版本 5.0 中的新增功能。

connections.awaitingTopologyChanges

当前在 hello 或 isMaster 请求中等待拓扑结构更改的客户端的数量。

注意

如果运行的是 MongoDB 5.0 或更高版本，请勿使用 isMaster 命令。请改用 hello。

connections.loadBalanced

5.3版本新增。

当前通过负载均衡器接收到的传入连接数。

defaultRWConcern

defaultRWConcern 部分提供有关全局默认读关注或写关注设置的本地副本的信息。数据可能已过时或已过期。有关更多信息，请参阅 getDefaultRWConcern。

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

defaultRWConcern

上次已知的全局默认读关注或写关注设置。

defaultRWConcern.defaultReadConcern

上次已知的全局默认读关注设置。

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

defaultRWConcern.defaultReadConcern.level

上次已知的全局默认读关注级别设置。

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

defaultRWConcern.defaultWriteConcern

上次已知的全局默认写关注设置。

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

defaultRWConcern.defaultWriteConcern.w

上次已知的全局默认 w 设置。

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

defaultRWConcern.defaultWriteConcern.wtimeout

上次已知的全局默认 wtimeout 设置。

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

defaultRWConcern.defaultWriteConcernSource

默认写关注的来源。默认情况下，该值为 "implicit"。使用 setDefaultRWConcern 完成设置默认写关注后，该值即变为 "global"。

版本 5.0 中的新增功能。

defaultRWConcern.defaultReadConcernSource

默认读关注的来源。默认情况下，该值为 "implicit"。使用 setDefaultRWConcern 完成设置默认读关注后，该值即变为 "global"。

版本 5.0 中的新增功能。

defaultRWConcern.updateOpTime

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

defaultRWConcern.updateWallClockTime

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

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 defaultRWConcern, the instance has never had knowledge of a global default read or write concern setting.

electionMetrics

electionMetrics 部分提供有关此 mongod 实例试图成为主节点而调用的选举的信息：

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>
}

electionMetrics.stepUpCmd

当主节点降级后，作为选举移交的一部分，由 mongod 实例调用的选举指标。

The stepUpCmd includes both the number of elections called and the number of elections that succeeded.

electionMetrics.priorityTakeover

mongod 实例调用的选举指标，因为其 priority 高于主节点。

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

electionMetrics.catchUpTakeover

mongod 实例调用的选举指标，因为它比主节点的日期更近。

The catchUpTakeover includes both the number of elections called and the number of elections that succeeded.

提示

settings.catchUpTakeoverDelayMillis

electionMetrics.electionTimeout

mongod 实例调用的选举指标，因为它无法在 settings.electionTimeoutMillis 内到达主节点。

The electionTimeout includes both the number of elections called and the number of elections that succeeded.

提示

settings.electionTimeoutMillis

electionMetrics.freezeTimeout

mongod 实例在其 freeze period（在此期间，节点无法寻求选举）到期后调用的选举指标。

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

electionMetrics.numStepDownsCausedByHigherTerm

mongod 实例因看到更高任期（具体来说，其他节点参与了额外选举）而降级的次数。

electionMetrics.numCatchUps

作为新当选主节点的 mongod 实例必须赶上已知最高 oplog 条目的选举次数。

electionMetrics.numCatchUpsSucceeded

作为新当选主节点的 mongod 实例成功赶上已知最高 oplog 条目的次数。

electionMetrics.numCatchUpsAlreadyCaughtUp

作为新当选主节点的 mongod 实例由于当选时已被赶上而结束其追赶进程的次数。

electionMetrics.numCatchUpsSkipped

作为新当选主节点的 mongod 实例跳过追赶进程的次数。

electionMetrics.numCatchUpsTimedOut

作为新当选主节点的 mongod 实例由于 settings.catchUpTimeoutMillis 限制而结束其追赶进程的次数。

electionMetrics.numCatchUpsFailedWithError

新当选主节点的追赶进程因出错导致失败的次数。

electionMetrics.numCatchUpsFailedWithNewTerm

其他一名（或多名成员）的任期较长（具体而言，其他成员参加了额外的选举），导致新当选主节点的追赶进程终止的次数。

electionMetrics.numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd

由于 mongod 收到 replSetAbortPrimaryCatchUp 命令而导致新当选主节点的追赶进程结束的次数。

electionMetrics.averageCatchUpOps

新当选的主节点在追赶进程时所应用操作的平均次数。

extra_info

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

extra_info

提供有关底层系统的其他信息的文档。

extra_info.note

带以下文本的字符串： 'fields vary by platform'

extra_info.page_faults

The total number of page faults. The 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 区分涉及磁盘 I/O 的“硬”页面错误与仅需要在内存中移动页面的“软”页面错误。MongoDB 在该统计中同时计入硬页面错误和软页面错误。

flowControl

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

flowControl

返回流量控制统计信息的文档。启用流量控制后，随着 majority commit 点滞后逐渐接近 flowControlTargetLagSeconds，主节点上的写入操作先获取票证才能获取锁。因此，在主节点上运行时，返回的指标很有意义。

flowControl.enabled

一个布尔值，用于表示流量控制处于启用状态 (true) 还是禁用状态 (false)。

另请参阅 enableFlowControl 。

flowControl.targetRateLimit

在主节点上运行时，每秒可获取的最大票证数。

在从节点上运行时，返回的数字是占位符。

flowControl.timeAcquiringMicros

在主节点上运行时，写入操作等待获取票证的总时间。

在从节点上运行时，返回的数字是占位符。

flowControl.locksPerKiloOp

在主节点上运行时，表示每 1000 次操作占用的锁数的近似值。

在从节点上运行时，返回的数字是占位符。

flowControl.sustainerRate

在主节点上运行时，维持提交点的从节点每秒应用的操作的近似值。

在从节点上运行时，返回的数字是占位符。

flowControl.isLagged

在主节点上运行时，为一个布尔值，指示流量控制是否已启用。当多数提交延迟大于配置的 flowControlTargetLagSeconds 的某个百分比时，将会启用流量控制。

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

有关其他信息，请参阅流量控制。

flowControl.isLaggedCount

在主节点上运行时，流量控制自上次重启以来启用的次数。当多数提交延迟大于 flowControlTargetLagSeconds 的某个百分比时，将会启用流量控制。

在从节点上运行时，返回的数字是占位符。

flowControl.isLaggedTimeMicros

在主节点上运行时，流量控制自上次重启以来启用所用的时间。当多数提交延迟大于 flowControlTargetLagSeconds 的某个百分比时，将会启用流量控制。

在从节点上运行时，返回的数字是占位符。

globalLock

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

globalLock

一个文档，其中报告数据库锁定状态。

一般来说，锁文档会提供有关锁使用情况的更详细数据。

globalLock.totalTime

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

globalLock.currentQueue

提供有关因为锁定而排队的操作数量信息的文档。

globalLock.currentQueue.total

The total number of operations queued waiting for the lock (that is, the sum of globalLock.currentQueue.readers and globalLock.currentQueue.writers).

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

globalLock.currentQueue.readers

当前排队并等待读锁的操作数。不必担心持续较小的读取队列，尤其是短操作的队列。

globalLock.currentQueue.writers

当前排队并等待写锁的操作数。不必担心持续较小的写队列，尤其是短操作的队列。

globalLock.activeClients

提供已连接客户端数量以及这些客户端执行的读写操作相关信息的文档。

Use this data to provide context for the globalLock.currentQueue data.

globalLock.activeClients.total

对数据库的内部客户端连接总数，包括系统线程以及排队的读取器和写入器。由于包含系统线程，该指标高于 activeClients.readers 和 activeClients.writers 的总和。

globalLock.activeClients.readers

执行读取操作的活动客户端连接的数量。

globalLock.activeClients.writers

执行写入操作的活动客户端连接的数量。

hedgingMetrics

仅适用于 mongos 实例。

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

hedgingMetrics

提供 mongos 实例的对冲读指标。

仅适用于 mongos 实例。

hedgingMetrics.numTotalOperations

为此 mongos 实例启用了对冲读选项后发出的操作总数。

仅适用于 mongos 实例。

hedgingMetrics.numTotalHedgedOperations

mongos 实例对冲读操作的所有操作的数量；即将该操作发送到每个查询分片的附加节点。

仅适用于 mongos 实例。

hedgingMetrics.numAdvantageouslyHedgedOperations

为满足客户端请求而发送到对冲读操作的附加读操作的总数。

仅适用于 mongos 实例。

indexBuilds

indexBuilds : {
   total : <num>,
   phases : {
      scanCollection : <num>,
      drainSideWritesTable: <num>,
      drainSideWritesTablePreCommit: <num>,
      waitForCommitQuorum: <num>,
      drainSideWritesTableOnCommit: <num>,
      processConstraintsViolatonTableOnCommit: <num>,
      commit: <num>
   }
}

indexBuilds

为索引构建提供指标的文档。使用这些指标来诊断索引构建问题。

注意

indexBuilds replaces the activeIndexBuilds field.

6.1版本新增。

indexBuilds.total

正在进行和已完成的索引构建总数。

6.1版本新增。

indexBuilds.phases

为索引构建过程的每个阶段提供计数器的文档。当索引构建达到指定阶段时，indexBuilds.phases 下的每个子字段都会递增。

6.1版本新增。

IndexBulkBuilder

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

indexBulkBuilder

提供索引批量构建器操作的指标。使用这些指标可诊断使用 createIndexes 构建索引的问题、初始同步期间的集合克隆、启动后恢复的索引构建，以及外部排序器磁盘使用情况的统计信息。

indexBulkBuilder.bytesSpilled

6.0.4版本新增。

外部排序器写入磁盘的字节数。

indexBulkBuilder.bytesSpilledUncompressed

6.0.4版本新增。

压缩前外部排序器写入磁盘的字节数。

indexBulkBuilder.count

创建的批量构建器的实例数。

indexBulkBuilder.filesClosedForExternalSort

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

indexBulkBuilder.filesOpenedForExternalSort

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

indexBulkBuilder.resumed

为可恢复索引构建创建批量构建器的次数。

indexBulkBuilder.spilledRanges

6.0.4版本新增。

外部排序器溢出到磁盘的次数。

indexBulkBuilder.numSorted

6.3版本新增。

已排序文档的总数。

indexBulkBuilder.bytesSorted

6.3版本新增。

已排序文档的字节总数。例如，如果总共对 10 个文档进行了排序，每个文档为 20 字节，则已排序的字节总数为 200。

indexBulkBuilder.memUsage

6.3版本新增。

为构建索引分配的当前内存字节数。

indexStats

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>") },
      prepareUnique: { count: Long("<num>"), accesses: Long("<num>") }, // Added in 7.0.14 (and 6.0.20)
      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>") }
   }
}

indexStats

一个文档，仅报告非系统命名空间中数据库和集合的所有索引的统计信息。indexStats 不报告 admin、local 和 config 数据库中索引的统计信息。

6.0版本新增。

indexStats.count

索引总数。

6.0版本新增。

indexStats.features

提供每种索引类型的计数器以及每个索引的访问次数的文档。 indexStats.features下的每个索引类型都有一个计算该类型索引总数的字段count和一个计算该索引访问次数的字段accesses。

6.0版本新增。

实例信息

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

host

系统的主机名。在 Unix/Linux 系统中，这应该与hostname 命令的输出相同。

advisoryHostFQDNs

系统的完全限定域名 (FQDN) 的数组。

version

当前 MongoDB 进程的 MongoDB 版本。

process

当前的 MongoDB 进程。可能的值为：mongos 或 mongod。

pid

进程 ID 号。

uptime

当前 MongoDB 进程处于活动状态的秒数。

uptimeMillis

当前 MongoDB 进程处于活动状态的毫秒数。

uptimeEstimate

根据 MongoDB 的内部粗粒度计时系统计算的正常运行时间（以秒为单位）。

localTime

ISODate 根据服务器以 UTC 方式当前时间。

latchAnalysis

latchAnalysis : {
   <latch name> : {
      created : <num>,
      destroyed : <num>,
      acquired : <num>,
      released : <num>,
      contended : <num>,
      hierarchicalAcquisitionLevelViolations : {
            onAcquire : <num>,
            onRelease : <num>
      }
   },
   ...

latchAnalysis

一份报告与内部锁原语（也称为闩锁）相关的指标的文档。

要返回 latchAnalysis 信息，必须明确指定包含的内容：

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

latchAnalysis 为每个锁存器返回 <latch name> 和以下关联指标：

衡量标准	说明
created	创建锁存器的次数。
destroyed	销毁锁存器的次数。
acquired	获取闩锁的次数。
released	释放锁存器的次数。
contended	闩锁发生争用的次数。
hierarchicalAcquisitionLevelViolations	仅当存在违规时才返回 包含以下字段： onAcquire 在获取闩锁期间违反闩锁层次结构（即闩锁级别顺序）的次数。 onRelease 在释放闩锁期间违反闩锁层次结构（即闩锁级别顺序）的次数。

4.4版本新增。

锁

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

locks

报告每个锁 <type> 以及锁 <modes> 上的数据的文档。

可能的锁 <types> 是：

锁类型	说明
ParallelBatchWriterMode	代表并行批量写入模式的锁。 在早期版本中，PBWM 信息作为 Global 锁信息的一部分进行报告。
ReplicationStateTransition	表示副本集节点状态转换采用的锁。
Global	代表全局锁定。
Database	代表数据库锁。
Collection	代表集合锁。
Mutex	代表互斥锁。
Metadata	代表元数据锁。
oplog	表示 oplog 上的锁。

可能的 <modes> 是：

锁模式	说明
R	代表共享（S）锁。
W	代表独占 (X) 锁。
r	代表意向共享（IS）锁。
w	代表意图独占 (IX) 锁。

所有值均为 Long() 类型。

locks.<type>.acquireCount

在指定模式下获取锁的次数。

locks.<type>.acquireWaitCount

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

locks.<type>.timeAcquiringMicros

锁获取的累积等待时间（以微秒为单位）。

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

locks.<type>.deadlockCount

锁获取遇到死锁的次数。

logicalSessionRecordCache

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>
},

logicalSessionRecordCache

提供有关服务器会话缓存的指标。

logicalSessionRecordCache.activeSessionsCount

自上次刷新周期以来，mongod 或 mongos 实例在内存中缓存的所有活动本地会话的数量。

提示

• $listLocalSessions

• logicalSessionRefreshMillis

logicalSessionRecordCache.sessionsCollectionJobCount

刷新进程在 config.system.sessions 集合上运行的次数。

提示

logicalSessionRefreshMillis

logicalSessionRecordCache.lastSessionsCollectionJobDurationMillis

上次刷新的时间长度（以毫秒为单位）。

logicalSessionRecordCache.lastSessionsCollectionJobTimestamp

上次刷新的时间。

logicalSessionRecordCache.lastSessionsCollectionJobEntriesRefreshed

上次刷新期间刷新的会话数。

logicalSessionRecordCache.lastSessionsCollectionJobEntriesEnded

上次刷新期间结束的会话数。

logicalSessionRecordCache.lastSessionsCollectionJobCursorsClosed

上次刷新 config.system.sessions 集合时关闭的游标数。

logicalSessionRecordCache.transactionReaperJobCount

跟踪事务记录清理过程在 config.transactions 集合上运行次数的数字。

logicalSessionRecordCache.lastTransactionReaperJobDurationMillis

上次清理事务记录的时间长度（以毫秒为单位）。

logicalSessionRecordCache.lastTransactionReaperJobTimestamp

上次清理事务记录的时间。

logicalSessionRecordCache.lastTransactionReaperJobEntriesCleanedUp

在上次清理事务记录期间删除的 config.transactions 集合中的条目数。

logicalSessionRecordCache.sessionCatalogSize

• 对于 mongod 实例，

  config.transactions 条目的内存缓存的大小。这对应于会话在 localLogicalSessionTimeoutMinutes 内未过期的可重试写入或事务。

• 对于 mongos 实例，

  包含最近 localLogicalSessionTimeoutMinutes 间隔内的事务的会话的内存缓存数量。

mem

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

mem

一个文档，其中报告 mongod 的系统架构和当前内存使用情况。

mem.bits

一个数字（64 或 32），指示 MongoDB 实例是针对 64 位架构还是针对 32 位架构编译的。

mem.resident

The value of 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.

mem.virtual

mem.virtual displays the quantity, in mebibyte (MiB), of virtual memory used by the mongod process.

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 mem values may not be accessible to the database server.

mem.note

The field mem.note appears if mem.supported is false.

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

衡量标准

metrics : {
   abortExpiredTransactions: {
      passes: <integer>,
      successfulKills: <integer>,
      timedOutKills: <integer>
   },
   apiVersions: {
      <appName1>: <string>,
      <appName2>: <string>,
      <appName3>: <string>
   },
   aggStageCounters : {
      <aggregation stage> : Long("<num>")
   },
   changeStreams: {
      largeEventsFailed: Long("<num>"),
      largeEventsSplit: Long("<num>")
   },
   commands: {
      <command>: {
         failed: Long("<num>"),
         validator: {
           total: Long("<num>"),
           failed: Long("<num>"),
           jsonSchema: Long("<num>")
         },
         total: 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 (*Also available in 7.0.5*)
      killedDueToMaxTimeMSExpired : Long("<num>"),  // Added in MongoDB 7.2 (*Also available in 7.0.5*)
      numConnectionNetworkTimeouts : Long("<num>"),  // Added in MongoDB 6.3
      totalTimeWaitingBeforeConnectionTimeoutMillis : Long("<num>"),  // Added in MongoDB 6.3
      scanAndOrder : Long("<num>"),
      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>") },
         classic: { hits: Long("<num>"), misses: Long("<num>"), replanned: Long("<num>") },
         sbe: { hits: Long("<num>"), misses: Long("<num>"), replanned: 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>")
      },
      profiler : {
         collectionScans : {
            nonTailable : Long("<num>"),
            tailable : 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>,
         userOperationsKilled : Long("<num>"),
         userOperationsRunning : 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>"),
      subPasses : Long("<num>")
   }
}

metrics

一个返回各种统计信息的文档，这些信息反映正在运行的 mongod 实例的当前使用情况和状态。

metrics.abortExpiredTransactions

返回abortExpiredTransactions线程当前状态统计信息的文档。

metrics.abortExpiredTransactions.passes

表示中止早于transactionLifetimeLimitSeconds参数的事务的成功传递次数。

如果passes值停止递增，则表示abortExpiredTransactions线程可能被卡住。

metrics.abortExpiredTransactions.successfulKills

MongoDB成功结束的过期事务数量。

从会话池中签出会话以运行数据库操作。

AbortExpiredTransactionsSessionCheckoutTimeout 设置尝试结束过期ACID 事务时要签出会话的最大毫秒数。

If the expired transaction is successfully ended, MongoDB increments metrics.abortExpiredTransactions.successfulKills. If the transaction isn't successfully ended because it timed out when attempting to check out a session, MongoDB increments metrics.abortExpiredTransactions.timedOutKills.

7.0.26版本新增。

metrics.abortExpiredTransactions.timedOutKills

MongoDB因尝试签出会话时超时而未能成功结束的过期事务数量。

从会话池中签出会话以运行数据库操作。

AbortExpiredTransactionsSessionCheckoutTimeout 设置尝试结束过期ACID 事务时要签出会话的最大毫秒数。

If the expired transaction is successfully ended, MongoDB increments metrics.abortExpiredTransactions.successfulKills. If the transaction isn't successfully ended because it timed out when attempting to check out a session, MongoDB increments metrics.abortExpiredTransactions.timedOutKills.

7.0.26版本新增。

metrics.aggStageCounters

A document that reports on the use of aggregation pipeline stages. The fields in metrics.aggStageCounters are the names of aggregation pipeline stages. For each pipeline stage, serverStatus reports the number of times that stage has been executed.

已在版本 5.2（以及 5.0.6）中更新。

metrics.apiVersions

包含以下内容的文档：

• 每个客户端应用程序的名称

• 每个应用程序在过去 24 小时内配置的 Stable API 版本

查看 metrics.apiVersions 时请考虑以下事项：

• 每个 appname 可能的返回值为：

  • default：该命令是在未指定 Stable API 版本的情况下发出的。

  • 1：该命令是使用 Stable API 版本 1 发出的。

  注意

  可能会看到 appname 的两个返回值，因为可以在命令级别指定 Stable API 版本。某些命令可能是在没有 Stable API 版本的情况下发出的，而其他命令则是在版本 1 下发出的。

• API 版本指标保留 24 小时。如果过去 24 小时内没有使用具体 API 版本从应用程序发出命令，则从指标中删除 appname 和 API 版本。这也适用于 default API 版本指标。

• 连接至 MongoDB 实例时，通过在连接 URI 中指定 appname 来设置 appname。?appName=ZZZ 将 appname 设置为 ZZZZ。

• 访问 Stable API 的驱动程序可以设置默认 appname。

• If no appname is configured, a default value is automatically populated based on the product. For example, for a MongoDB Compass connection with no appname in the URI, the metric returns: 'MongoDB Compass': [ 'default' ].

版本 5.0 中的新增功能。

metrics.operatorCounters

一个文档，其中报告聚合管道操作符和表达式使用情况。

metrics.operatorCounters.expressions

一个带有数字的文档，表示表达式的运行频率。

要获取特定操作符（例如大于操作符 ($gt)）的指标，请将该操作符附加到命令中：

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

版本 5.0 中的新增功能。

metrics.operatorCounters.match

带有数字的文档，该数字指示匹配表达式运行的频率。

匹配表达式操作符也会作为聚合管道 $match 的一部分递增。如果 $match 阶段使用 $expr 操作符，则 $expr 的计数器会递增，但组件计数器不会递增。

考虑以下查询：

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

查询运行时，$expr 的计数器会递增。$gt 的计数器不会递增。

metrics.changeStreams

报告大于 16 MB 的变更流事件的相关信息的文档。

7.0版本新增。

metrics.changeStreams.largeEventsFailed

由于事件大于 16 MB 而导致 BSONObjectTooLarge 异常的变更流事件的数量。要防止出现异常，请参阅 $changeStreamSplitLargeEvent。

版本 7.0 新增内容：（也适用于版本 6.0.9 和 5.0.19）

metrics.changeStreams.largeEventsSplit

分割成较小片段且大于 16 MB 的变更流事件的数量。仅当使用 $changeStreamSplitLargeEvent 管道阶段时，才会分割事件。

版本 7.0 中的新功能：（也适用于 6.0.9）

metrics.commands

A document that reports on the use of database commands. The fields in metrics.commands are the names of database commands. For each command, the serverStatus reports the total number of executions and the number of failed executions.

metrics.commands includes replSetStepDownWithForce (that is, the replSetStepDown command with force: true) as well as the overall replSetStepDown. In earlier versions, the command reported only overall replSetStepDown metrics.

metrics.commands.<command>.failed

<command> 在此 mongod 上失败的次数。

metrics.commands.<create or collMod>.validator

对于 create 和 collMod 命令，它是报告传递给命令的非空 validator 对象的文档，用于指定集合的验证规则或表达式。

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

将非空 validator 对象作为选项传递给此 mongod 上的命令的次数。

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

由于模式验证错误，使用非空 validator 对象调用此 mongod 上的命令失败的次数。

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

将带有 $jsonSchema 的 validator 对象作为选项传递给此 mongod 上的命令的次数。

metrics.commands.<command>.total

在此 mongod 上执行 <command> 的次数。

metrics.commands.update.pipeline

使用聚合管道更新此 mongod 上的文档的次数。从更新总数中减去该值以获得使用文档事务语法进行的更新次数。

pipeline 计数器仅适用于 update 和findAndModify 操作。

metrics.commands.findAndModify.pipeline

聚合管道中使用 findAndModify() 来更新此 mongod 上的文档的次数。

pipeline 计数器仅适用于 update 和findAndModify 操作。

metrics.commands.update.arrayFilters

使用 arrayFilter 更新此 mongod 上的文档的次数。

arrayFilters 计数器仅适用于 update 和findAndModify 操作。

metrics.commands.findAndModify.arrayFilters

将 arrayFilter 与 findAndModify() 一起使用来更新此 mongod 上的文档的次数。

arrayFilters 计数器仅适用于 update 和findAndModify 操作。

metrics.document

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

metrics.document.deleted

已删除的文档总数。

metrics.document.inserted

插入的文档总数。

metrics.document.returned

查询返回的文档总数。

metrics.document.updated

与更新操作匹配的文档总数。此值不一定与更新修改的文档数相同。

metrics.dotsAndDollarsFields

带有数字的文档，该数字指示使用美元 ($) 前缀名称执行插入或更新操作的频率。此值不报告确切的操作次数。

当 upsert 操作创建一个新文档时，它将被视为 insert 而不是 update。

版本 5.0 中的新增功能。

metrics.executor

一个文档，其中报告复制执行器的各种统计信息。

metrics.getLastError

一个文档，其中报告写关注使用情况。

metrics.getLastError.wtime

一个文档，其中报告 w 参数大于 1 时的写关注操作计数。

metrics.getLastError.wtime.num

具有指定写关注（write concern）的操作总数（即 w），这些操作等待副本集的一个或多个节点确认写入操作（即 w 值大于 1）。

metrics.getLastError.wtime.totalMillis

mongod 执行特定写关注（write concern）操作所花费的总时间（以毫秒为单位），这些操作指定写关注（即 w），并等待一个或多个副本集节点确认写操作（即 w 值大于 1）。

metrics.getLastError.wtimeouts

由于 wtimeout 阈值导致写关注操作超时的次数。对于默认和非默认写关注规范，该数字都会递增。

metrics.getLastError.default

一个文档，其中报告何时使用默认写关注（即非 clientSupplied写关注）。默认写关注的可能来源是：

• implicitDefault

• customDefault

• getLastErrorDefaults

有关每种可能的写关注来源或 provenance 的信息，请参阅下表:

来源	说明
clientSupplied	应用程序中指定了写关注。
customDefault	写入关注源自自定义的默认值。请参阅 setDefaultRWConcern。
getLastErrorDefaults	写关注源自副本集的 settings.getLastErrorDefaults 字段。
implicitDefault	在没有所有其他写入关注规范的情况下，写入关注源自服务器。

metrics.getLastError.default.unsatisfiable

非 clientSupplied 写关注返回 UnsatisfiableWriteConcern 错误代码的次数。

metrics.getLastError.default.wtimeouts

非 clientSupplied 写关注超时的次数。

metrics.mongos

包含有关 mongos 的指标的文档。

metrics.mongos.cursor

包含 mongos 使用的游标指标的文档。

metrics.mongos.cursor.moreThanOneBatch

自 mongos 启动以来返回多个批处理的游标的总数。其他批处理可使用 getMore 命令进行检索。

版本 5.0 中的新增功能。

metrics.mongos.cursor.totalOpened

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

版本 5.0 中的新增功能。

metrics.network

6.3版本新增。

一个文档，其中报告服务器网络指标。

metrics.network.totalEgressConnectionEstablishmentTimeMillis

6.3版本新增。

建立服务器连接的总时间（毫秒）。

metrics.network.totalIngressTLSConnections

6.3版本新增。

使用 TLS 的服务器收到的传入连接总数。该数字为累积性，表示服务器启动后的总数。

metrics.network.totalIngressTLSHandshakeTimeMillis

6.3版本新增。

服务器的传入连接必须等待 TLS 网络握手完成的总时间（以毫秒为单位）。该数字为累积性，表示服务器启动后的总数。

metrics.network.totalTimeForEgressConnectionAcquiredToWireMicros

6.3版本新增。

操作在获取服务器连接和写入字节以通过网络发送到服务器之间等待的总时间（以微秒为单位）。该数字为累积性，表示服务器启动后的总数。

metrics.network.totalTimeToFirstNonAuthCommandMillis

6.3版本新增。

从接受传入服务器的连接到收到不属于连接身份验证握手的第一个操作的总时间（以毫秒为单位）。该数字为累积性，表示服务器启动后的总数。

metrics.operation

一份文档，其中包含 MongoDB 使用特殊操作类型处理的几种更新和查询操作的计数器。

metrics.operation.killedDueToClientDisconnect

版本 7.1 中的新功能：（也适用于 7.0.5）

由于客户端断开连接而在完成之前取消的操作总数。

metrics.operation.killedDueToMaxTimeMSExpired

版本 7.2 中的新功能：（也适用于 7.0.5）

在完成之前超时的操作总数。

metrics.operation.numConnectionNetworkTimeouts

6.3版本新增。

由于服务器连接获取超时错误而失败的操作总数。

metrics.operation.totalTimeWaitingBeforeConnectionTimeoutMillis

6.3版本新增。

由于服务器连接获取超时错误而导致操作失败前的总等待时间（毫秒）。

metrics.operation.scanAndOrder

返回已排序数字但无法使用索引执行排序操作的查询总数。

metrics.operation.writeConflicts

遇到写冲突的查询总数。

metrics.query.lookup

一个文档，提供有关使用基于时隙的查询执行引擎的 $lookup 阶段的详细数据。要了解更多信息，请参阅$lookup优化。

这些指标主要供 MongoDB 内部使用。

6.1 版本新增

metrics.query.multiPlanner

为基于时隙的查询执行引擎和经典查询引擎提供详细的查询规划数据。有关基于时隙的查询执行引擎的更多信息，请参阅：基于时隙的查询执行引擎管道优化。

这些指标主要供 MongoDB 内部使用。

版本 6.0.0和 5.0.9中的新增内容

metrics.query.sort

包含与排序阶段相关的计数器的文档。

6.2版本新增。

metrics.query.sort.spillToDisk

由排序阶段导致的写入磁盘的总次数。

6.2版本新增。

metrics.query.sort.totalBytesSorted

排序数据的总量（以字节为单位）。

6.2版本新增。

metrics.query.sort.totalKeysSorted

排序中使用的键总数。

6.2版本新增。

query.multiPlanner.classicMicros

聚合在经典多计划器中花费的总微秒数。

query.multiPlanner.classicWorks

汇总经典多计划器中执行的“工作”的总数。

query.multiPlanner.classicCount

聚合经典多计划器中的总调用次数。

query.multiPlanner.sbeMicros

汇总基于槽的执行引擎多计划器中花费的总微秒数。

query.multiPlanner.sbeNumReads

汇总在基于槽的执行引擎多计划器中完成的读取总数。

query.multiPlanner.sbeCount

汇总基于槽的执行引擎多计划器的总调用次数。

query.multiPlanner.histograms.classicMicros

用于测量调用经典多规划器所花费的微秒数的直方图。

query.multiPlanner.histograms.classicWorks

一种直方图，测量调用一次经典多计划器期间完成的“工作”数量。

query.multiPlanner.histograms.classicNumPlans

一种直方图，测量调用一次经典多计划器期间候选集中的计划数。

query.multiPlanner.histograms.sbeMicros

一个直方图，用于测量调用基于槽的执行引擎多计划器所花费的微秒数。

query.multiPlanner.histograms.sbeNumReads

一个直方图，用于测量基于槽的执行引擎多计划器调用期间的读取次数。

query.multiPlanner.histograms.sbeNumPlans

一个直方图，用于测量在基于槽的执行引擎多计划器调用期间候选集中的计划数。

query.queryFramework.aggregate

一个文档，其中报告在每个查询框架上运行的聚合操作数量。query.queryFramework.aggregate 中的子字段指示每个框架用于执行聚合操作的次数。

query.queryFramework.find

一个文档，其中报告在每个查询框架上运行的查找操作数量。query.queryFramework.find 中的子字段指示每个框架用于执行查找操作的次数。

metrics.queryExecutor

一个文档，报告来自查询执行系统的数据。

metrics.queryExecutor.scanned

在查询和查询计划评估期间扫描的索引项目总数。该计数器与 explain() 的输出中的 totalKeysExamined 相同。

metrics.queryExecutor.scannedObjects

查询和查询计划评估期间扫描的文档总数。该计数器与 explain() 的输出中的 totalDocsExamined 相同。

metrics.queryExecutor.collectionScans

报告执行集合扫描的查询次数的文档。

metrics.queryExecutor.collectionScans.nonTailable

执行了集合扫描但未使用可追加游标的查询数量。

metrics.queryExecutor.collectionScans.total

执行集合扫描的查询总数。该总数包括使用和未使用可追加游标的查询。

metrics.queryExecutor.profiler.collectionScans.nonTailable

profile未使用 可追加游标 的 集合执行集合扫描的查询数量。

metrics.queryExecutor.profiler.collectionScans.tailable

profile对使用可追加游标的 集合执行集合扫描的查询数。

metrics.queryExecutor.profiler.collectionScans.total

对profile集合执行集合扫描的查询总数。这包括同时使用可追加和不可追加游标的查询。

metrics.record

一个文档，其中报告与磁盘内存文件中的记录分配相关的数据。

metrics.repl

A document that reports metrics related to the replication process. metrics.repl document appears on all mongod instances, even those that aren't members of replica sets.

metrics.repl.apply

一个文档，其中报告复制 oplog 中操作的应用情况。

metrics.repl.apply.batchSize

The total number of oplog entries applied. The metrics.repl.apply.batchSize is incremented with the number of oplog entries in a batch at the batch boundaries instead of being incremented by one after each entry.

For finer granularity, see metrics.repl.apply.ops.

metrics.repl.apply.batches

metrics.repl.apply.batches reports on the oplog application process on secondaries members of replica sets. See Multithreaded Replication for more information on the oplog application processes.

metrics.repl.apply.batches.num

在所有数据库中应用的批处理总数。

metrics.repl.apply.batches.totalMillis

mongod 应用 oplog 中的操作所花费的总时间（以毫秒为单位）。

metrics.repl.apply.ops

The total number of operations applied during the replication process. metrics.repl.apply.ops is incremented after each operation, including operations that derive from oplog entries during application, such as updates to internal metadata collections like config.transactions.

提示

metrics.repl.apply.batchSize

metrics.repl.buffer

MongoDB buffers oplog operations from the replication sync source buffer before applying oplog entries in a batch. metrics.repl.buffer provides a way to track the oplog buffer. See Multithreaded Replication for more information on the oplog application process.

metrics.repl.buffer.count

oplog 缓冲区中的当前操作数。

metrics.repl.buffer.maxSizeBytes

缓冲区的大小上限。该值是 mongod 中的常量设置，不可配置。

metrics.repl.buffer.sizeBytes

oplog 缓冲区当前的内容大小。

metrics.repl.network

metrics.repl.network 报告复制过程的网络使用情况。

metrics.repl.network.bytes

metrics.repl.network.bytes 报告从复制同步源读取的总数据量。

metrics.repl.network.getmores

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

metrics.repl.network.getmores.num

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.

metrics.repl.network.getmores.totalMillis

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

注意

此数字可能很大，因为，即使 getmore 操作没有初始返回数据，MongoDB 也会等待更多数据。

metrics.repl.network.getmores.numEmptyBatches

从节点从同步源接收的空 oplog 批处理的数量。如果从节点与源完全同步并且满足以下任一条件，则从节点会收到一个空批处理：

• getmore 在等待更多数据时超时，或者

• 自从最后一次批处理发送到该从节点以来，同步源的大部分提交点已提前。

对于主节点，如果该实例以前是从节点，则该数字报告其作为从节点时收到的空批处理数。否则，对于主节点，此数字为 0。

metrics.repl.network.notPrimaryLegacyUnacknowledgedWrites

由于当前 mongod 不处于 PRIMARY 状态而失败的未确认 (w: 0) 传统写入操作（请参阅操作码）的数量。

metrics.repl.network.notPrimaryUnacknowledgedWrites

由于当前 mongod 不处于 PRIMARY 状态而失败的未确认 (w: 0) 写入操作的数量。

metrics.repl.network.oplogFetcherHighestFetchedOptime

oplog获取器在最近批处理中从其同步源获取的最高optime 。

metrics.repl.network.oplogFetcherLagSeconds

同步源的上次应用的optime与oplog获取器在此节点上获取的最高optime之间的复制获取延迟（以秒为单位）。

metrics.repl.network.oplogGetMoresProcessed

一个文档，报告用于获取节点作为同步源处理的 oplog 的 getMore 命令的数量。

metrics.repl.network.oplogGetMoresProcessed.num

用于获取节点作为同步源处理的 oplog 的 getMore 命令的数量。

metrics.repl.network.oplogGetMoresProcessed.totalMillis

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

metrics.repl.network.ops

从复制源读取的操作总数。

metrics.repl.network.readersCreated

创建的oplog查询进程总数。每当连接发生错误时，包括超时或网络操作， MongoDB都会创建新的oplog查询。每当MongoDB选择新的复制源时，该值也会递增。

metrics.repl.network.replSetUpdatePosition

一个文档，报告节点发送到其同步源的 replSetUpdatePosition 命令的数量。

metrics.repl.network.replSetUpdatePosition.num

节点发送到其同步源的 replSetUpdatePosition 命令的数量。replSetUpdatePosition 命令是内部复制命令，用于将复制进度从节点传送到其同步源。

注意

处于 STARTUP2 状态的副本集节点不会向其同步源发送 replSetUpdatePosition 命令。

metrics.repl.reconfig

一个文档，其中包含节点的 newlyAdded 字段被主节点自动删除的次数。当一个节点首次被添加到副本集时，该节点的 newlyAdded 字段将被设置为 true。

版本 5.0 中的新增功能。

metrics.repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields

主节点自动删除的 newlyAdded 节点字段的次数。当一个节点首次被添加到副本集时，该节点的 newlyAdded 字段将被设置为 true。在主节点收到指示节点状态为 SECONDARY、RECOVERING 或 ROLLBACK 的节点心跳响应后，主节点将自动删除该节点的 newlyAdded 字段。newlyAdded 字段存储在 local.system.replset 集合中。

版本 5.0 中的新增功能。

metrics.repl.stateTransition

有关在节点经历以下可能停止用户操作的转换之一时用户操作的信息：

• 节点升级成为主节点。

• 节点降级成为从节点。

• 节点正在主动执行回滚。

metrics.repl.stateTransition.lastStateTransition

报告的转换情况：

状态变更	说明
"stepUp"	节点升级成为主节点。
"stepDown"	节点降级成为从节点。
"rollback"	节点正在主动执行回滚。
""	节点未发生任何状态更改。

metrics.repl.stateTransition.userOperationsKilled

在 mongod 实例的状态变改期间停止的操作次数。

注意

该指标反映被终止的操作总数，无论操作是由用户还是服务器发起。

metrics.repl.stateTransition.userOperationsRunning

在 mongod 实例的状态更改期间保持运行的操作数。

注意

该指标反映正在运行的操作总数，无论操作是由用户还是服务器发起。

metrics.repl.syncSource

有关副本集节点的同步源选择进程的信息。

metrics.repl.syncSource.numSelections

节点尝试从可用同步源选项中选择节点进行同步的次数。例如，如果重新评估同步源或节点从当前同步源收到错误，则节点会尝试选择要从中进行同步的节点。

metrics.repl.syncSource.numTimesChoseSame

节点在重新评估其当前同步源是否为最佳同步源后，保留其原始同步源的次数。

metrics.repl.syncSource.numTimesChoseDifferent

节点在重新评估当前同步源是否为最佳状态后选择新同步源的次数。

metrics.repl.syncSource.numTimesCouldNotFind

一个节点在尝试选择同步源时找不到可用同步源的次数。

metrics.repl.waiters.replication

等待复制或日志写关注确认的线程数量。

版本 7.0.10 中的新增功能：（也适用于 6.0.16 和 5.0.27）

metrics.repl.waiters.opTime

排队等待本地复制 optime 分配的线程数。

版本 7.0.10 中的新增功能：（也适用于 6.0.16 和 5.0.27）

metrics.storage.freelist.search.bucketExhausted

mongod 在没有发现大量记录分配的情况下检查空闲列表的次数。

metrics.storage.freelist.search.requests

mongod 搜索可用记录分配的次数。

metrics.storage.freelist.search.scanned

mongod 搜索的可用记录分配的数量。

metrics.ttl

一个文档，其中报告 ttl 索引进程的资源使用情况的操作信息。

metrics.ttl.deletedDocuments

从具有 ttl 索引的集合中删除的文档总数。

metrics.ttl.passes

TTL 背景进程为检查过期文档而执行的传递次数。当 TTL 监视器从所有 TTL 索引中删除了它能找到的尽可能多的候选文档时，一次通过即完成。有关 TTL 索引删除过程的更多信息，请参阅删除流程。

metrics.ttl.subPasses

TTL 背景进程为检查过期文档而执行的子遍数。有关 TTL 索引删除过程的更多信息，请参阅删除流程。

metrics.cursor

包含有关游标状态和使用情况的数据的文档。

metrics.cursor.moreThanOneBatch

自服务器进程启动以来返回多个批处理的游标总数。使用 getMore 命令可检索其他批处理。

版本 5.0 中的新增功能。

metrics.cursor.timedOut

自服务器进程启动以来超时的游标总数。如果该数字很大或以正常速度增长，则可能表明存在应用程序错误。

metrics.cursor.totalOpened

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

版本 5.0 中的新增功能。

metrics.cursor.lifespan

一个文档，报告使用寿命位于指定时间段内的游标的数量。游标使用寿命是指从创建游标到使用 killCursors 命令终止游标或游标在批处理中没有剩余对象时的时间段。

使用寿命时间段为：

• < 1 秒

• >= 1 秒但 < 5 秒

• >= 5 秒但 < 15 秒

• >= 15 秒但 < 30 秒

• >= 30 秒但 < 1 分钟

• >= 1 分钟但 < 10 分钟

• >= 10 分钟

版本 5.0 中的新增功能。

metrics.cursor.lifespan.greaterThanOrEqual10Minutes

使用寿命为大于等于 10 分钟的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan10Minutes

使用寿命大于等于 1 分钟但小于 10 分钟的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan15Seconds

使用寿命大于等于 5 秒但小于 15 秒的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan1Minute

使用寿命大于等于 30 秒但小于 1 分钟的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan1Second

使用寿命小于 1 秒的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan30Seconds

使用寿命大于等于 15 秒但小于 30 秒的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.lifespan.lessThan5Seconds

使用寿命大于等于 1 秒但小于 5 秒的游标数量。

版本 5.0 中的新增功能。

metrics.cursor.open

包含有关打开游标的数据的文档。

metrics.cursor.open.noTimeout

打开游标的数量，设置了选项 DBQuery.Option.noTimeout，防止一段时间不活动后出现超时。

metrics.cursor.open.pinned

“固定”打开游标的数量。

metrics.cursor.open.total

MongoDB 为客户端维护的游标数量。由于 MongoDB 会耗尽未使用的游标，因此该值通常很小或为零。但是，如果存在队列、过时的可追加游标或大量操作，则该值可能会增加。

metrics.cursor.open.singleTarget

The total number of cursors that only target a single shard. Only mongos instances report metrics.cursor.open.singleTarget values.

metrics.cursor.open.multiTarget

The total number of cursors that only target more than one shard. Only mongos instances report metrics.cursor.open.multiTarget values.

镜像读 (Mirrored Reads)

仅在 mongod 上可用。

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

mirroredReads

仅在 mongod 上可用。

A document that reports on mirrored reads. To return mirroredReads information, you must explicitly specify the inclusion:

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

mirroredReads.processedAsSecondary

6.2版本新增。

该节点作为从节点时处理的镜像读数量。

提示

mirrorReads Parameter

mirroredReads.seen

该节点收到的支持镜像的操作的数量。

提示

mirrorReads Parameter

mirroredReads.sent

该节点作为主节点时发送的镜像读数量。例如，如果读取被镜像并发送至两个从节点，则镜像读的数量为 2。

提示

mirrorReads Parameter

网络

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
}

network

报告 MongoDB 网络使用相关数据的文档。这些统计信息仅衡量入口连接，特别是 mongod 或 mongos 通过客户端或其他 mongod 或 mongos 实例发起的网络连接看到的流量。由该 mongod 或 mongos 实例启动的网络连接（特别是出口连接）产生的流量值不 包含在这些统计信息中。

network.bytesIn

服务器通过客户端或其他 mongod 或 mongos 实例启动的网络连接收到的逻辑字节总数。逻辑字节是指给定文件所包含的确切字节数。

network.bytesOut

服务器通过客户端或其他 mongod 或 mongos 实例发起的网络连接发送的逻辑总字节数。逻辑字节对应于给定文件包含的字节数。

network.physicalBytesIn

服务器通过客户端或其他 mongod 或 mongos 实例发起的网络连接收到的物理字节总数。物理字节数是位于磁盘上的实际字节数。

network.physicalBytesOut

服务器通过客户端或其他 mongod 或 mongos 实例发起的网络连接发送的物理总字节数。物理字节数是位于磁盘上的实际字节数。

network.numSlowDNSOperations

耗时超过 1 秒的 DNS 解析操作的总数。

network.numSlowSSLOperations

用时超过 1 秒的 SSL 握手操作总数。

network.numRequests

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

network.tcpFastOpen

一份报告有关 MongoDB 支持和使用 TCP 快速打开 (TFO) 连接的数据的文档。

network.tcpFastOpen.kernelSetting

仅 Linux

返回 /proc/sys/net/ipv4/tcp_fastopen 的值：

• 0 - 系统已禁用 TCP 快速打开。

• 1 - 为传出连接启用 TCP 快速打开。

• 2 - 为传入连接启用 TCP 快速打开。

• 3 - 为传入和传出连接启用“TCP 快速打开”。

network.tcpFastOpen.serverSupported

• 如果主机操作系统支持入站 TCP 快速打开 (TFO) 连接，则返回 true。

• 如果主机操作系统不 支持入站 TCP 快速打开 (TFO) 连接，则返回 false。

network.tcpFastOpen.clientSupported

• 如果主机操作系统支持出站 TCP 快速打开 (TFO) 连接，则返回 true。

• 如果主机操作系统不支持出站 TCP 快速打开 (TFO) 连接，则返回 false。

network.tcpFastOpen.accepted

自 mongod 或 mongos 上次启动以来已接受的到 mongod 或 mongos 的传入 TCP 快速打开 (TFO) 连接总数。

network.compression

一个文档，其中报告每个网络压缩程序库压缩和解压缩的数据量。

network.compression.snappy

一个文档，返回有关使用 snappy 库压缩和解压缩的字节数的统计信息。

network.compression.zstd

一个文档，返回有关使用 zstd 库压缩和解压缩的字节数的统计信息。

network.compression.zlib

一个文档，返回有关使用 zlib 库压缩和解压缩的字节数的统计信息。

network.serviceExecutors

版本 5.0 中的新增功能。

报告服务执行程序数据的文档，这些执行程序为客户端请求运行操作。

network.serviceExecutors.passthrough

版本 5.0 中的新增功能。

一个文档，报告有关 passthrough 服务执行程序的线程和客户端的数据。passthrough 服务执行程序为每个客户端创建一个新线程，并在客户端结束后销毁该线程。

network.serviceExecutors.passthrough.threadsRunning

版本 5.0 中的新增功能。

passthrough 服务执行程序中运行的线程数。

network.serviceExecutors.passthrough.clientsInTotal

版本 5.0 中的新增功能。

分配给 passthrough 服务执行程序的客户端总数。可以将客户端分配给 passthrough 服务执行程序和当前未运行的请求。

network.serviceExecutors.passthrough.clientsRunning

版本 5.0 中的新增功能。

当前使用 passthrough 服务执行程序运行请求的客户端数量。

network.serviceExecutors.passthrough.clientsWaitingForData

版本 5.0 中的新增功能。

使用等待来自网络的传入数据的 passthrough 服务执行程序的客户端数量。

network.serviceExecutors.fixed

版本 5.0 中的新增功能。

一个文档，报告有关 fixed 服务执行程序的线程和客户端的数据。fixed 服务执行程序拥有固定数量的线程。线程被临时分配给客户端，并在客户端结束后予以保留。

network.serviceExecutors.fixed.threadsRunning

版本 5.0 中的新增功能。

fixed 服务执行程序中运行的线程数。

network.serviceExecutors.fixed.clientsInTotal

版本 5.0 中的新增功能。

分配给 fixed 服务执行程序的客户端总数。可以将客户端分配给 fixed 服务执行程序和当前未运行的请求。

network.serviceExecutors.fixed.clientsRunning

版本 5.0 中的新增功能。

当前使用 fixed 服务执行程序运行请求的客户端数量。

network.serviceExecutors.fixed.clientsWaitingForData

版本 5.0 中的新增功能。

使用等待来自网络的传入数据的 fixed 服务执行程序的客户端数量。

network.listenerProcessingTime

6.3版本新增。

一个文档，其中报告数据库监听器将传入数据库连接请求分配给专用线程所花费的总时间。

network.listenerProcessingTime.durationMicros

6.3版本新增。

数据库侦听器将传入数据库连接请求分配给执行数据库操作的专用线程所花费的总时间（以微秒为单位）。

opLatencies

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

opLatencies

包含整个实例的操作延迟的文档。有关此文档的说明，请参阅latencyStats 文档。

从MongoDB6.2 开始， 和 实例的opLatencies mongodmongos指标报告。mongos 报告的延迟包括操作延迟时间以及mongod 和mongos 实例之间的通信时间。

Starting in MongoDB 7.0, each category document includes queryableEncryptionLatencyMicros, the total latency, in microseconds, attributable to Queryable Encryption operations.

opLatencies.reads

读取请求的延迟统计信息。

opLatencies.writes

写入操作的延迟统计信息。

opLatencies.commands

数据库命令的延迟统计信息。

opLatencies.transactions

数据库事务的延迟统计信息。

opReadConcernCounters

仅适用于 mongod 实例

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

opReadConcernCounters

已在版本5.0 中删除。已替换为readConcernCounters 。

一个文档，其中报告自 mongod 实例上次启动以来，查询操作为该实例指定的读关注级别。

指定 w	说明
"available"	指定读关注级别 "available" 的查询操作的数量。
"linearizable"	指定读关注级别 "linearizable" 的查询操作的数量。
"local"	指定读关注级别 "local" 的查询操作的数量。
"majority"	指定读关注级别 "majority" 的查询操作的数量。
"snapshot"	指定读关注级别 "snapshot" 的查询操作的数量。
"none"	未指定读关注级别而是使用默认读关注级别的查询操作数量。

The sum of the opReadConcernCounters equals opcounters.query.

opWriteConcernCounters

仅适用于 mongod 实例

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>"),
               ...
            }
         }
      }
   }
}

opWriteConcernCounters

一个文档，其中报告自 mongod 实例上次启动以来，写入操作为该实例指定的写关注。

More specifically, the opWriteConcernCounters reports on the w: <value> 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.

注意

仅当 reportOpWriteConcernCountersInServerStatus 参数设置为 true（默认为 false）时才可用。

opWriteConcernCounters.insert

一个文档，其中报告自 mongod 实例上次启动以来，插入操作为该实例指定的 w: <value>：

注意

仅当 reportOpWriteConcernCountersInServerStatus 参数设置为 true（默认为 false）时才可用。

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 : {}
      }
   }
},

指定 w	说明
"wmajority"	指定 w: "majority" 的插入操作次数。
"wnum"	指定 w: <num> 的插入操作次数。计数按特定的 ``<num>`` 进行分组。
"wtag"	指定 w: <tag> 的插入操作次数。计数按特定 <tag> 分组。
"none"	未指定 w 值的插入操作数。这些操作使用默认的 w 值 “majority”。
"noneInfo"	使用默认写关注的非事务查询操作的数量。这些指标跟踪 cluster wide write concern（全局默认写关注）和隐式默认写关注的使用情况。 opWriteConcernCounters.noneInfo 中的值之和应等于 opWriteConcernCounters.none 的值。

The sum of the opWriteConcernCounters.insert equals opcounters.insert.

opWriteConcernCounters.update

一个文档，其中报告自 mongod 实例上次启动以来，更新操作为该实例指定的 w: <value>：

注意

仅当 reportOpWriteConcernCountersInServerStatus 参数设置为 true（默认为 false）时才可用。

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 : {}
      }
   }
},

指定 w	说明
"wmajority"	指定 w: "majority" 的更新操作数。
"wnum"	指定 w: <num> 的更新操作数。计数按特定 <num> 分组。
"wtag"	指定 w: <tag> 的更新操作数。计数按特定 <tag> 分组。
"none"	未指定 w 值的更新操作数。这些操作使用 1 的默认值 w。
"noneInfo"	使用默认写关注的非事务查询操作的数量。这些指标跟踪 cluster wide write concern（全局默认写关注）和隐式默认写关注的使用情况。 opWriteConcernCounters.noneInfo 中的值之和应等于 opWriteConcernCounters.none 的值。

The sum of the opWriteConcernCounters.update equals opcounters.update.