serverStatus

定义

serverStatus: serverStatus 命令返回一个提供数据库状态概述的文档。监控应用程序可以定期运行此命令，以收集有关实例的统计信息。

兼容性

此命令可用于以下环境中托管的部署：

MongoDB Atlas：用于云中 MongoDB 部署的完全托管服务

注意

所有 MongoDB Atlas 集群都支持此命令。有关 Atlas 对所有命令的支持的信息，请参阅不支持的命令。

MongoDB Enterprise：基于订阅、自我管理的 MongoDB 版本
MongoDB Community：源代码可用、免费使用且可自行管理的 MongoDB 版本

语法

该命令具有以下语法：

db.runCommand(
   {
     serverStatus: 1
   }
)

值（即上面的 1）不会影响该命令的操作。db.serverStatus() 命令将返回大量数据。要从输出中返回特定对象或字段，请在命令后附加对象或字段名称。

例如：

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

mongosh 为命令 serverStatus 提供 db.serverStatus() 包装器。

提示

另请参阅：

serverStatus 的大部分输出也由 mongostat 动态显示。有关更多信息，请参阅 mongostat 命令。

行为

默认情况下，serverStatus 在输出中排除：

repl 文档中的一些内容。
mirroredReads 文档。

要包含默认排除的字段，请在命令中指定顶层字段并将其设置为 1。要排除默认包含的字段，请指定该字段并将其设置为 0。您可以指定顶层字段或嵌入字段。

例如，以下操作会排除输出中的 repl、metrics 和locks 信息。

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

例如，以下操作会排除输出中嵌入的 histogram 字段。

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

以下示例在输出中包含所有 repl 信息：

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

初始化

serverStatus 报告的统计信息将在 mongod 服务器重启时重置。

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

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

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

包括 `mirroredReads`

默认情况下，输出中不包含 mirroredReads 信息。如要返回 mirroredReads 信息，必须明确指定包含的内容：

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

输出

注意

输出字段因 MongoDB 的版本、底层操作系统平台、存储引擎和节点类型（包括 mongos、mongod 或副本集节点）不同而异。

有关特定于 MongoDB 版本的 serverStatus 输出，请参阅 MongoDB 手册的相应版本。

断言

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 数据结构中的其他值提供上下文。

bucketCatalog

bucketCatalog: {
    numBuckets: <num>,
    numOpenBuckets: <num>,
    numIdleBuckets: <num>,
    memoryUsage: <num>,
    numBucketInserts: <num>,
    numBucketUpdates: <num>,
    numBucketsOpenedDueToMetadata: <num>,
    numBucketsClosedDueToCount: <num>,
    numBucketsClosedDueToSchemaChange: <num>,
    numBucketsClosedDueToSize: <num>,
    numBucketsClosedDueToTimeForward: <num>,
    numBucketsClosedDueToTimeBackward: <num>,
    numBucketsClosedDueToMemoryThreshold: <num>,
    numCommits: <num>,
    numMeasurementsGroupCommitted: <num>,
    numWaits: <num>,
    numMeasurementsCommitted: <num>,
    avgNumMeasurementsPerCommit: <num>,
    numBucketsClosedDueToReopening: <num>,
    numBucketsArchivedDueToMemoryThreshold: <num>,
    numBucketsArchivedDueToTimeBackward: <num>,
    numBucketsReopened: <num>,
    numBucketsKeptOpenDueToLargeMeasurements: <num>,
    numBucketsClosedDueToCachePressure: <num>,
    numBucketsFrozen: <num>,
    numCompressedBucketsConvertedToUnsorted: <num>,
    numBucketsFetched: <num>,
    numBucketsQueried: <num>,
    numBucketFetchesFailed: <num>,
    numBucketQueriesFailed: <num>,
    numBucketReopeningsFailed: <num>,
    numDuplicateBucketsReopened: <num>,
    stateManagement: {
       bucketsManaged: <num>,
       currentEra: <num>,
       erasWithRemainingBuckets: <num>,
       trackedClearOperations: <num>
    }
 }

版本 5.0 中的新增功能。

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

bucketCatalog 返回以下指标：

衡量标准	说明
`numBuckets`	跟踪的存储桶总数。预计等于 `numOpenBuckets` 和 `numArchivedBuckets` 的总和。
`numOpenBuckets`	缓存中存储有完整表示形式、准备接收新文档的跟踪存储桶的数量。
`numIdleBuckets`	已打开且当前没有待处理的未提交文档插入的存储桶数。 numOpenBuckets 的子集。
`numArchivedBuckets`	缓存中存储的具有最小表示形式的跟踪存储桶的数量，这些存储桶可以有效地重新打开以接收新文档。
`memoryUsage`	内部分桶数据结构使用的字节数。
`numBucketInserts`	创建的新桶的数量。
`numBucketUpdates`	更新现有存储桶以包含其他文档的次数。
`numBucketsOpenedDueToMetadata`	由于文档到达时 `metaField` 值与当前打开的任何存储桶都不匹配而打开的存储桶数。
`numBucketsClosedDueToCount`	因达到文档计数限制而关闭的存储桶的数量。
`numBucketsClosedDueToSchemaChange`	因传入文档的模式与打开的文档桶中的模式不兼容而关闭的文档桶数量。
`numBucketsClosedDueToSize`	由于传入文档会使存储桶超过其大小限制而关闭的存储桶数量。
`numBucketsClosedDueToTimeForward`	由于文档在当前打开的所有 `metaField` 值的最长时间后到达 `timeField` 值而关闭的存储段数。
`numBucketsClosedDueToTimeBackward`	由于文档到达时具有 `timeField` 值，而关闭的存储段数早于该 `metaField` 值当前打开的所有存储段的最短时间。
`numBucketsClosedDueToMemoryThreshold`	由于活动存储桶集不适合允许的存储桶目录缓存大小而关闭的存储桶数。
`numCommits`	对时间序列集合的存储桶级提交的数量。
`numMeasurementsGroupCommitted`	包含来自并发插入命令的测量值的提交次数。
`numWaits`	操作等待另一个线程重新打开存储桶或完成组提交的次数。
`numMeasurementsCommitted`	提交到时间序列集合的文档数量。
`avgNumMeasurementsPerCommit`	每次提交的平均文档数。
`numBucketsClosedDueToReopening`	因有合适的水桶被重新打开而关闭的水桶数量。
`numBucketsArchivedDueToMemoryThreshold`	由于活动存储桶设立不符合允许的存储桶目录缓存大小而存档的存储桶数量。
`numBucketsArchivedDueToTimeBackward`	由于具有 `timeField` 值的文档在所有当前打开的存储桶达到该 `metaField` 值的最小时间之前到达而存档的存储桶的数量。
`numBucketsReopened`	由于到达的文档与任何打开的存储桶都不匹配，但与现有的非已满存储桶匹配而重新打开的存储桶数。
`numBucketsKeptOpenDueToLargeMeasurements`	因文件大小本应关闭，但因未达到合理压缩所需的最低文档数而保持打开的文件桶数量。
`numBucketsClosedDueToCachePressure`	因大小超过存储桶目录的动态存储桶大小限制而关闭的存储桶的数量，该限制源自可用存储引擎缓存大小和 `numBuckets`。此限制不同于最大存储桶大小限制。
`numBucketsFrozen`	冻结的存储桶的数量。如果尝试压缩存储桶会损坏其内容，则存储桶将被冻结。
`numCompressedBucketsConvertedToUnsorted`	包含未按各自 `timeField` 值排序的文档的压缩存储桶数。
`numBucketsFetched`	获取用于检查是否适合重新打开的已存档存储桶的数量。
`numBucketsQueried`	为确定是否可以保存传入文档而查询的存储桶总数。
`numBucketFetchesFailed`	已获取但不适合重新打开的已存档存储桶的数量。
`numBucketQueriesFailed`	由于缺乏候选可用性，查询合适的开放存储桶的次数失败了。
`numBucketReopeningsFailed`	由于并发操作冲突、格式不正确的存储桶等原因而尝试重新打开存储桶但失败的次数。
`numDuplicateBucketsReopened`	与当前打开的存储桶重复的重新打开的存储桶的数量。
`stateManagement`	跟踪存储桶目录状态信息的文档。
`stateManagement.bucketsManaged`	为冲突管理而跟踪的桶总数。这包括水桶目录中打开的水桶，以及任何正在被直接写入的水桶，包括通过更新和删除命令写入的水桶。
`stateManagement.currentEra`	存储桶目录的当前时代。存储桶目录从 0 纪元开始，并在存储桶被清除时递增。尝试插入到存储桶中会导致它被删除（如果已被清除），或者将其更新到当前时代。
`stateManagement.erasWithRemainingBuckets`	具有跟踪存储桶的era 数量。
`stateManagement.trackedClearOperations`	一组存储桶已被清除，但这些存储桶的移除被推迟的次数。这可能是由于删除集合、在分片集合中移动区块或选举等事件造成的。

catalogStats

5.1 版本中的新功能。

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

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

catalogStats.collections: 用户集合总数（不包括系统集合）。

catalogStats.capped: 固定大小用户集合的总数。

catalogStats.views: 用户浏览总数。

catalogStats.timeseries: 时间序列集合的总数。

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

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

changeStreamPreImages

版本 5.0 中的新增功能。

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

一个文档，其中报告与change stream前像相关的指标。

changeStreamPreImages.purgingJob

版本 7.1 中的新增内容。

一个文档，其中报告与change stream前映像的清除作业相关的指标。清除作业是系统用于异步删除前像的背景进程。

changeStreamPreImages.purgingJob字段返回以下指标：

衡量标准	说明
`totalPass`	清除作业完成的删除遍历总数。
`docsDeleted`	清除作业删除的前图像文档的累计数量。
`bytesDeleted`	清除作业从所有前图像collection中删除的所有文档的累积大小（以字节为单位）。
`scannedCollections`	清除作业扫描的前图像collection的累计数量。在单租户环境中，此数字与`totalPass`相同，因为每个租户都有一个前图像collection。
`scannedInternalCollections`	清除作业扫描的内部前图像集合的累计数量。内部集合是存储在`config.system.preimages`中的前像集合内的集合。
`maxStartWallTimeMillis`	从每个前图像collection的第一个文档开始的最大挂起时间（以毫秒为单位）。
`timeElapsedMillis`	清除作业执行所有删除操作的累积时间（以毫秒为单位）。

changeStreamPreImages.expireAfterSeconds: 版本 7.1 中的新增内容。
MongoDB 保留前像的时间（以秒为单位）。如果未定义expireAfterSeconds ，则该指标不会出现在serverStatus输出中。

连接

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

从客户端到数据库服务器的传入连接数。该数字包括当前 Shell 会话。考虑 connections.available 的值，为该数据添加更多上下文。

该值将包括所有传入连接，包括任何 shell 连接或来自其他服务器的连接，例如副本集节点或 mongos 实例。

connections.available: 可用的未使用传入连接数。将此值与 connections.current 的值结合，可了解数据库的连接负载；将此值与 UNIX ulimit 自管理部署设置文档结合，可了解有关可用连接系统阈值的更多信息。

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

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

如果 serverStatus 未返回此字段，则全局默认读关注尚未设置或尚未传播到实例。

defaultRWConcern.defaultReadConcern.level

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

如果 serverStatus 未返回此字段，则表示该设置的全局默认值尚未设置或尚未传播到实例。

defaultRWConcern.defaultWriteConcern

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

如果 serverStatus 未返回此字段，则全局默认写关注尚未设置或者尚未传播到实例。

defaultRWConcern.defaultWriteConcern.w

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

如果 serverStatus 未返回此字段，则表示该设置的全局默认值尚未设置或尚未传播到实例。

defaultRWConcern.defaultWriteConcern.wtimeout

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

如果 serverStatus 未返回此字段，则表示该设置的全局默认值尚未设置或尚未传播到实例。

defaultRWConcern.defaultWriteConcernSource: 默认写关注的来源。默认情况下，该值为 "implicit"。使用 setDefaultRWConcern 完成设置默认写关注后，该值即变为 "global"。
版本 5.0 中的新增功能。

defaultRWConcern.defaultReadConcernSource: 默认读关注的来源。默认情况下，该值为 "implicit"。使用 setDefaultRWConcern 完成设置默认读关注后，该值即变为 "global"。
版本 5.0 中的新增功能。

defaultRWConcern.updateOpTime: 该实例上次更新其任何全局读关注或写关注设置副本的时间戳。如果没有 defaultRWConcern.defaultReadConcern 和 defaultRWConcern.defaultWriteConcern 字段，则此字段指示上次取消设置默认值的时间戳。

defaultRWConcern.updateWallClockTime: 该实例上次更新其任何全局读关注或写关注设置副本的挂钟时间。如果没有 defaultRWConcern.defaultReadConcern 和 defaultRWConcern.defaultWriteConcern 字段，则此字段指示上次取消设置默认值的时间。

defaultRWConcern.localUpdateWallClockTime: 该实例上次更新其任何全局读关注或写关注设置副本的本地系统挂钟时间。如果此字段是 defaultRWConcern 下的唯一字段，则该实例从不了解全局默认读关注或写关注设置。

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 实例调用的选举指标。

stepUpCmd 既包括调用的选举次数，也包括成功的选举次数。

electionMetrics.priorityTakeover

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

electionMetrics.priorityTakeover 既包括调用的选举次数，也包括成功的选举次数。

electionMetrics.catchUpTakeover

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

catchUpTakeover 既包括调用的选举次数，也包括成功的选举次数。

提示

另请参阅：

settings.catchUpTakeoverDelayMillis

electionMetrics.electionTimeout

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

electionTimeout 既包括调用的选举次数，也包括成功的选举次数。

提示

另请参阅：

settings.electionTimeoutMillis

electionMetrics.freezeTimeout

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

electionMetrics.freezeTimeout 既包括调用的选举次数，也包括成功的选举次数。

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

页面错误总数。extra_info.page_faults 计数器在性能不佳的时刻可能会急剧增加，并且可能与内存环境有限和数据集较大相关。有限且偶发的页面错误并不一定表明存在问题。

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 的某个百分比时，将会启用流量控制。

不启用流量控制会导致复制延迟。如果副本集没有收到足够的负载来启用流量控制，无响应的从节点就可能出现延迟，从而使 flowControl.isLagged 的值为 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: 自数据库上次启动并创建 globalLock 以来的时间（以微秒为单位）。这约等于服务器的总计正常运行时间。

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

globalLock.currentQueue.total

排队等待锁定的操作总数（即 globalLock.currentQueue.readers 和 globalLock.currentQueue.writers 的总和）。

不必担心持续较小的队列，特别是短操作的队列。globalLock.activeClients 读取者和写入者信息为该数据提供了上下文。

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

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

globalLock.activeClients

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

利用该数据为 globalLock.currentQueue 数据提供上下文。

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

globalLock.activeClients.readers: 执行读取操作的活动客户端连接的数量。

globalLock.activeClients.writers: 执行写入操作的活动客户端连接的数量。

hedgingMetrics

重要

从 MongoDB 8.0开始，对冲读已弃用。默认情况下，指定读取偏好nearest的查询不再使用对冲读。如果您明确指定对冲读，MongoDB 会执行对冲读并记录警告。

仅适用于 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>,
   killedDueToInsufficientDiskSpace : <num>,
   failedDueToDataCorruption : <num>
},

indexBuilds: 提供服务器上次启动后索引构建的指标。

indexBuilds.total: 索引构建总数。

indexBuilds.killedDueToInsufficientDiskSpace: 由于磁盘空间不足而结束的索引构建总数。从 MongoDB 7.1 开始，您可以使用indexBuildMinAvailableDiskSpaceMB参数设置构建索引所需的最小磁盘空间。
版本 7.1 中的新增内容。

indexBuilds.failedDueToDataCorruption: 由于数据损坏而失败的索引构建总数。
版本 7.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 构建索引的问题、初始同步期间的集合克隆、启动后恢复的索引构建，以及外部排序器磁盘使用情况的统计信息。

indexBuildBuilder.bytesSpilled: 版本 6.0.4 中的新增功能。
外部排序器写入磁盘的字节数。

indexBuilder.bytesSpilledUncompressed: 版本 6.0.4 中的新增功能。
压缩前外部排序器写入磁盘的字节数。

indexBulkBuilder.count: 创建的批量构建器的实例数。

indexBulkBuilder.filesClosedForExternalSort: 外部排序器关闭文件句柄以将数据溢写到磁盘的次数。将此值与 filesOpenedForExternalSort 相结合，可确定外部排序器正在使用的打开文件句柄数。

indexBulkBuilder.filesOpenedForExternalSort: 外部排序器打开文件句柄以将数据溢写到磁盘的次数。将此值与 filesClosedForExternalSort 相结合，可确定外部排序器正在使用的打开文件句柄数。

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 8.0.4 (and 7.0.14)
      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: 一个文档，其中报告数据库和集合的所有索引的统计信息。
6.0 版本中的新功能。

indexStats.count: 索引总数。
6.0 版本中的新功能。

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

实例信息

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

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

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

version: 当前 MongoDB 进程的 MongoDB 版本。

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

service: 当前 MongoDB 进程的角色。可能的值为 router 或 shard。
8.0版本新增。

pid: 进程 ID 号。

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

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

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

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

锁

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`	代表元数据锁。
`DDLDatabase`	表示DDL数据库锁。版本 7.1 中的新增内容。
`DDLCollection`	表示DDLcollection锁。版本 7.1 中的新增内容。
`oplog`	表示 oplog 上的锁。

可能的 <modes> 是：

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

所有值均为 Long() 类型。

locks.<type>.acquireCount: 在指定模式下获取锁的次数。

locks.<type>.acquireWaitCount: 由于锁以冲突模式被占用而导致 locks.<type>.acquireCount 锁获取遇到等待的次数。

locks.<type>.timeAcquiringMicros

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

locks.<type>.timeAcquiringMicros 除以 locks.<type>.acquireWaitCount 得出特定锁模式的大致平均等待时间。

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 实例在内存中缓存的所有活动本地会话的数量。

提示

另请参阅：

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: mem.resident 的值大致等于数据库进程当前使用的 RAM 量，以兆字节 (MiB) 为单位。在正常使用期间，此值往往会增长。在专用数据库服务器中，此数字往往接近系统内存总量。

mem.virtual: mem.virtual 显示 mongod 进程使用的虚拟内存量，以兆字节 (MiB) 为单位。

mem.supported: 指示底层系统是否支持扩展内存信息的布尔值。如果此值为 false 且系统不支持扩展内存信息，则数据库服务器可能无法访问其他 mem 值。

mem.note

字段 mem.note 出现的条件：mem.supported 为 false。

mem.note 字段包含文本：'not all mem info support on this platform'。

衡量标准

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>"),
         batchSize: <num>,
         batches : {
            num : <num>,
            totalMillis : <num>
         },
         ops : Long("<num>")
      },
      write : {
         batchSize: <num>,
         batches : {
            num : <num>,
            totalMillis : <num>
         }
      },
      buffer : {
         write: {
            count : Long("<num>"),
            maxSizeBytes : Long("<num>"),
            sizeBytes : Long("<num>")
         },
         apply: {
            count : Long("<num>"),
            sizeBytes : Long("<num>"),
            maxSizeBytes : Long("<num>"),
            maxCount: 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>"),
      subPasses : Long("<num>")
   }
}

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

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

metrics.abortExpiredTransactions.passes

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

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

metrics.aggStageCounters

一个文档，其中报告聚合管道阶段的使用情况。metrics.aggStageCounters 中的字段是聚合管道阶段的名称。对于每个管道阶段，serverStatus 报告该阶段的执行次数。

已在版本 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。
如果未配置 appname，则根据产品自动填充默认值。例如，对于 URI 中没有 appname 的 MongoDB Compass 连接，该指标返回：'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.largeEventsSplit: 分割成较小片段且大于 16 MB 的变更流事件的数量。仅当使用 $changeStreamSplitLargeEvent 管道阶段时，才会分割事件。
版本 7.0中的新增功能：（在 6.0.9 中也可用）

metrics.changeStreams: 报告大于 16 MB 的变更流事件的相关信息的文档。
7.0 版本中的新增功能。

metrics.changeStreams.largeEventsFailed: 由于事件大于 16 MB 而导致 BSONObjectTooLarge 异常的变更流事件的数量。要防止出现异常，请参阅 $changeStreamSplitLargeEvent。
版本 7.0 新增内容：（也适用于版本 6.0.9 和 5.0.19）

metrics.changeStreams.showExpandedEvents

showExpandedEvents选项设置为true的变更流游标的数量。

当您执行以下操作时， showExpandedEvents的计数器会递增：

打开change stream游标。
在change stream游标上运行explain命令。

版本 7.1 中的新增内容。

metrics.commands

报告数据库命令使用情况的文档。metrics.commands 中的字段是数据库命令的名称。对于每个命令，serverStatus 都会报告执行的总次数和执行失败的次数。

metrics.commands 包括replSetStepDownWithForce （即带有 force: true 的 replSetStepDown 指令）和整个replSetStepDown 。在早期版本中，该命令仅报告整体 replSetStepDown 指标。

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.<command>.rejected

<command> 在 mongod 上被拒绝的次数，因为命令或操作关联的查询设置中，reject 字段是 true。

要设置reject字段，使用 setQuerySettings。

8.0版本新增。

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: 一个文档，其中反映文档访问权限和修改模式。将这些值与 opcounters 文档中的数据进行比较，后者跟踪操作总数。

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: 具有指定写关注的操作总数（即w），这些操作等待副本集的一个或多个节点确认写操作（即 w 值大于1）。

metrics.getLastError.wtime.totalMillis: mongod 执行特定写关注操作所花费的总时间（以毫秒为单位），这些操作指定写关注（即 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: 自 mongos 启动以来已打开的游标总数，包括当前打开的游标。与 metrics.cursor.open.total 不同，后者仅表示当前打开的游标数量。
版本 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 中的新增内容。
由于客户端断开连接而在完成之前取消的操作总数。

metrics.operation.killedDueToDefaultMaxTimeMSExpired: 8.0版本新增。
由于集群级别默认超时而超时的操作总数，defaultMaxTimeMS。

metrics.operation.killedDueToMaxTimeMSExpired: 版本 7.2 中的新增内容。
由于操作级别超时而超时的操作总数，cursor.maxTimeMS()。

metrics.operation.numConnectionNetworkTimeouts: 6.3 版本中的新功能。
由于服务器连接获取超时错误而失败的操作总数。

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

metrics.operation.totalTimeWaitingBeforeConnectionTimeoutMillis: 6.3 版本中的新功能。
由于服务器连接获取超时错误而导致操作失败前的总等待时间（毫秒）。

metrics.operation.unsendableCompletedResponses: 版本 7.1 中的新增内容。
在服务器端完成但由于客户端和服务器之间的连接失败或断开而未向客户端发送响应的操作总数。

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.record: 一个文档，其中报告与磁盘内存文件中的记录分配相关的数据。

metrics.repl: 一个文档，其中报告与复制进程相关的指标。metrics.repl 文档将出现在所有 mongod 实例上，包括不属于副本集成员的实例。

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

metrics.repl.apply.batchSize

应用的 oplog 操作总数。metrics.repl.apply.batchSize 随着批处理边界处的批处理中的操作数量而增加，而不是在每次操作之后递增。

有关更详细的信息，请参阅 metrics.repl.apply.ops。

metrics.repl.apply.batches: metrics.repl.apply.batches 报告副本集的从节点上的 oplog 应用程序进程。有关 oplog 应用程序进程的更多信息，请参阅多线程复制。

metrics.repl.apply.batches.num: 在所有数据库中应用的批处理总数。

metrics.repl.apply.batches.totalMillis: mongod 应用 oplog 中的操作所花费的总时间（以毫秒为单位）。

metrics.repl.apply.ops: 应用的 oplog 操作总数。每次操作后，metrics.repl.apply.ops 都会递增。
提示
另请参阅：
metrics.repl.apply.batchSize

metrics.repl.write: 报告写入 oplog 条目的文档。
8.0版本新增。

metrics.repl.write.batchSize: 写入 oplog 的条目总数。当节点将批次写入 oplog 时，此指标会更新每个批次中的条目数。
8.0版本新增。

metrics.repl.write.batches: 为从节点报告 oplog 编写过程的文件。
8.0版本新增。

metrics.repl.write.batches.num: 在所有数据库中写入的批处理总数。
8.0版本新增。

metrics.repl.write.batches.totalMillis: 该节点将条目写入 oplog 所花费的总时间（以毫秒为单位）。
8.0版本新增。

metrics.repl.buffer

MongoDB 在批量应用 oplog 条目之前，会对复制同步源缓冲区中的 oplog 操作进行缓冲。metrics.repl.buffer 提供了一种跟踪 oplog 缓冲区的方法。有关 oplog 应用程序过程的更多信息，请参阅多线程复制。

在版本8.0中进行了更改。

从 MongoDB 8.0 开始，从节点现在可以并行更新本地 oplog 并将更改应用于数据库。对于每批 oplog 条目，MongoDB 使用两个缓冲区：

write 缓冲从主节点接收新的 oplog 条目。写入器将这些条目添加到本地 oplog 并将它们发送到应用器。
apply 缓冲区从写入器接收新的 oplog 条目。应用程序使用这些条目来更新本地数据库。

这是一项破坏性变更，因为它弃用了较早的 metrics.repl.buffer 状态指标。

metrics.repl.buffer.apply: 提供有关 oplog 应用缓冲状态的信息。
8.0版本新增。

metrics.repl.buffer.apply.count: oplog 应用缓冲中的当前操作数。
8.0版本新增。

metrics.repl.buffer.apply.maxCount: oplog 应用缓冲中的最大操作数。mongod 使用常量设置该值，该值不可配置。
8.0版本新增。

metrics.repl.buffer.apply.maxSizeBytes: 应用缓冲的最大大小。mongod 使用常量设置此大小，该常量不可配置。
8.0版本新增。

metrics.repl.buffer.apply.sizeBytes: oplog 应用缓冲当前的内容大小。
8.0版本新增。

metrics.repl.buffer.count: 自版本 8.0 起已弃用。
从 MongoDB 8.0开始，从节点使用单独缓冲来写入和应用 oplog 条目。有关 oplog 缓冲中的当前操作数，请参阅 apply.count 或 write.count 状态指标。

metrics.repl.buffer.maxSizeBytes: 自版本 8.0 起已弃用。
从 MongoDB 8.0开始，从节点使用单独缓冲来写入和应用 oplog 条目。有关缓冲区的最大大小，请参阅 apply.maxSizeBytes 或 write.maxSizeBytes 状态指标。

metrics.repl.buffer.sizeBytes: 自版本 8.0 起已弃用。
从 MongoDB 8.0 开始，从节点使用单独的缓冲区来写入和应用 oplog 条目。有关 oplog 缓冲区的当前大小，请参见 apply.sizeBytes 或 write.sizeBytes 状态指标。

metrics.repl.buffer.write: 提供有关 oplog 写入缓冲状态的信息。
8.0版本新增。

metrics.repl.buffer.write.count: oplog 写入缓冲区中的当前操作数。
8.0版本新增。

metrics.repl.buffer.write.maxSizeBytes: 写入缓冲区的最大大小。mongod 使用常量设置此值，该常量不可配置。
8.0版本新增。

metrics.repl.buffer.write.sizeBytes: oplog 写入缓冲区当前的内容大小。
8.0版本新增。

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

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

metrics.repl.network.getmores: metrics.repl.network.getmores 报告 getmore 操作的信息，这些操作是作为 oplog 复制进程的一部分从 oplog 游标请求其他结果。

metrics.repl.network.getmores.num: metrics.repl.network.getmores.num 报告 getmore 操作的总数，这些操作是从复制同步源请求一组附加操作的操作。

metrics.repl.network.getmores.totalMillis: metrics.repl.network.getmores.totalMillis 报告从 getmore 操作中收集数据所需的总时间。
注意
此数字可能很大，因为，即使 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.oplogGetMoresProcessed: 一个文档，报告用于获取节点作为同步源处理的 oplog 的 getMore 命令的数量。

metrics.repl.network.oplogGetMoresProcessed.num: 用于获取节点作为同步源处理的 oplog 的 getMore 命令的数量。

metrics.repl.network.oplogGetMoresProcessed.totalMillis: 节点处理 getMore 命令所花费的时间（以毫秒为单位）计入 metrics.repl.network.oplogGetMoresProcessed.num。

metrics.repl.network.ops: 从复制源读取的操作总数。

metrics.repl.network.readersCreated: 创建的 oplog 查询进程总数。每当连接发生错误时，包括超时或网络操作，MongoDB 都会创建新的 oplog 查询。此外，每次 MongoDB 选择新的复制源时，metrics.repl.network.readersCreated 都会递增。

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.totalOperationsKilled: 在mongod实例状态更改期间停止的操作总数。
7.3版本新增： totalOperationsKilled取代了userOperationsKilled

metrics.repl.stateTransition.totalOperationsRunning: 在mongod实例的状态更改期间保持运行的操作总数。
7.3版本新增： totalOperationsRunning取代了userOperationsRunning

metrics.repl.stateTransition.userOperationsKilled: 自版本7.3起已弃用： totalOperationsKilled取代了userOperationsKilled 。

metrics.repl.stateTransition.userOperationsRunning: 自版本7.3起已弃用： totalOperationsRunning取代了userOperationsRunning 。

metrics.repl.syncSource: 有关副本集节点的同步源选择进程的信息。

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

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

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

metrics.repl.syncSource.numTimesCouldNotFind: 一个节点在尝试选择同步源时找不到可用同步源的次数。

metrics.repl.waiters.replication: 等待复制或记录的写关注确认的线程数。
7.3版本新增。

metrics.repl.waiters.opTime: 排队等待本地复制 optime 分配的线程数。
7.3版本新增。

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: 自服务器进程启动以来已打开的游标总数，包括当前打开的游标。与 metrics.cursor.open.total 不同，后者仅表示当前打开的游标数量。
版本 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: 仅针对单个分片的游标总数。仅 mongos 实例报告 metrics.cursor.open.singleTarget 值。

metrics.cursor.open.multiTarget: 仅针对多个分片的游标的总数。仅 mongos 实例报告 metrics.cursor.open.multiTarget 值。

镜像读 (Mirrored Reads)

仅在 mongod 上可用。

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

mirroredReads

仅在 mongod 上可用。

报告镜像读情况的文档。如要返回 mirroredReads 信息，必须明确指定包含的内容：

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: 服务器收到的不同请求总数。使用此值为 network.bytesIn 和 network.bytesOut 值提供上下文，确保 MongoDB 的网络利用率与预期和应用程序使用情况一致。

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 文档。

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

要在 opLatencies 输出中包含直方图，请运行以下命令：

db.runCommand( { serverStatus: 1, opLatencies: { histograms: true } } ).opLatencies

opLatencies.reads: 读取请求的延迟统计信息。

opLatencies.writes: 写入操作的延迟统计信息。

opLatencies.commands: 数据库命令的延迟统计信息。

opLatencies.transactions: 数据库事务的延迟统计信息。

opWorkingTime

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

opWorkingTime

包含实例操作执行信息的文档。 latencyStats有关此文档。

opWorkingTime 下的字段以 workingMillis 来衡量，这是 MongoDB 执行该操作所花费的时间。这意味着等待锁和流量控制等因素不会影响 opWorkingTime。

要在 opWorkingTime 输出中包含直方图，请运行以下命令：

db.runCommand( { serverStatus: 1, opWorkingTime: { histogram: true } } ).opWorkingTime

8.0版本新增。

opWorkingTime.commands: 报告数据库命令执行统计信息的文档。
8.0版本新增。

opWorkingTime.reads: 报告读取操作的执行统计信息的文档。
8.0版本新增。

opWorkingTime.writes: 报告写入操作的执行统计信息的文档。
8.0版本新增。

opWorkingTime.transactions: 报告事务执行统计信息的文档。
8.0版本新增。

opReadConcernCounters

警告

已删除

从版本 5.0 开始，opReadConcernCounters 替换为 readConcernCounters。

仅适用于 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"`	未指定读关注级别而是使用默认读关注级别的查询操作数量。

opReadConcernCounters 的总和等于 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 实例上次启动以来，写入操作为该实例指定的写关注。

更具体地说，opWriteConcernCounters 报告写操作指定的 w:<value>。写关注的日志标志选项 (j) 和超时选项 (wtimeout) 不影响计数。即使操作超时，计数也会递增。

注意

仅当 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` 的值。

opWriteConcernCounters.insert 的总和等于 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` 的值。

opWriteConcernCounters.update 的总和等于 opcounters.update。

opWriteConcernCounters.delete

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

注意

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

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

指定 `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` 的值。

opWriteConcernCounters.delete 的总和等于 opcounters.delete。

运算计数器

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

opcounters

一个文档，其中按类型报告自 mongod 实例上次启动以来的数据库操作。

这些数字将随着时间的推移而增长，直到下一次重新启动。随时间推移分析这些值，跟踪数据库的使用情况。

注意

opcounters 中的数据将影响多个文档的操作（如批量插入或多重更新操作）视为单个操作。有关更细粒度的文档级操作跟踪，请参阅 metrics.document。

此外，这些值还反映接收到的操作，即使操作不成功，也会递增。

opcounters.insert: 自 mongod 实例上次启动以来收到的插入操作总数。

opcounters.query: 自 mongod 实例上次启动以来收到的查询总数。从 MongoDB 7.1 开始，聚合算作查询操作，并递增该值。

opcounters.update: 自 mongod 实例上次启动以来收到的更新操作总数。

opcounters.delete: 自 mongod 实例上次启动以来的删除操作总数。

opcounters.getmore: 自 mongod 实例上次启动以来 getMore 操作的总数。即使查询计数较低，此计数器读数也可能很高。从节点发送 getMore 操作，作为复制进程的一部分。

opcounters.command

自 mongod 实例上次启动以来向数据库发出的命令总数。

opcounters.command计算除了以下命令之外的所有命令：

opcounters.deprecated

opQuery 统计对 MongoDB 5.0 中已弃用但暂时支持的操作码的请求数量。仅当使用已弃用操作码时，此部分才会出现在 db.serverStatus() 输出中。

当 mongod 启动时，计数器会重置。

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

opcountersRepl

返回的 opcountersRepl。*值的类型为 NumberLong。

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

opcountersRepl

一个文档，其中按类型报告自 mongod 实例上次启动以来的数据库复制操作。

这些值只有在当前主机是副本集成员时才会出现。

由于 MongoDB 在复制过程中对操作进行序列化的方式不同，这些值与 opcounters 值不同。有关复制的更多信息，请参阅复制。

这些数字将随时间推移而增长，以响应数据库的使用，直到下次重新启动。随时间推移分析这些值，跟踪数据库的使用情况。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.insert

自 mongod 实例上次启动以来复制的插入操作总数。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.query

自 mongod 实例上次启动以来复制的查询总数。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.update

自 mongod 实例上次启动以来复制的更新操作总数。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.delete

自 mongod 实例上次启动以来复制的删除操作总数。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.getmore

自 mongod 实例上次启动以来 getMore 操作的总数。即使查询计数较低，此计数器读数也可能很高。从节点发送 getMore 操作，作为复制进程的一部分。

返回的 opcountersRepl。*值的类型为 NumberLong。

opcountersRepl.command

自 mongod 实例上次启动以来向数据库发出的已复制命令总数。

返回的 opcountersRepl。*值的类型为 NumberLong。

oplogTruncation

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

oplogTruncation

一个文档，其中报告 oplog 截断情况。

该字段仅在当前实例是副本集节点并且使用 WiredTiger 存储引擎或适用于自管理部署的内存存储引擎时出现。

可用于 WiredTiger 存储引擎。

oplogTruncation.totalTimeProcessingMicros

扫描或采样 oplog 以确定 oplog 截断点所用的总时间（以微秒为单位）。

totalTimeProcessingMicros 仅在 mongod 实例在现有数据文件上启动时才有意义（即对用于自管理部署的内存存储引擎没有意义）。

看 oplogTruncation.processingMethod

可用于 WiredTiger 存储引擎。

oplogTruncation.processingMethod

启动时用于确定 oplog 截断点的方法。该值可以是 "sampling" 或 "scanning"。

processingMethod 仅在 mongod 实例在现有数据文件上启动时才有意义（即对用于自管理部署的内存存储引擎没有意义）。

可用于 WiredTiger 存储引擎。

oplogTruncation.oplogMinRetentionHours

Oplog 的最短保留期（以小时为单位）。如果 oplog 已超过 oplog 大小，则 mongod 仅截断早于已配置保留值的 oplog 条目。

仅当 mongod 是副本集的节点且满足以下条件时才可见：

mongod 是使用 --oplogMinRetentionHours 命令行选项或 storage.oplogMinRetentionHours 配置文件选项启动的，
or
最短保留期是在启动后使用 replSetResizeOplog 配置的。

oplogTruncation.totalTimeTruncatingMicros

执行 oplog 截断所花费的累积时间，以微秒为单位。

可用于 WiredTiger 存储引擎。

oplogTruncation.truncateCount

oplog 截断的累积次数。

可用于 WiredTiger 存储引擎。

planCache

7.0 版本中的新增功能。

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

planCache: 一个文档，其中报告查询计划缓存统计信息。

planCache.totalQueryShapes

计划缓存查询结构的近似数量

在 7.2 版之前，有关计划缓存查询结构数量的信息存储在 query.planCacheTotalQueryShapes 字段中。

版本 7.2 中的新增内容。

planCache.totalSizeEstimateBytes

计划缓存的总大小（字节）。

在版本 7.2 之前，有关计划缓存大小的信息存储在 query.planCacheTotalSizeEstimateBytes 字段中。

版本 7.2 中的新增内容。

planCache.classic.hits: 在查询缓存中找到并重用于避免查询计划阶段的经典执行引擎查询计划的数量。

planCache.classic.misses: 在查询缓存中未找到并经过查询计划阶段的经典执行引擎查询计划数。

planCache.classic.skipped: 由于查询不符合缓存条件而在查询缓存中找不到的经典执行引擎查询计划的数量。
7.3版本新增。

planCache.sbe.hits: 在查询缓存中找到并重复使用以避免查询规划阶段的基于槽的执行引擎查询计划数量。

planCache.sbe.misses: 在查询缓存中未找到并经过查询计划阶段的基于时隙的执行引擎查询计划数。

planCache.sbe.skipped: 由于查询不符合缓存条件而在查询缓存中找不到的基于槽的执行引擎查询计划的数量。
7.3版本新增。

queryStats

版本 7.1 中的新增内容。

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

queryStats: 包含$queryStats聚合阶段指标的文档。

queryStats.numEvicted: $queryStats collection由于空间限制而逐出的查询数量。

queryStats.numRateLimitedRequests: 由于速率限制而未记录查询的查询统计信息的次数。

queryStats.queryStatsStoreSizeEstimateBytes: $queryStats虚拟collection中对象的当前估计大小。

queryStats.numQueryStatsStoreWriteErrors: 此 MongoDB 进程无法存储新的查询统计数据键的次数。通常，当$queryStats虚拟collection空间不足时，会发生这些故障。

queryStats.numHmacApplicationErrors: 使用transformIdentifiers选项调用$queryStats时，此 MongoDB 进程无法计算单向标记化查询统计信息键的次数。

queryAnalyzers

7.0 版本中的新增功能。

queryAnalyzers: {
  activeCollections: <integer>,
  totalCollections: <integer>,
  totalSampledReadsCount: <integer>,
  totalSampledWritesCount: <integer>,
  totalSampledReadsBytes: <integer>,
  totalSampledWritesBytes: <integer>
}

queryAnalyzers.activeCollections: 查询分析器主动采样的集合数量。

queryAnalyzers.totalCollections: 已采样集合的总数。

queryAnalyzers.totalSampledReadsCount: 已采样读取查询的总数。

queryAnalyzers.totalSampledWritesCount: 已采样写入查询的总数。

queryAnalyzers.totalSampledReadsBytes: 已采样读取查询的总大小（字节）。此指标仅在 mongod 上运行 serverStatus 时可用。

queryAnalyzers.totalSampledWritesBytes: 已采样写入查询的总大小（字节）。此指标仅在 mongod 上运行 serverStatus 时可用。

队列

随着在各阶段进行操作，如果当前阶段的并发操作数超过最大阈值，则该操作可能会进入队列。这可以防止过多的资源争用，并提供对数据库状态的可观察。

8.0版本新增。

queues: {
   execution: {
      write: {
         out: Long("<num>"),
         available: Long("<num>"),
         totalTickets: Long("<num>"),
         exempt: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         },
         normalPriority: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         }
      },
      read: {
         out: Long("<num>"),
         available: Long("<num>"),
         totalTickets: Long("<num>"),
         exempt: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>")),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         },
         normalPriority: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         }
      },
      monitor: {
         timesDecreased: Long("<num>"),
         timesIncreased: Long("<num>"),
         totalAmountDecreased: Long("<num>"),
         totalAmountIncreased: Long("<num>"),
         resizeDurationMicros: Long("<num>")
      }
   },
   ingress: {
      out: Long("<num>"),
      available: Long("<num>"),
      totalTickets: Long("<num>"),
      exempt: {
         addedToQueue: Long("<num>"),
         removedFromQueue: Long("<num>"),
         queueLength: Long("<num>"),
         startedProcessing: Long("<num>"),
         processing: Long("<num>"),
         finishedProcessing: Long("<num>"),
         totalTimeProcessingMicros: Long("<num>"),
         canceled: Long("<num>"),
         newAdmissions: Long("<num>"),
         totalTimeQueuedMicros: Long("<num>")
      },
      normalPriority: {
         addedToQueue: Long("<num>"),
         removedFromQueue: Long("<num>"),
         queueLength: Long("<num>"),
         startedProcessing: Long("<num>"),
         processing: Long("<num>"),
         finishedProcessing: Long("<num>"),
         totalTimeProcessingMicros: Long("<num>"),
         canceled: Long("<num>"),
         newAdmissions: Long("<num>"),
         totalTimeQueuedMicros: Long("<num>")
      }
   }
}

queues.execution

8.0版本新增。

一个文档，它提供了存储层中等待执行的并发事务操作的监控和排队信息。

这些设置专属于 MongoDB。要更改并发读取和写入事务（读取和写入票证）的设置，请参阅 storageEngineConcurrentReadTransactions 和 storageEngineConcurrentWriteTransactions。

重要

从版本 7.0 开始，MongoDB 使用默认算法动态调整并发存储引擎事务的最大数量（包括读写票证），以优化过载期间的数据库吞吐量。

下表总结了如何识别 MongoDB 7.0 后版本以及更早版本的过载场景：

版本	诊断过载情况
7.0及更高版本	持续较长时间的大量排队操作很可能表示过载。并发存储引擎事务（票证）可用性长时间为 0 并不表示存在过载。
6.0 及更早版本	持续较长时间的大量排队操作很可能表示过载。并发存储引擎事务（票证）可用性长时间为 0 可能表明出现过载。

queues.execution.write: 返回允许进入 WiredTiger 存储引擎的并发读取事务（读取工单）队列信息的文档。

queues.execution.read: 一个文档，返回 WiredTiger 存储引擎中允许的并发写事务（写工单）的队列信息。

queues.execution.monitor

一个文档，返回系统对允许并发事务（工单）数量所做调整的监控指标。

queues.execution.monitor.timesDecreased

队列大小减小的次数。

queues.execution.monitor.timesIncreased

队列大小增加的次数。

queues.execution.monitor.totalAmountDecreased

队列减少的操作总量。

queues.execution.monitor.totalAmountIncreased

队列增加的操作总数。

queues.execution.monitor.resizeDurationMicros

系统调整队列大小的累计时间（以毫秒为单位）。

queues.ingress

8.0版本新增。

一个文档，返回用于入口准入控制的队列信息。利用这些值能够限制从网络进入数据库的操作数量，进而保护数据库并减轻资源过载的问题。

允许的并发操作的最大数量受 ingressAdmissionControllerTicketPoolSize 的限制。

队列信息

out: Long("<num>"),
available: Long("<num>"),
totalTickets: Long("<num>"),
exempt: {
   addedToQueue: Long("<num>"),
   removedFromQueue: Long("<num>"),
   queueLength: Long("<num>"),
   startedProcessing: Long("<num>"),
   processing: Long("<num>"),
   finishedProcessing: Long("<num>"),
   totalTimeProcessingMicros: Long("<num>"),
   canceled: Long("<num>"),
   newAdmissions: Long("<num>"),
   totalTimeQueuedMicros: Long("<num>")
},
normalPriority: {
   addedToQueue: Long("<num>"),
   removedFromQueue: Long("<num>"),
   queueLength: Long("<num>"),
   startedProcessing: Long("<num>"),
   processing: Long("<num>"),
   finishedProcessing: Long("<num>"),
   totalTimeProcessingMicros: Long("<num>"),
   canceled: Long("<num>"),
   newAdmissions: Long("<num>"),
   totalTimeQueuedMicros: Long("<num>")
}

out: 当前持有的工单数量。

available: 可用的工单数。

totalTickets: 工单池的大小。

exempt: 一个返回从队列中排除操作的指标的文档。

exempt.startedProcessing: 获取准入工单的操作总数。

exempt.processing: 当前正在处理的操作总数。

exempt.finishedProcessing: 发布准入工单的操作总数。

exempt.totalTimeProcessingMicros: 总操作时间持有准入工单。

exempt.canceled: 队列中超时的操作总数。

exempt.newAdmissions: 新加入队列的总数。

exempt.totalTimeQueuedMicros: 队列中操作等待的总时间。

normalPriority: 一个文档，返回受队列影响的操作的指标。

normalPriority.addedToQueue: 添加到队列中的操作总数。

normalPriority.removedFromQueue: 从队列中移除的操作总数。

normalPriority.queueLength: 队列中的操作总数。

normalPriority.startedProcessing: 获取准入工单的操作总数。

normalPriority.processing: 当前正在处理的操作总数。

normalPriority.finishedProcessing: 发布准入工单的操作总数。

normalPriority.totalTimeProcessingMicros: 总操作时间持有准入工单。

normalPriority.canceled: 队列中超时的操作总数。

normalPriority.newAdmissions: 新加入队列的总数。

normalPriority.totalTimeQueuedMicros: 队列中操作等待的总时间。

querySettings

8.0版本新增。

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

querySettings

包含配置计数和查询设置使用情况的文档。

从 MongoDB 8.0开始，使用查询设置而不是添加索引筛选器。从 MongoDB 8.0开始，索引筛选器已弃用。

查询设置的功能比索引筛选器更多。此外，索引筛选器不是持久性的，您无法轻松地为所有集群节点创建索引筛选器。要添加查询设置并探索示例，请参阅setQuerySettings 。

querySettings.count: 查询设置的总数。

querySettings.rejectCount: 将 reject 字段设置为 true 的查询设置总数。要设置 reject 字段，请使用 setQuerySettings。

querySettings.size: 查询设置的总大小（以字节为单位）。

readConcernCounters

版本 5.0 中的新增功能。

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

readConcernCounters: 用于报告查询操作指定的读关注级别的文档。该文档包含 readConcernCounters.nonTransactionOps 和 readConcernCounters.transactionOps 文档。

readConcernCounters.nonTransactionOps: 一个文档，其中报告数据库服务器上次启动后执行的非事务查询操作所指定的读关注级别。

readConcernCounters.nonTransactionOps.none

未指定读关注级别而使用以下任一选项的非事务查询操作数量：

默认的读关注级别，或
全局默认读取会关注配置（如果由 setDefaultRWConcern 命令设置）。

readConcernCounters.nonTransactionOps.noneInfo

使用全局默认读关注和隐式默认读关注的非事务查询操作的数量。

readConcernCounters.nonTransactionOps.noneInfo 中的值之和应等于 readConcernCounters.nonTransactionOps.none 的值。

readConcernCounters.nonTransactionOps.local: 指定 "local" 读关注级别的非事务查询操作的数量。

readConcernCounters.nonTransactionOps.available: 指定 "available" 读关注级别的非事务查询操作的数量。

readConcernCounters.nonTransactionOps.majority: 指定 "majority" 读关注级别的非事务查询操作的数量。

readConcernCounters.nonTransactionOps.snapshot: 包含指定 "snapshot" 读关注级别的非事务查询操作的文档。

readConcernCounters.nonTransactionOps.snapshot.withClusterTime: 指定 "snapshot" 读关注级别和集群时间（指定时间点）的非事务查询操作数。

readConcernCounters.nonTransactionOps.snapshot.withoutClusterTime: 指定 "snapshot" 读关注级别但没有集群时间的非事务查询操作数，这意味着省略了某个时间点，服务器将读取该节点可用的最近提交的快照。

readConcernCounters.nonTransactionOps.linearizable: 指定 "linearizable" 读关注级别的非事务查询操作的数量。

readConcernCounters.transactionOps: 一个文档，其中报告数据库服务器上次启动后执行的事务查询操作所指定的读关注级别。

readConcernCounters.transactionOps.none: 满足以下条件的事务查询操作数：未指定读关注级别而是使用默认读关注级别或借助 setDefaultRWConcern 命令添加的全局默认读关注或写关注配置。

readConcernCounters.transactionOps.noneInfo: 有关全局默认读关注和事务查询操作使用的隐式默认读关注的信息。

readConcernCounters.transactionOps.local: 指定 "local" 读关注级别的事务查询操作数。

readConcernCounters.transactionOps.available: 指定 "available" 读关注级别的事务查询操作数。

readConcernCounters.transactionOps.majority: 指定 "majority" 读关注级别的事务查询操作数。

readConcernCounters.transactionOps.snapshot: 包含指定 "snapshot" 读关注级别的事务查询操作的文档。

readConcernCounters.transactionOps.snapshot.withClusterTime: 指定 "snapshot" 读关注级别和集群时间（指定时间点）的事务查询操作数。

readConcernCounters.transactionOps.snapshot.withoutClusterTime: 指定 "snapshot" 读关注级别但没有集群时间的事务查询操作数，这意味着省略了某个时间点，服务器将读取该节点可用的最近提交的快照。

readPreferenceCounters

从 MongoDB 7.2（以及 7.0.3、 6.0.11)。

仅在 mongod 上可用。

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

readPreferenceCounters

仅在 mongod 上可用。

一个文档，其中报告此 mongod 节点接收到的具有指定读取偏好的操作数。

tagged 子字段是指通过标签传入的任何读取偏好。

readPreferenceCounters.executedOnPrimary

仅在 mongod 上可用。

一个文档，用于计算该节点在充当主节点时接收的内部和外部读取偏好操作的数量。

readPreferenceCounters.executedOnSecondary

仅在 mongod 上可用。

一个文档，用于计算该节点在充当从节点时接收的内部和外部读取偏好操作的数量。

repl

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

repl: 一个文档，其中报告副本集配置。repl 仅在当前主机为副本集时出现。有关复制的更多信息，请参阅复制。

repl.hosts: 当前副本集节点的主机名和端口信息 ("host:port") 的数组

repl.setName: 一个体现当前副本集名称的字符串。该值反映了 --replSet 命令行参数或配置文件中的 replSetName 值。

repl.isWritablePrimary: 一个布尔值，指示当前节点是否为副本集的主节点。

repl.secondary: 一个布尔值，指示当前节点是否为副本集的从节点。

repl.primary: 副本集当前主节点的主机名和端口信息 ("host:port")。

repl.me: 副本集当前节点的主机名和端口信息 ("host:port" )。

repl.primaryOnlyServices: 包含服务器上每个活动主服务实例的数量和状态的文档。主服务只能在服务器为主服务器时启动，但可以在服务器更改状态后继续运行直至完成。
版本 5.0 中的新增功能。

repl.primaryOnlyServices.ReshardingRecipientService

包含 ReshardingRecipientService 的状态和实例数量的文档：

由分片接收，根据新的分片键和区域，分片会在重新分片操作后拥有数据块。

重新分片协调节点指示每个发送和接收分片主节点，以重命名临时分片集合。临时集合将成为新的重新分片集合。

版本 5.0 中的新增功能。

repl.primaryOnlyServices.RenameCollectionParticipantService

包含 RenameCollectionParticipantService 的状态和实例数量的文档：

RenameCollectionParticipantService 确保在某个分片收到 renameCollection 请求后，该分片能够在系统出现故障的情况下恢复本地重命名。

版本 5.0 中的新增功能。

repl.primaryOnlyServices.ShardingDDLCoordinator

包含 ShardingDDLCoordinator 的状态和实例数量的文档：

ShardingDDLCoordinator 服务管理主节点数据库的 DDL 操作，例如：创建数据库、删除数据库、renameCollection。

ShardingDDLCoordinator 确保在分片集群内的任何一个特定时间点，对每个数据库都执行一次 (DDL) 操作。

版本 5.0 中的新增功能。

repl.primaryOnlyServices.ReshardingDonorService

包含 ReshardingDonorService 的状态和实例数量的文档：

捐赠者是在重命名操作完成之前拥有分片集合数据段的分片。

重新分片协调节点指示每个发送和接收分片主节点，以重命名临时分片集合。临时集合将成为新的重新分片集合。

版本 5.0 中的新增功能。

repl.rbid: 回滚标识符。用于确定此 mongod 实例是否发生了回滚。

repl.replicationProgress

数组，其中副本集的每个成员都有一个文档，用于向该成员报告复制进程。通常，这是主节点，如果使用链式复制，则为从节点。

要包含此输出，必须将 repl 选项传递给 serverStatus，如下所示：

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

repl.replicationProgress 部分的内容取决于每个节点的复制源。本部分支持内部操作，仅供内部和诊断使用。

repl.replicationProgress[n].rid: 一个 ObjectId，用作副本集成员的 ID。仅供内部使用。

repl.replicationProgress[n].optime: 该节点报告的有关该节点应用 oplog 中最后一次操作的信息。

repl.replicationProgress[n].host: 副本集节点的主机名，采用 [hostname]:[port] 格式。

repl.replicationProgress[n].memberID: 此副本集节点的整数标识符。

安全性

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

security

一个文档，其中报告：

使用给定身份验证机制针对 mongod 或 mongos 实例进行身份验证的次数。
mongod / mongos 实例的 TLS/SSL 证书。（仅出现在支持 TLS 的 mongod 或 mongos 实例中）

security.authentication.saslSupportedMechsReceived: 版本 5.0 中的新增功能。
hello 请求包含有效 hello.saslSupportedMechs 字段的次数。

security.authentication.mechanisms: 一个文档，其中报告使用给定身份验证机制对 mongod 或 mongos 实例进行身份验证的次数。文档中的值区分标准身份验证和推测性身份验证。[1]
注意
mechanisms 文档中的字段取决于 authenticationMechanisms 参数的配置。mechanisms 文档包含 mongod 或 mongos 实例支持的每种身份验证机制的字段。
以下示例展示了仅支持 x.509 身份验证的部署的 mechanisms 文档的形状。

security.authentication.mechanisms.MONGODB-X509

一个文档，其中报告使用 x.509 对 mongod 或 mongos 实例进行身份验证的次数。

包括 x.509 身份验证尝试总次数以及推测性尝试子集。[1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.received: 使用 x.509 收到的推测性身份验证尝试次数。包括成功和失败的推测性身份验证尝试。[1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.successful: 使用 x.509 成功收到的推测性身份验证尝试次数。[1]

security.authentication.mechanisms.MONGODB-X509.authenticate.received: 使用 x.509 收到的成功和失败的身份验证尝试次数。此值包括使用 x.509 收到的推测性身份验证尝试。

security.authentication.mechanisms.MONGODB-X509.authenticate.successful: 使用 x.508 收到的成功身份验证尝试次数。此值包括使用 x.509 的成功推测性身份验证尝试。

[1]	(1, 2, 3, 4) 推测性身份验证可最大限度地减少身份验证过程中的网络往返次数，从而优化性能。

security.SSLServerSubjectName: 与 mongod / mongos 实例的 TLS/SSL 证书关联的主题名称。

security.SSLServerHasCertificateAuthority

一个布尔值：

true 当 mongod / mongos 实例的 TLS/SSL 证书与证书颁发机构关联时。
false 当 TLS/SSL 证书是自签名时。

security.SSLServerCertificateExpirationDate: mongod / mongos 实例的 TLS/SSL 证书的到期日期和时间。

分片

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

sharding: 包含与分片集群相关的数据的文档。lastSeenConfigServerOpTime 仅适用于 mongos 或分片成员，不适用于配置服务器。

sharding.configsvrConnectionString: 配置服务器的连接字符串。

sharding.lastSeenConfigServerOpTime

mongos 或分片节点已看到的 CSRS 主节点的最新 optime。optime 文档包括：

ts，操作的时间戳。
t，最初在主节点上生成操作的term。

仅当分片集群使用 CSRS 时，才会出现 lastSeenConfigServerOpTime。

sharding.maxChunkSizeInBytes: 迁移范围的最大大小限制。如果此值最近已在配置服务器上更新，maxChunkSizeInBytes 可能无法反映最新值。

shardingStatistics

在分片的成员上运行时：

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>"),
   countTransitionToDedicatedConfigServerStarted : Long("<num>"), // Added in MongoDB 8.0
   countTransitionToDedicatedConfigServerCompleted : Long("<num>"), // Added in MongoDB 8.0
   countTransitionFromDedicatedConfigServerCompleted : Long("<num>"), // Added in MongoDB 8.0
   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>,
   configServerInShardCache : <boolean>, // Added in MongoDB 8.0
   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")
       }
    }
   }
},

在 mongos 上运行时：

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>")
   },
   configServerInShardCache : <boolean> // Added in MongoDB 8.0
}

shardingStatistics: 包含分片集群上的元数据刷新相关指标的文档。

shardingStatistics.countStaleConfigErrors

线程遇到过时配置异常的总次数。由于过时配置异常会触发元数据刷新，因此该数字大致与元数据刷新次数成正比。

仅当在分片上运行时才出现。

shardingStatistics.countDonorMoveChunkStarted

作为范围迁移过程的一部分，MongoDB 在分片的主节点上启动 moveChunk 命令或 moveRange 命令的总次数。这个不断增加的次数不考虑数据块迁移是否成功。

仅当在分片上运行时才出现。

shardingStatistics.countDonorMoveChunkCommitted

MongoDB 在分片主节点上提交的数据段迁移总数。

数据段迁移由 moveChunk 和 moveRange 命令在范围迁移过程中执行。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.countDonorMoveChunkAborted

MongoDB 在分片主节点上中止的数据段迁移总数。

数据段迁移由 moveChunk 和 moveRange 命令在范围迁移过程中执行。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.totalDonorMoveChunkTimeMillis

将数据段从当前分片移动到其他分片的累计时间（毫秒）。对于每个数据段迁移，时间从 moveRange 或 moveChunk 命令启动时开始，在范围迁移过程中将数据段移至其他分片时结束。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.totalDonorChunkCloneTimeMillis

范围迁移过程的克隆阶段在分片主节点上所花费的累计时间（毫秒）。具体而言，对于此分片上的每次迁移，跟踪的时间从 moveRange 和 moveChunk 命令开始，在目标分片进入 catchup 阶段以应用范围迁移过程中发生的更改之前结束。

仅当在分片上运行时才出现。

shardingStatistics.totalCriticalSectionCommitTimeMillis

范围迁移过程的更新元数据阶段在分片主节点上所花费的累计时间（毫秒）。在更新元数据阶段，MongoDB 会阻止对集合的所有操作。

仅当在分片上运行时才出现。

shardingStatistics.totalCriticalSectionTimeMillis

范围迁移过程的追赶阶段和更新元数据阶段在分片主节点上花费的累计时间（毫秒）。

要计算追赶阶段的持续时间，请从 totalCriticalSectionTimeMillis 中减去 totalCriticalSectionCommitTimeMillis：

totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis

仅当在分片上运行时才出现。

shardingStatistics.countDocsClonedOnRecipient

MongoDB 在接收分片主节点上克隆的文档不断增加的累计数量。

仅当在分片上运行时才出现。

shardingStatistics.countBytesClonedOnRecipient

在范围迁移过程中，MongoDB 在接收分片的主节点上克隆的累计字节数。

有关数据同步的详细信息，请参阅副本集数据同步。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.countDocsClonedOnCatchUpOnRecipient

在范围迁移过程的追赶阶段，MongoDB 在接收分片主节点上克隆的累计文档数。

有关数据同步的详细信息，请参阅副本集数据同步。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.countBytesClonedOnCatchUpOnRecipient

在范围迁移过程的追赶阶段，MongoDB 在接收分片主节点上克隆的累计字节数。

有关数据同步的详细信息，请参阅副本集数据同步。

仅在分片上可用。

从 MongoDB 7.1（以及 7.0、6.3.2、6.0.6 和 5.0.18）开始提供。

shardingStatistics.countDocsClonedOnDonor

MongoDB 在发送分片主节点上复制的文档的累积且不断增加的数量。

仅当在分片上运行时才出现。

shardingStatistics.countRecipientMoveChunkStarted

此成员作为接收分片的主分片，已开始接收的数据段的累计数量（无论移动是否成功），该计数会持续增加。

仅当在分片上运行时才出现。

shardingStatistics.countDocsDeletedByRangeDeleter

MongoDB 在数据段迁移期间在源分片的主节点上删除文档的累积数量，该计数会持续增加。

仅当在分片上运行时才出现。

在版本 7.1 中进行了更改。

shardingStatistics.countDonorMoveChunkLockTimeout

MongoDB 因锁获取超时而在源分片的主节点上中止数据段迁移的累计次数，该计数会持续增加。

仅当在分片上运行时才出现。

shardingStatistics.unfinishedMigrationFromPreviousPrimary

选举后上一个主节点留下的未完成迁移数。只有在新当选的 mongod 转换为主节点的过程完成后，该值才会更新。

仅当在分片上运行时才出现。

shardingStatistics.chunkMigrationConcurrency

源分片和接收分片上用于执行数据段迁移操作的线程数。

仅当在分片上运行时才出现。

从 MongoDB 6.3（和 5.0.15）开始可用。

shardingStatistics.catalogCache: 包含有关集群路由信息缓存的统计信息的文档。

shardingStatistics.catalogCache.numDatabaseEntries: 目录缓存中当前数据库条目的总数。

shardingStatistics.catalogCache.numCollectionEntries: 目录缓存中当前集合条目（跨所有数据库）的总数。

shardingStatistics.catalogCache.countStaleConfigErrors: 线程遇到过时配置异常的总次数。过时配置异常会触发元数据刷新。

shardingStatistics.catalogCache.totalRefreshWaitTimeMicros: 线程等待元数据刷新所用的累计时间（以微秒为单位）。

shardingStatistics.catalogCache.numActiveIncrementalRefreshes: 当前等待完成的增量目录缓存刷新次数。

shardingStatistics.countIncrementalRefreshesStarted: 已启动的增量刷新的累计次数。

shardingStatistics.catalogCache.numActiveFullRefreshes: 当前等待完成的完整目录缓存刷新次数。

shardingStatistics.catalogCache.countFullRefreshesStarted: 已启动的完整刷新的累计次数。

shardingStatistics.catalogCache.countFailedRefreshes: 失败的完整刷新或增量刷新的累计次数。

shardingStatistics.countTransitionToDedicatedConfigServerStarted

transitionToDedicatedConfigServer 命令启动的次数。

仅在配置服务器节点上运行时出现。

8.0版本新增。

shardingStatistics.countTransitionToDedicatedConfigServerCompleted

transitionToDedicatedConfigServer 命令完成的次数。

仅在配置服务器节点上运行时出现。

8.0版本新增。

shardingStatistics.countTransitionFromDedicatedConfigServerCompleted

transitionFromDedicatedConfigServer 命令完成的次数。

仅在配置服务器节点上运行时出现。

8.0版本新增。

shardingStatistics.rangeDeleterTasks

在范围迁移过程中，当前排队的已准备好运行或正运行的数据段范围删除任务的总数。

查看 config.rangeDeletions 集合中的文档，了解数据段迁移后有待从分片中删除的数据段范围的信息。

仅在分片节点上运行时出现。

shardingStatistics.configServerInShardCache: 一个布尔值，表示配置服务器是否为配置分片。此值会定期刷新，因此在运行状况良好的集群中， configServerInShardCache 的值可能会过时大约一分钟。如果节点无法与配置服务器通信，则 configServerInShardCache 可能会在较长时间内保持过时状态。

shardingStatistics.resharding

包含重新分片操作相关统计信息的文档。

每个分片都返回自己的重新分片操作统计数据。如果分片不参与重新分片操作，则该分片将不包含有关重新分片操作的统计数据。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.countStarted

countSucceeded、 countFailed和 countCanceled 的总和。如果重新分片操作已开始但尚未完成，则总和值将进一步加 1。当 mongod 启动或重新启动时，总和值将被设置为 0。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.countSucceeded

成功执行重新分片操作的次数。启动或重新启动 mongod 时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.countFailed

重新分片操作失败的次数。启动或重新启动 mongod 时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.countCanceled

取消的重新分片操作的数量。启动或重新启动 mongod 时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.active.resharding.documentsCopied

当前重新分片操作中从发送分片复制到接收分片的文档数量。开始新的重新分片操作时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

在版本 6.1 中进行了更新

shardingStatistics.resharding.active.bytesCopied

当前重新分片操作中从发送分片复制到接收分片的字节数量。开始新的重新分片操作时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

在版本 6.1 中进行了更新

shardingStatistics.resharding.active.countWritesToStashCollections: 重新分片期间，写入接收储藏集合的次数。
6.1 版本新增内容。

shardingStatistics.resharding.active.countWritesDuringCriticalSection

当前重新分片操作在关键部分执行的写入次数。关键部分可防止对当前正在重新分片的集合进行新的传入写入。开始新的重新分片操作时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

在版本 6.1 中进行了更新

shardingStatistics.resharding.active.countReadsDuringCriticalSection: 在重新分片期间，在发送分片的关键部分尝试读取的次数。
6.1 版本新增内容。

shardingStatistics.resharding.active.oplogEntriesFetched

从当前重新分片操作的 oplog 获取的条目数。开始新的重新分片操作时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

在版本 6.1 中进行了更新

shardingStatistics.resharding.active.oplogEntriesApplied

应用于当前重新分片操作的 oplog 的条目数。开始新的重新分片操作时，该数字将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

在版本 6.1 中进行了更新

shardingStatistics.resharding.active.insertsApplied: 重新分片期间应用的插入操作总数。
6.1 版本新增内容。

shardingStatistics.resharding.active.updatesApplied: 重新分片期间应用的更新操作总数。
6.1 版本新增内容。

shardingStatistics.resharding.active.deletesApplied: 重新分片期间应用的删除操作总数。
6.1 版本新增内容。

shardingStatistics.resharding.oldestActive.coordinatorAllShardsHighestRemainingOperationTimeEstimatedMillis: 在所有分片上计算的剩余描述的最高估值。如果无法计算时间估值，则该值设置为 -1。
6.1 版本新增内容。

shardingStatistics.resharding.oldestActive.coordinatorAllShardsLowestRemainingOperationTimeEstimatedMillis: 在所有分片上计算的剩余秒数的最低估值。如果无法计算时间估值，则该值设置为 -1。
6.1 版本新增内容。

shardingStatistics.resharding.oldestActive.recipientRemainingOperationTimeEstimatedMillis

当前重新分片操作的估计剩余时间（毫秒）。在重新分片之前，或者在无法计算时间时，该值将被设置为 -1。

如果一个分片涉及多个重新分片操作，则此字段包含该分片作为接收分片的最早重新分片操作的剩余时间估计。

6.1 版本新增内容。

shardingStatistics.resharding.oldestActive.totalOperationTimeElapsedMillis

当前重新分片操作所用的总时间（毫秒）。开始新的重新分片操作时，时间将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

shardingStatistics.resharding.latencies: 重新分片操作的计时指标。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchRetrievalTimeMillis: 接收分片从发送分片处检索文档批次所用的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchesRetrieved: 接收分片从发送分片处检索的文档的批次总数。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.collectionCloningTotalLocalInsertTimeMillis: 接收分片从发送分片处插入文档批次所用的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.collectionCloningTotalLocalInserts: 接收者插入的来自捐赠者的文档批次总数。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchRetrievalTimeMillis: 接收分片从发送分片那里检索 oplog 条目批次所花费的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchesRetrieved: 接收分片从发送分片处检索的 oplog 条目的批次总数。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInsertTimeMillis: 接收分片从发送分片处插入 oplog 条目批次所用的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInserts: 接收分片插入的来自发送分片的 oplog 条目批次总数。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchRetrievalTimeMillis: 接收分片检索在获取期间插入的 oplog 条目批次所用的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesRetrieved: 在接收分片检索的提取过程中插入的 oplog 条目的批次总数。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchApplyTimeMillis: 接收分片应用批量 oplog 条目所花费的总时间（以毫秒为单位）。
6.1 版本新增内容。

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesApplied: 接收方应用的 oplog 条目的批处理总数。
6.1 版本新增内容。

shardingStatistics.resharding.totalApplyTimeElapsedMillis

当前重新分片操作的应用步骤所用的总时间（毫秒）。在应用步骤中，接收分片根据来自发送分片的新传入写入来修改其数据。开始新的重新分片操作时，时间将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

shardingStatistics.resharding.totalCriticalSectionTimeElapsedMillis

当前重新分片操作的关键部分所用的总时间（毫秒）。关键部分可防止对当前正在重新分片的集合进行新的传入写入。开始新的重新分片操作时，时间将被设置为 0。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

shardingStatistics.resharding.donorState

当前重新分片操作的发送分片的状态。开始新的重新分片操作时，该数字将被设置为 0。

返回的数字	含义	说明
0	`unused`	该分片不是当前重新分片操作中的发送分片。
1	`preparing-to-donate`	源分片正准备向接收分片提供数据。
2	`donating-initial-data`	发送分片正在向接收分片发送数据。
3	`donating-oplog-entries`	发送分片正在向接收分片发送 oplog 条目。
4	`preparing-to-block-writes`	发送分片即将阻止对正在重新分片的集合进行新的传入写入操作。
5	`error`	重新分片操作过程中发生错误。
6	`blocking-writes`	发送分片正在阻止新的传入写入操作，并且发送分片已通知所有接收分片新的传入写入已禁止。
7	`done`	发送分片已经删除旧的分片集合，重新分片操作已完成。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

shardingStatistics.resharding.recipientState

当前重新分片操作的接收分片的状态。开始新的重新分片操作时，该数字将被设置为 0。

返回的数字	含义	说明
0	`unused`	分片不是当前重新分片操作中的接收分片。
1	`awaiting-fetch-timestamp`	接收分片正在等待发送分片做好发送数据的准备
2	`creating-collection`	接收分片正在创建新的分片集合。
3	`cloning`	接收分片正在接收来自发送分片的数据。
4	`applying`	接收分片正在应用 oplog 条目，以根据来自发送分片的新传入写入来修改数据副本。
5	`error`	重新分片操作过程中发生错误。
6	`strict-consistency`	接收分片将所有数据更改存储在临时集合中。
7	`done`	重新分片操作已完成。

仅当对分片或配置服务器上运行时才存在。对配置服务器运行时则返回 0。

版本 5.0 中的新增功能。

shardingStatistics.numHostsTargeted

指示针对 CRUD 操作和聚合命令的分片数量。运行 CRUD 操作或聚合命令时，以下指标将递增。

名称	说明
`allShards`	针对所有分片的命令
`manyShards`	针对多个分片的命令
`oneShard`	针对一个分片的命令
`unsharded`	在未分片的集合上运行的命令

注意

在 mongos 上运行 serverStatus 命令可以深入了解在分片集群上运行的 CRUD 和聚合操作。

多分片操作可以是分散收集，也可以特定于分片。多分片分散收集操作可能会消耗更多资源。使用 shardingStatistics.numHostsTargeted 指标，可以调整在分片集群上运行的聚合查询。

shardingStatistics.resharding.coordinatorState

当前重新分片操作的重新分片协调器的状态。重新分片协调器是在配置服务器主节点上运行的线程。开始新的重新分片操作时，该数字将被设置为 0。

返回的数字	含义	说明
0	`unused`	该分片不是当前重新分片操作中的协调者。
1	`initializing`	重新分片协调器已将协调器文档插入 `config.reshardingOperations` 中，并将 `reshardingFields` 添加到原始集合的 `config.collections` 条目中。
2	`preparing-to-donate`	重新分片协调器已为临时重新分片集合创建了一个 `config.collections` 条目。已在 `config.chunks` 中插入了基于新分片键的范围条目。已将条目插入到与新分片键关联的任何区域的 `config.tags` 中。协调器通知参与分片开始重新分片操作。然后，协调器将等待，直到所有发送分片都选择了一个 `minFetchTimestamp` 并准备好发送。
3	`cloning`	重新分片协调节点通知发送分片将数据发送给接收分片。协调节点等待所有接收分片完成对发送分片数据的克隆。
4	`applying`	重新分片协调器通知接收分片根据来自发送分片的新传入写入来修改其数据副本。协调器等待所有接收分片完成应用 oplog 条目。
5	`blocking-writes`	重新分片协调节点通知发送分片，以防止对正在重新分片的集合进行新的传入写入操作。然后，协调节点等待所有接收分片进行所有数据更改。
6	`aborting`	在重新分片操作或运行 `abortReshardCollection` 命令（或 `sh.abortReshardCollection()` 方法）期间出现不可恢复的错误。
6	`committing`	重新分片协调器删除了临时重新分区集合的 `config.collections` 条目。然后，协调器将 `recipientFields` 添加到源集合的条目中。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.opStatus

当前重新分片操作的状态。

返回的数字	说明
-1	重新分片操作不在进行中。
0	重新分片操作成功。
1	重新分片操作失败。
2	重新分片操作已取消。

仅当对分片或配置服务器上运行时才存在。

版本 5.0 中的新增功能。

shardingStatistics.resharding.lastOpEndingChunkImbalance

此字段包含最近重新分片操作处理的集合的所有区域中 ( maxNumChunksInShard - minNumChunksInShard ) 的最大数值差。

请参阅范围大小。

仅在配置服务器上更新。

版本 5.0 中的新增功能。

shardedIndexConsistency

shardedIndexConsistency : {
   numShardedCollectionsWithInconsistentIndexes : Long("<num>")
},

shardedIndexConsistency

仅在配置服务器实例上可用。

一份文档：返回分片集合索引一致性检查的结果。

仅当在分片集群的配置服务器副本集的主节点上运行时，返回的指标才有意义。

提示

另请参阅：

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

shardedIndexConsistency.numShardedCollectionsWithInconsistentIndexes

仅在配置服务器实例上可用。

分片之间索引不一致的分片集合的数量。如果分片集合在包含集合数据段的每个分片上不具有完全相同的索引（包括索引选项），则分片集合的索引不一致。

要确认分片集合是否存在不一致的索引，请参阅查找分片间不一致的索引。

仅当在分片集群的配置服务器副本集的主节点上运行时，返回的指标才有意义。

提示

另请参阅：

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

引擎加密

storageEngine : {
   name : <string>,
   supportsCommittedReads : <boolean>,
   persistent : <boolean>
},

storageEngine: 包含有关当前存储引擎的数据的文档。

storageEngine.name: 当前存储引擎的名称。

storageEngine.supportsCommittedReads: 一个布尔值，指示存储引擎是否支持 "majority" 读关注。

storageEngine.persistent: 一个布尔值，指示存储引擎是否将数据持久存储到磁盘。

tcmalloc

注意

tcmalloc 此页面中省略了仅供内部使用的指标。

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

tcmalloc

注意

从 8.0 版开始，MongoDB 使用 TCMalloc 的更新版本，改进了内存碎片和管理。如需了解更多信息，请参阅 tcmalloc 升级。

包含服务器内存分配信息的文档。tcmalloc 指标默认包含在 serverStatus 输出中。要更改 tcmalloc 部分的详细程度，请指定一个介于 0 和 3（含）之间的整数：

如果将详细程度设置为 0，则 tcmalloc 指标不会包含在 serverStatus 输出中。
如果将详细程度设置为 1，则 serverStatus 输出将包括默认的 tcmalloc 指标。
如果将详细程度设置为 2，则 serverStatus 输出将包括默认 tcmalloc 指标和 tcmalloc.tcmalloc.cpuCache 部分。
如果将详细程度设置为 3，则 serverStatus 输出包括所有 tcmalloc 指标。

如果您指定的值大于 3，MongoDB 会将 verbosity 设置为3。

例如，要调用 serverStatus 并将 verbosity 设置为 2，请运行以下命令：

db.runCommand( { serverStatus: 1, tcmalloc: 2 } )

提示

另请参阅：

TCMalloc Stats

tcmalloc.usingPerCPUCaches

一个布尔值，表示 TCMalloc 是否正在使用 CPU 缓存运行。如果 tcmalloc.usingPerCPUCaches 为 false ，请确保：

您已禁用 glibc rseq。
您正在使用 Linux 内核版本 4.18 或更高版本。

8.0版本新增。

tcmalloc.maxPerCPUCacheSizeBytes: 每个 CPU 缓存的最大大小（以字节为单位）。
8.0版本新增。

tcmalloc.generic.peak_memory_usage: MongoDB 在任何时间点分配的最大内存量（以字节为单位）。
8.0版本新增。

tcmalloc.generic.current_allocated_bytes: 当前分配给内存并被 MongoDB 使用的总字节数。

tcmalloc.generic.heap_size: 从操作系统分配的内存量（以字节为单位）。此值包括当前正在使用的内存和已分配但未使用的内存。

tcmalloc.tcmalloc.central_cache_free: 中央空闲列表中保存的内存量（以字节为单位）。中央空闲列表是一种用来管理空闲内存，以便再次利用的结构。

tcmalloc.tcmalloc.cpu_free: 所有 CPU 缓存中可用的空闲内存量（以字节为单位）。
8.0版本新增。

tcmalloc.tcmalloc.total_bytes_held: 当前缓存中保存的内存量（以字节为单位）。
8.0版本新增。

tcmalloc.tcmalloc.release_rate: 将未使用内存释放给操作系统的速率（单位为字节/秒）。tcmallocReleaseRate 参数决定 tcmalloc.tcmalloc.release_rate 的值。

tcmalloc.tcmalloc.cpuCache

提供每个 CPU 缓存数据的文档。

cpuCache 在默认详细级别排除指标。要查看 cpuCache 指标，您必须将 tcmalloc详细程度设置为至少 2。

8.0版本新增。

tcmalloc.tcmalloc.cpuCache.N.overflows: CPU 缓存发生溢出的次数。当用户释放内存且缓存已满时，就会发生溢出。
8.0版本新增。

tcmalloc.tcmalloc.cpuCache.N.underflows: CPU 缓存遇到的下溢次数。当用户分配内存而缓存为空时，就会发生下溢。
8.0版本新增。

tcmalloc.tcmalloc_derived.total_free_bytes: tcmalloc 必须从操作系统请求更多内存之前剩余的内存量。
8.0版本新增。

事务

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

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

transactions

在mongod上运行时，包含有关可重试日志和事务的数据的文档。

在 mongos 上运行时，生成一个文档，其中包含有关在实例上运行的事务的数据。

transactions.retriedCommandsCount

仅在 mongod 上可用。

提交相应可重试写入命令后收到的重试总次数。也就是说，即使先前的写入已经成功，并在 config.transactions 集合中拥有事务和会话的关联记录，仍会尝试可重试写入，例如，对客户端的初始写入响应丢失时。

注意

MongoDB 不会重新执行已提交的写入。

总数是所有会话中的总和值。

总数不包括在数据段迁移过程中可能在内部发生的任何可重试写入。

transactions.retriedStatementsCount

仅在 mongod 上可用。

与 transactions.retriedCommandsCount 中的重试命令关联的写入语句总数。

注意

MongoDB 不会重新执行已提交的写入。

总数不包括在数据段迁移过程中可能在内部发生的任何可重试写入。

transactions.transactionsCollectionWriteCount

仅在 mongod 上可用。

在提交新的可重试写入语句时触发的写入 config.transactions 集合的总次数。

对于更新和删除命令，由于只能重试单个文档操作，因此每个语句都只有一次写入。

对于插入操作，每批插入的文档只有一次写入，除非失败导致单独插入每个文档。

该总数包括在迁移过程中写入服务器的 config.transactions 集合的次数。

transactions.currentActive

在 mongod 和 mongos 上均可用。

当前正在执行命令的未结事务总数。

transactions.currentInactive

在 mongod 和 mongos 上均可用。

当前未执行命令的活动事务总数。

transactions.currentOpen

在 mongod 和 mongos 上均可用。

未结事务的总数。当第一个命令作为事务的一部分运行时，事务就会打开，并保持打开状态，直到事务提交或中止。

transactions.totalAborted

对于 mongod，指的是自上次启动以来在该实例上中止的事务总数。

对于 mongos，指的是自上次启动以来通过该实例中止的事务总数。

transactions.totalCommitted

对于 mongod，指的是自上次启动以来在该实例上提交的事务总数。

对于mongos，指的是自上次启动以来通过该实例提交的事务总数。

transactions.totalStarted

对于 mongod，指的是自上次启动以来在该实例上启动的事务总数。

对于 mongos，指的是自上次启动以来在该实例上启动的事务总数。

transactions.abortCause

仅适用于 mongos。

按原因对 transactions.totalAborted 进行细分。如果客户端发出显式 abortTransaction，则原因列为 abort。

例如：

totalAborted : Long("5"),
abortCause : {
   abort : Long("1"),
   DuplicateKey : Long("1"),
   StaleConfig : Long("3"),
   SnapshotTooOld : Long("1")
},

transactions.totalContactedParticipants

仅适用于 mongos。

自上次启动以来，针对通过此 mongos 启动的所有事务接触的分片总数。

在事务处理期间联系的分片的数量可以包括提交中可能不包含的分片。

transactions.totalParticipantsAtCommit

仅适用于 mongos。

自上次启动以来，通过此 mongos 启动的所有事务的提交所涉及的分片总数。

transactions.totalRequestsTargeted

仅适用于 mongos。

mongos 作为其事务的一部分所针对的网络请求总数。

transactions.commitTypes

仅适用于 mongos。

按类型细分提交。例如：

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

提交类型为：

类型	说明
`noShards`	提交未接触任何分片的事务。
`singleShard`	提交影响单个分片的事务。
`singleWriteShard`	联系到多个分片，但其写入操作仅影响单个分片的事务提交。
`readOnly`	提交仅涉及读取操作的事务。
`twoPhaseCommit`	提交包含写入多个分片的事务。
`recoverWithToken`	提交从另一个实例或该实例重新启动后恢复事务结果。

对于每种提交类型，命令都会返回以下指标：

衡量标准	说明
`initiated`	启动此类型提交的总次数。
`successful`	此类提交成功的总次数。
`successfulDurationMicros`	成功提交此类型所花费的总时间（以微秒为单位）。

transactions.totalPrepared

仅在 mongod 上可用。

自 mongod 进程上次启动以来，此服务器上处于准备状态的事务总数。

transactions.totalPreparedThenCommitted

仅在 mongod 上可用。

自 mongod 进程上次启动以来，在此服务器上准备和提交的事务总数。

transactions.totalPreparedThenAborted

仅在 mongod 上可用。

自 mongod 进程上次启动以来，在此服务器上准备和中止的事务总数。

transactions.currentPrepared

仅在 mongod 上可用。

此服务器上当前处于准备状态的事务数量。

transactions.lastCommittedTransaction

仅在 mongod 上可用。

mongod 为主节点时提交的最后一个事务的详细信息。

通过从节点返回时，lastCommittedTransaction 返回该从节点作为主节点时提交的最后一个事务的详细信息。

lastCommittedTransaction : {
   operationCount : Long("1"),
   oplogOperationBytes : Long("211"),
   writeConcern : {
      w : "majority",
      wtimeout : 0
   }
}

衡量标准	说明
`operationCount`	事务中写入操作的数量。
`oplogOperationBytes`	事务对应的一个或多个 oplog 条目的大小。[2]
`writeConcern`	用于事务的写关注。

[2]	MongoDB 根据需要创建尽可能多的 oplog 条目，以封装事务中的所有写入操作。有关详细信息，请参阅 Oplog 大小限制。

transportSecurity

transportSecurity : {
   1.0 : Long("<num>"),
   1.1 : Long("<num>"),
   1.2 : Long("<num>"),
   1.3 : Long("<num>"),
   unknown : Long("<num>")
},

transportSecurity.<version>: 已与此 mongod 或 mongos 实例建立的 TLS <version> 连接的累计数量。该值在重新启动时重置。

watchdog

watchdog : {
   checkGeneration : Long("<num>"),
   monitorGeneration : Long("<num>"),
   monitorPeriod : <num>
}

注意

watchdog 部分仅在启用存储节点看门狗时出现。

watchdog: 一个文档，其中报告存储节点看门狗的状态。

watchdog.checkGeneration: 自启动以来检查目录的次数。每个 monitoringPeriod 都会多次检查目录。

watchdog.monitorGeneration: 检查 mongod 使用的所有文件系统的状态的次数。该值在每个 monitoringPeriod 中递增一次。

watchdog.monitorPeriod: 由 watchdogPeriodSeconds 设置的值。这是状态检查之间的时间段。

WiredTiger

wiredTiger 信息仅在使用 WiredTiger 存储引擎时才显示。服务器的一些统计数据会汇总。

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

注意

以下并非详尽列表。

wiredTiger.uri: 一个字符串，供 MongoDB 内部使用。

wiredTiger.async: 一份返回与异步操作 API 相关的统计数据的文档。MongoDB 未使用此功能。

wiredTiger.block-manager: 一个文档，用于返回区块管理器操作的统计信息。

wiredTiger.cache

返回有关缓存和从缓存中逐出页面的统计数据的文档。

下面介绍一些关键 wiredTiger.cache 统计数据：

wiredTiger.cache.maximum bytes configured: 最大缓存大小。

wiredTiger.cache.bytes currently in the cache: 当前缓存中数据的字节大小。此值不应大于 maximum bytes configured 值。

wiredTiger.cache.unmodified pages evicted: 页面驱逐的主要统计信息。

wiredTiger.cache.tracked dirty bytes in the cache: 缓存中脏数据的大小（字节）。该值应小于 bytes currently in the cache 值。

wiredTiger.cache.pages read into cache: 读入缓存的页数。wiredTiger.cache.pages read into cache 和 wiredTiger.cache.pages written from cache 可以概述 I/O 活动。

wiredTiger.cache.pages written from cache: 从缓存写入的页数。wiredTiger.cache.pages written from cache 和 wiredTiger.cache.pages read into cache 可以概述 I/O 活动。

如需调整 WiredTiger 内部缓存大小，请参阅 storage.wiredTiger.engineConfig.cacheSizeGB 和 --wiredTigerCacheSizeGB。避免将 WiredTiger 内部缓存大小增加到超过其默认值。

wiredTiger.connection: 一个文档，其中返回与 WiredTiger 连接相关的统计信息。

wiredTiger.cursor: 一个文档，其中返回 WiredTiger 游标的统计信息。

wiredTiger.data-handle: 一个文档，其中返回数据句柄和扫描的统计信息。

wiredTiger.log: 一份返回 WiredTiger 预写日志（即日志）统计数据的文档。
提示
另请参阅：
日志和 WiredTiger 存储引擎

wiredTiger.reconciliation: 一个文档，其中返回协调进程的统计信息。

wiredTiger.session: 返回会话的打开游标计数和打开会话计数的文档。

wiredTiger.thread-yield: 在页面获取期间返回让步统计信息的文档。

wiredTiger.transaction

返回有关事务检查点和操作的统计信息的文档。

wiredTiger.transaction.transaction checkpoint most recent time (msecs): 创建最新检查点的时间量（以毫秒为单位）。在稳定的写入负载下该值的增加可能表明 I/O 子系统已饱和。

后退

profile

来年

shardConnPoolStats

定义

兼容性

注意

语法

提示

另请参阅：

行为

初始化

包括 mirroredReads

输出

注意

断言

bucketCatalog

catalogStats

changeStreamPreImages

连接

注意

注意

defaultRWConcern

electionMetrics

提示

另请参阅：

提示

另请参阅：

extra_info

flowControl

globalLock

hedgingMetrics

重要

indexBuilds

IndexBulkBuilder

indexStats

实例信息

锁

logicalSessionRecordCache

提示

另请参阅：

提示

另请参阅：

mem

衡量标准

注意

提示

另请参阅：

注意

注意

镜像读 (Mirrored Reads)

提示

另请参阅：

提示

另请参阅：

提示

另请参阅：

网络

opLatencies

opWorkingTime

opReadConcernCounters

警告

已删除

opWriteConcernCounters

注意

注意

注意

注意

运算计数器

注意

opcountersRepl

oplogTruncation

planCache

queryStats

queryAnalyzers

队列

重要

队列信息

querySettings

readConcernCounters

readPreferenceCounters

repl

安全性

注意

包括 `mirroredReads`