serverStatus

在本页面

• Definition

• Behavior

• Output

Definition

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

db.runCommand( { serverStatus: 1 } )

该值(即上面的1)不会影响该命令的操作。 mongoShell 程序为命令提供db.serverStatus()包装器。

Behavior

默认情况下，serverStatus在其输出中排除repl文档中的某些内容。

要包括默认情况下不包括的字段，请指定顶级字段并将其在命令中设置为1。要排除默认包含的字段，请指定顶级字段并在命令中设置为0。

例如，以下操作禁止输出中的repl，metrics和locks信息。

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

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

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

Output

• 从 MongoDB 3.6.11 开始，serverStatus在其输出中包括：

• metrics.repl.apply.batchSize

  • opReadConcernCounters

  • opWriteConcernCounters(需要将reportOpWriteConcernCountersInServerStatus参数设置为true)。

• 从 MongoDB 3.6 开始，serverStatus不再输出rangeDeleter部分。

• 从 MongoDB 3.0 开始，serverStatus不再输出workingSet，indexCounters和recordStats部分。

Instance Information

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

• host

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

• advisoryHostFQDNs

  • 3.2 版中的新功能。

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

• version

  • 当前 MongoDB 进程的 MongoDB 版本。

• process

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

• pid

  • 进程 ID 号。

• uptime

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

• uptimeMillis

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

• uptimeEstimate

  • 正常运行时间(以秒为单位)是根据 MongoDB 内部类粒度计时系统计算得出的。

• localTime

  • 根据服务器，以 UTC 表示当前时间的 ISODate。

asserts

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

• asserts

  • 报告自 MongoDB 流程启动以来提出的 assert 数量的文档。尽管 assert 错误通常很少见，但是如果asserts的值不为零，则应检查日志文件以获取更多信息。在许多情况下，这些错误是微不足道的，但值得研究。

• asserts. regular

  • 自 MongoDB 流程开始以来提出的常规声明的数量。检查日志文件以获取有关这些消息的更多信息。

• asserts. warning

  • 自 MongoDB 进程启动以来发出的警告数。检查日志文件以获取有关这些警告的更多信息。

• asserts. msg

  • 自 MongoDB 进程启动以来引发的消息声明的数量。检查日志文件以获取有关这些消息的更多信息。

• asserts. user

  • 自上次 MongoDB 进程启动以来发生的“用户 assert”数量。这些是用户可能产生的错误，例如磁盘空间不足或重复密钥。您可以通过解决应用程序或部署中的问题来防止出现这些 assert。查看 MongoDB 日志以获取更多信息。

• asserts. rollovers

  • 自上次 MongoDB 进程启动以来，翻转计数器已翻转的次数。 230 个 assert 后，计数器将翻转为零。使用此值可为asserts数据结构中的其他值提供上下文。

backgroundFlushing

"backgroundFlushing" : {
   "flushes" : <num>,
   "total_ms" : <num>,
   "average_ms" : <num>,
   "last_ms" : <num>,
   "last_finished" : ISODate("...")
},

• backgroundFlushing

  • 报告mongod进程对磁盘的定期写入的文档。如果您担心写入性能和journaling，请考虑这些值。

• backgroundFlushing. flushes

  • 数据库已将所有写入刷新到磁盘的次数。随着数据库运行时间的延长，该值将增加。

• backgroundFlushing. total_ms

  • mongod进程将数据写入(即刷新)到磁盘所花费的总毫秒数。由于total_ms是绝对值，因此请考虑flushes和average_ms值以提供上下文。

• backgroundFlushing. average_ms

  • 每次刷新到磁盘的平均时间(以毫秒为单位)，方法是将total_ms除以flushes。

随着flushes的值增加，average_ms更有可能代表“正常”时间。但是，异常数据会使该值偏斜。使用backgroundFlushing.last_ms检查瞬时历史问题或随机写入分布是否不偏高平均值。

• backgroundFlushing. last_ms

  • 最后一次刷新操作完成的时间(以毫秒为单位)。使用此值来验证服务器的当前性能是否符合backgroundFlushing.average_ms和backgroundFlushing.total_ms提供的历史数据。

• backgroundFlushing. last_finished

  • 最后完成的刷新操作的时间戳，格式为ISODate。如果该值比服务器当前时间晚了几分钟，并且考虑了时区差异，那么重新启动数据库可能会导致某些数据丢失。

还要考虑正在进行的操作，这些操作可能会通过例行阻止写操作来歪曲此值。

connections

"connections" : {
   "current" : <num>,
   "available" : <num>,
   "totalCreated" : NumberLong(<num>)
},

• connections

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

• connections. current

  • 从 Client 端到数据库服务器的传入连接数。该数字包括当前的 Shell 会话。考虑connections.available的值可向此基准添加更多上下文。

该值将包括所有传入连接，包括任何 Shell 程序连接或来自其他服务器的连接，例如replica set成员或mongos实例。

• connections. available

  • 可用的未使用的传入连接数。将此值与connections.current的值结合使用以了解数据库上的连接负载，并在UNIX ulimit 设置文档中获取有关可用连接上的系统阈值的更多信息。

• connections. totalCreated

  • 创建到服务器的“所有**”传入连接的计数。此数字包括此后关闭的连接。

dur (Journaling)

"dur" : {
   "commits" : <num>,
   "journaledMB" : <num>,
   "writeToDataFilesMB" : <num>,
   "compression" : <num>,
   "commitsInWriteLock" : <num>,
   "earlyCommits" : <num>,
   "timeMs" : {
      "dt" : <num>,
      "prepLogBuffer" : <num>,
      "writeToJournal" : <num>,
      "writeToDataFiles" : <num>,
      "remapPrivateView" : <num>,
      "commits" : <num>,
      "commitsInWriteLock" : <num>
   }
},

• dur

  • 报告mongod实例的journaling-related operations和性能的文档。 MongoDB 根据过去 3 到 6 秒之间收集的 3 秒间隔报告此数据。

• dur. commits

  • 在最后日记帐组提交间隔期间写入journal的事务数。

• dur. journaledMB

  • 在最后日记帐组提交间隔期间写入journal的数据量(以兆字节(MB)为单位)。

• dur. writeToDataFilesMB

  • 在最后日记帐组提交间隔期间从journal写入数据文件的数据量(兆字节)。

• dur. compression

  • 写入journal的数据的压缩率：

( journaled_size_of_data / uncompressed_size_of_data )

• dur. commitsInWriteLock

  • 持有写锁定时发生的提交计数。写入锁定中的提交表示正在承受沉重的写入负载的 MongoDB 节点，并要求进一步诊断。

• dur. earlyCommits

  • MongoDB 在 sched 的日记帐组提交间隔之前请求提交的次数。使用此值可确保日记帐组提交间隔的部署时间不会太长。

• dur. timeMS

  • 报告最后日记帐组提交间隔中日记的各个阶段中mongod实例的性能的文档。

• dur.timeMS. dt

  • MongoDB 收集dur.timeMS数据的时间(以毫秒为单位)。使用此字段可为其他dur.timeMS字段值提供上下文。

• dur.timeMS. prepLogBuffer

  • 准备写日记所花费的时间(以毫秒为单位)。较小的值表示较好的日记帐性能。

• dur.timeMS. writeToJournal

  • 实际写入日记所花费的时间(以毫秒为单位)。文件系统的速度和设备接口可能会影响性能。

• dur.timeMS. writeToDataFiles

  • 日志记录后花费在写入数据文件上的时间(以毫秒为单位)。文件系统的速度和设备接口可能会影响性能。

• dur.timeMS. remapPrivateView

  • 重新 Map 写时复制内存 Map 视图所花费的时间(以毫秒为单位)。较小的值表示较好的日记帐性能。

• dur.timeMS. commits

  • 提交花费的时间(以毫秒为单位)。

• dur.timeMS. commitsInWriteLock

  • 持有写锁定时发生的提交所花费的时间(以毫秒为单位)。

extra_info

"extra_info" : {
   "note" : "fields vary by platform.",
   "heap_usage_bytes" : <num>,
   "page_faults" : <num>
},

• extra_info

  • 提供有关基础系统的其他信息的文档。

• extra_info. note

  • Literals 为"fields vary by platform."的字符串

• extra_info. heap_usage_bytes

  • 数据库进程使用的堆空间的总大小(以字节为单位)。仅在 Unix/Linux 系统上可用。

• extra_info. page_faults

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

Windows 在涉及磁盘 I/O 的“硬”页面错误和仅需要在内存中移动页面的“软”页面错误之间进行区分。 MongoDB 在此统计信息中同时统计硬页面错误和软页面错误。

globalLock

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

• globalLock
  • 报告数据库锁定状态的文档。

通常，locks文档提供了有关锁用途的更多详细数据。

• globalLock. totalTime

  • 自数据库上次启动并创建globalLock以来的时间(以微秒为单位)。这大致相当于服务器的总正常运行时间。

• globalLock. currentQueue

  • 提供有关由于锁定而排队的操作数的信息的文档。

• globalLock.currentQueue. total

  • 排队 await 锁定的操作总数(即globalLock.currentQueue.readers和globalLock.currentQueue.writers的总和)。

始终保持较小的队列，尤其是较短的操作队列，应该引起关注。 globalLock.activeClientsReader 和 Writer 信息提供了此数据的上下文。

• globalLock.currentQueue. readers

  • 当前排队并 await 读锁定的操作数。始终较小的读取队列，尤其是较短的操作，不会引起任何问题。

• globalLock.currentQueue. writers

  • 当前排队并 await 写锁定的操作数。始终较小的写队列，尤其是较短操作的写队列，无需担心。

• globalLock. activeClients

  • 提供有关已连接 Client 端数量以及这些 Client 端执行的读取和写入操作的信息的文档。

使用此数据为globalLock.currentQueue数据提供上下文。

• globalLock.activeClients. total

  • 与数据库的内部 Client 端连接总数，包括系统线程以及排队的读取器和写入器。由于包含系统线程，因此该 Metrics 将高于activeClients.readers和activeClients.writers的总数。

• globalLock.activeClients. readers

  • 执行读取操作的活动 Client 端连接数。

• globalLock.activeClients. writers

  • 执行写操作的活动 Client 端连接数。

logicalSessionRecordCache

3.6 版的新功能。

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

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

• logicalSessionRecordCache. sessionsCollectionJobCount
  • 跟踪刷新过程在config.system.sessions集合上运行的次数的数字。

• logicalSessionRecordCache. lastSessionsCollectionJobDurationMillis

  • 上次刷新的时间(以毫秒为单位)。

• logicalSessionRecordCache. lastSessionsCollectionJobTimestamp

  • 上次刷新发生的时间。

• logicalSessionRecordCache. lastSessionsCollectionJobEntriesRefreshed

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

• logicalSessionRecordCache. lastSessionsCollectionJobEntriesEnded"

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

• logicalSessionRecordCache. lastSessionsCollectionJobCursorsClosed"

  • 在上一次config.system.sessions集合刷新期间关闭的游标数。

• logicalSessionRecordCache. transactionReaperJobCount"

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

• logicalSessionRecordCache. lastTransactionReaperJobDurationMillis"

  • 上次事务记录清除的长度(以毫秒为单位)。

• logicalSessionRecordCache. lastTransactionReaperJobTimestamp"

  • 上次 Transaction 记录清除的时间。

• logicalSessionRecordCache. lastTransactionReaperJobEntriesCleanedUp"

  • 上一次 Transaction 记录清除期间删除的config.transactions集合中的条目数。

locks

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

• locks
  • 在版本 3.0 中更改。

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

可能的锁<types>为：

可能的<modes>是：

所有值均为NumberLong()类型。

• locks.<type>. acquireCount
  {#serverstatus.locks.<type>.acquireCount}

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

• locks.<type>. acquireWaitCount
  {#serverstatus.locks.<type>.acquireWaitCount}

  • 由于锁处于冲突模式而发生的locks.acquireCount个锁获取 await 的次数。

• locks.<type>. timeAcquiringMicros
  {#serverstatus.locks.<type>.timeAcquiringMicros}

  • 锁定获取的累积 await 时间(以微秒为单位)。

locks.timeAcquiringMicros除以locks.acquireWaitCount得出特定锁定模式的平均 await 时间。

• locks.<type>. deadlockCount
  {#serverstatus.locks.<type>.deadlockCount}
  • 锁获取遇到死锁的次数。

network

"network" : {
   "bytesIn" : <num>,
   "bytesOut" : <num>,
   "numRequests" : <num>
},

• network

  • 报告有关 MongoDB 网络使用情况数据的文档。

• network. bytesIn

  • 反映此数据库*接收到的网络通信量的字节数。使用此值可确保发送到mongod进程的网络流量与期望值和整个应用程序间流量一致。

• network. bytesOut

  • 反映从此数据库发送*的网络流量的字节数。使用此值可确保mongod进程发送的网络流量与期望值和整个应用程序间流量一致。

• network. numRequests

  • 服务器已收到的不同请求的总数。使用此值可提供network.bytesIn和network.bytesOut值的上下文，以确保 MongoDB 的网络利用率与期望和应用程序使用一致。

opLatencies

仅适用于``mongod''实例

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

• opLatencies
  • 包含整个数据库操作延迟的文档。有关此文档的说明，请参见latencyStats Document。

只有mongod个实例报告opLatencies。

• opLatencies. reads

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

• opLatencies. writes

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

• opLatencies. commands

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

opReadConcernCounters

版本 3.6.11 中的新功能。

仅适用于 mongod 实例

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

• opReadConcernCounters
  • 版本 3.6.11 中的新功能。

自上次启动以来，向mongod实例报告由查询操作指定的阅读关注度的文档。

opReadConcernCounters的总和等于opcounters.query。

opWriteConcernCounters

版本 3.6.11 中的新功能。

仅适用于 mongod 实例

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

• opWriteConcernCounters
  • 版本 3.6.11 中的新功能。

自上次启动以来，报告对mongod实例执行写操作所指定的write concerns的文档。

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

• opWriteConcernCounters. insert
  • 版本 3.6.11 中的新功能。

自上次启动以来，报告对mongod实例执行插入操作所指定的w: <value>的文档：

"insert" : {
   "wmajority" : NumberLong(<num>),
   "wnum" : {
      "<num>" :  NumberLong(<num>),
      ...
   },
   "wtag" : {
      "<tag1>" :  NumberLong(<num>),
      ...
   },
   "none" : NumberLong(<num>)
},

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

• opWriteConcernCounters. update
  • 版本 3.6.11 中的新功能。

自上次启动以来，针对由mongod实例的更新操作指定的w: <value>报告的文档：

"update" : {
   "wmajority" : NumberLong(<num>),
   "wnum" : {
      "<num>" :  NumberLong(<num>),
   },
   "wtag" : {
      "<tag1>" :  NumberLong(<num>),
      ...
   },
   "none" : NumberLong(<num>)
},

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

• opWriteConcernCounters. delete
  • 版本 3.6.11 中的新功能。

自上次启动以来，针对mongod实例报告由删除操作指定的w: <value>的文档：

"delete" : {
   "wmajority" :  NumberLong(<num>)
   "wnum" : {
      "<num>" :  NumberLong(<num>),
      ...
   },
   "wtag" : {
      "<tag1>" :  NumberLong(<num>),
      ...
   },
   "none" : NumberLong(<num>)
}

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

opcounters

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

• opcounters
  • 自mongod实例上次启动以来按类型报告数据库操作的文档。

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

• opcounters. insert

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

• opcounters. query

  • 自mongod实例上次启动以来收到的查询总数。

• opcounters. update

  • 自上一次启动mongod实例以来收到的更新操作总数。

• opcounters. delete

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

• opcounters. getmore

  • 自上一次启动mongod实例以来的“ getmore”操作总数。即使查询计数很低，此计数器也可能很高。辅助节点在复制过程中发送getMore个操作。

• opcounters. command

  • 自上一次启动mongod实例以来，发布到数据库的命令总数。

opcounters.command计算所有commands **** **的写入命令：insert，update和delete。

opcountersRepl

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

• opcountersRepl
  • 自mongod实例上次启动以来按类型报告数据库复制操作的文档。

仅当当前主机是副本集的成员时，才会显示这些值。

由于 MongoDB 在复制过程中如何序列化操作，因此这些值与opcounters值不同。有关复制的更多信息，请参见Replication。

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

• opcountersRepl. insert

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

• opcountersRepl. query

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

• opcountersRepl. update

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

• opcountersRepl. delete

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

• opcountersRepl. getmore

  • 自上一次启动mongod实例以来的“ getmore”操作总数。即使查询计数很低，此计数器也可能很高。辅助节点在复制过程中发送getMore个操作。

• opcountersRepl. command

  • 自mongod实例上次启动以来，已发布到数据库的复制命令总数。

oplogTruncation

"oplogTruncation" : {
   "totalTimeProcessingMicros" : <NumberLong>,
   "processingMethod" : <string>,
   "totalTimeTruncatingMicros" : <NumberLong>,
   "truncateCount" : <NumberLong>
},

• oplogTruncation
  • 3.6.16 版中的新功能：适用于 WiredTiger 存储引擎

报告oplog个截断的文档。

仅当当前实例是副本集的成员并使用WiredTiger 存储引擎时，才显示该字段。

• oplogTruncation. totalTimeProcessingMicros
  • 3.6.16 版中的新功能。

扫描或采样操作日志以确定操作日志截断点所花费的总时间(以微秒为单位)。

See oplogTruncation.processingMethod

• oplogTruncation. processingMethod
  • 3.6.16 版中的新功能。

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

• oplogTruncation. totalTimeTruncatingMicros
  • 3.6.16 版中的新功能。

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

• oplogTruncation. truncateCount
  • 3.6.16 版中的新功能。

oplog 截断的累积数量。

repl

"repl" : {
   "hosts" : [
         <string>,
         <string>,
         <string>
   ],
   "setName" : <string>,
   "setVersion" : <num>,
   "ismaster" : <boolean>,
   "secondary" : <boolean>,
   "primary" : <hostname>,
   "me" : <hostname>,
   "electionId" : ObjectId(""),
   "rbid" : <num>,
   "replicationProgress" : [
         {
            "rid" : <ObjectId>,
            "optime" : { ts: <timestamp>, term: <num> },
            "host" : <hostname>,
            "memberId" : <num>
         },
        ...
   ]
}

• repl

  • 报告副本集配置的文档。 repl仅在当前主机是副本集时出现。有关复制的更多信息，请参见Replication。

• repl. hosts

  • 当前副本集成员的主机名和端口信息("host:port")的数组。

• repl. setName

  • 具有当前副本集名称的字符串。此值反映配置文件中的--replSet命令行参数或replSetName值。

• repl. ismaster

  • 指示当前节点是否为副本集的primary的布尔值。

• repl. secondary

  • 指示当前节点是否为副本集的secondary成员的布尔值。

• repl. primary

  • 3.0 版中的新功能。

副本集的当前primary成员的主机名和端口信息("host:port")。

• repl. me

  • 3.0 版中的新增功能：副本集当前成员的主机名和端口信息("host:port")。

• repl. rbid

  • 3.0 版中的新功能。

Rollback标识符。用于确定此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

"security" : {
   "SSLServerSubjectName": <string>,
   "SSLServerHasCertificateAuthority": <boolean>,
   "SSLServerCertificateExpirationDate": <date>
},

• security
  • 3.0 版中的新功能。

报告安全配置和详细信息的文档。仅针对支持 TLS/SSL 编译的mongod个实例显示。

• security. SSLServerSubjectName

  • 与net.ssl.PEMKeyFile指定的 TLS/SSL 证书关联的使用者名称。

• security. SSLServerHasCertificateAuthority

  • 当net.ssl.PEMKeyFile指定的 TLS/SSL 证书与证书颁发机构关联时，为true的布尔值。 false(当 TLS/SSL 证书是自签名的)。

• security. SSLServerCertificateExpirationDate

  • date object代表net.ssl.PEMKeyFile指定的 TLS/SSL 证书到期的日期。

sharding

3.2 版中的新增功能：在mongos上运行时，该命令返回分片信息。

在 3.6 版中进行了更改：从 MongoDB 3.6 开始，分片成员返回分片信息。

{
   "configsvrConnectionString" : "csRS/cfg1.example.net:27019,cfg2.example.net:27019,cfg2.example.net:27019",
   "lastSeenConfigServerOpTime" : {
      "ts" : Timestamp(1517462189, 1),
      "t" : NumberLong(1)
   },
   "maxChunkSizeInBytes" : NumberLong(67108864)
}

• sharding

  • 包含有关分片群集数据的文档。 lastSeenConfigServerOpTime仅用于mongos或分片成员，而不用于配置服务器。

• sharding. configsvrConnectionString

  • 配置服务器的连接字符串。

• sharding. lastSeenConfigServerOpTime

  • mongos 或分片成员已经看到的 CSRS 主数据库的最新运行时间。 optime 文档包括：

• ts，即操作的时间戳记。

• t，即最初在 CSRS 主数据库上生成操作的术语。

仅当分片群集使用 CSRS 时，lastSeenConfigServerOpTime才存在。

• sharding. maxChunkSizeInBytes
  • 3.6 版的新功能。

一块的最大size limit。如果块大小最近已在配置服务器上更新，则maxChunkSizeInBytes可能不反映最新值。

shardingStatistics

3.6.4 版中的新功能。

"shardingStatistics" : {
   "countStaleConfigErrors" : NumberLong(<num>),
   "countDonorMoveChunkStarted" : NumberLong(<num>),
   "totalDonorChunkCloneTimeMillis" : NumberLong(<num>),
   "totalCriticalSectionCommitTimeMillis" : NumberLong(<num>),
   "totalCriticalSectionTimeMillis" : NumberLong(<num>),
   "catalogCache" : {
      "numDatabaseEntries" : NumberLong(<num>),
      "numCollectionEntries" : NumberLong(<num>),
      "countStaleConfigErrors" : NumberLong(<num>),
      "totalRefreshWaitTimeMicros" : NumberLong(<num>),
      "numActiveIncrementalRefreshes" : NumberLong(<num>),
      "countIncrementalRefreshesStarted" : NumberLong(<num>),
      "numActiveFullRefreshes" : NumberLong(<num>),
      "countFullRefreshesStarted" : NumberLong(<num>),
      "countFailedRefreshes" : NumberLong(<num>)
   }
},

• shardingStatistics

  • 包含有关分片群集上元数据刷新的 Metrics 的文档。

• shardingStatistics. countStaleConfigErrors

  • 线程遇到过时的配置异常的总次数。由于陈旧的配置异常触发了元数据的刷新，因此该数目与元数据的刷新次数大致成比例。

*仅在分片上运行时存在。

• shardingStatistics. countDonorMoveChunkStarted
  • moveChunk命令在分片上作为该块迁移过程的一部分在该分片上启动的总数。这个数量的增加并未考虑块迁移是否成功。

*仅在分片上运行时存在。

• shardingStatistics. totalDonorChunkCloneTimeMillis
  • 块迁移的克隆阶段从此分片(此节点是该分片的成员)所花费的累积时间(以毫秒为单位)。具体来说，对于从此分片进行的每次迁移，跟踪时间均以moveChunk命令开始，并在目标分片进入追赶阶段以应用chunk migrations期间发生的更改之前结束。

*仅在分片上运行时存在。

• shardingStatistics. totalCriticalSectionCommitTimeMillis
  • 更新块迁移的元数据阶段从此分片(此节点是该分片的成员)所花费的累积时间(以毫秒为单位)。在更新元数据阶段，将阻止对集合的所有操作。

*仅在分片上运行时存在。

• shardingStatistics. totalCriticalSectionTimeMillis
  • 块迁移的追赶阶段和更新元数据阶段从此分片(此节点是该分片的成员)所花费的累积时间(以毫秒为单位)。

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

totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis

仅在分片上运行时存在。

• shardingStatistics. catalogCache

  • 包含有关集群路由信息缓存的统计信息的文档。

• shardingStatistics.catalogCache. numDatabaseEntries

  • 目录高速缓存中当前存在的数据库条目总数。

• shardingStatistics.catalogCache. numCollectionEntries

  • 目录高速缓存中当前的收集条目总数(跨所有数据库)。

• shardingStatistics.catalogCache. countStaleConfigErrors

  • 线程遇到过时的配置异常的总次数。陈旧的配置异常会触发元数据的刷新。

• shardingStatistics.catalogCache. totalRefreshWaitTimeMicros

  • 线程必须 await 元数据刷新的累积时间(以微秒为单位)。

• shardingStatistics.catalogCache. numActiveIncrementalRefreshes

  • 当前 await 完成的增量编录高速缓存刷新数。

• shardingStatistics. countIncrementalRefreshesStarted

  • 已开始的增量刷新的累积数量。

• shardingStatistics.catalogCache. numActiveFullRefreshes

  • 当前 await 完成的完整目录高速缓存刷新数。

• shardingStatistics.catalogCache. countFullRefreshesStarted

  • 已开始的完整刷新的累积数量。

• shardingStatistics.catalogCache. countFailedRefreshes

  • 失败的完整或增量刷新的累积数量。

storageEngine

3.0 版中的新功能。

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

• storageEngine

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

• storageEngine. name

  • 当前存储引擎的名称。

• storageEngine. supportsCommittedReads

  • 3.2 版中的新功能。

指示存储引擎是否支持"majority" read concern的布尔值。

• storageEngine. persistent
  • 3.2.6 版中的新功能。

指示storage engine是否将数据持久保存到磁盘的布尔值。

transactions

版本 3.6.3 中的新功能。

"transactions" : {
   "retriedCommandsCount" : <NumberLong>,
   "retriedStatementsCount" : <NumberLong>,
   "transactionsCollectionWriteCount" : <NumberLong>
},

• transactions

  • 包含有关retryable writes数据的文档。

• transactions. retriedCommandsCount

  • 在已经提交了相应的可重试写入命令之后，已接收到的重试尝试总数。也就是说，即使先前已成功写入并且在config.transactions集合中具有与事务和会话相关的记录，例如在丢失对 Client 端的初始写入响应时，也尝试进行可重试的写入。

总计涵盖所有会话。

总数不包括作为块迁移的一部分可能在内部发生的任何可重试写入。

版本 3.6.3 中的新功能。

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

总数不包括作为块迁移的一部分可能在内部发生的任何可重试写入。

版本 3.6.3 中的新功能。

• transactions. transactionsCollectionWriteCount
  • 提交新的可重试的写语句时触发对config.transactions集合的写总数。

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

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

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

版本 3.6.3 中的新功能。

transportSecurity

版本 3.6.7 中的新功能：(* 在 3.4.17 中也可用)

"transportSecurity" : {
   "1.0" : <NumberLong>,
   "1.1" : <NumberLong>,
   "1.2" : <NumberLong>,
   "1.3" : <NumberLong>,
   "unknown" :<NumberLong>
},

• transportSecurity. <version>
  {#serverstatus.transportSecurity.<version>}
  • 版本 3.6.7 中的新功能：(* 在 3.4.17 中也可用)

与此mongod或mongos实例构建的 TLS<version>连接的累积数量。重新启动后将重置该值。

wiredTiger

wiredTiger信息仅在使用WiredTiger存储引擎时出现。一些统计信息，例如wiredTiger.LSM，会为服务器汇总。

"wiredTiger" : {
   "uri" : "statistics:",
   "LSM" : {
         "sleep for LSM checkpoint throttle" : <num>,
         "sleep for LSM merge throttle" : <num>,
         "rows merged in an LSM tree" : <num>,
         "application work units currently queued" : <num>,
         "merge work units currently queued" : <num>,
         "tree queue hit maximum" : <num>,
         "switch work units currently queued" : <num>,
         "tree maintenance operations scheduled" : <num>,
         "tree maintenance operations discarded" : <num>,
         "tree maintenance operations executed" : <num>
   },
   "async" : {
         "number of allocation state races" : <num>,
         "number of operation slots viewed for allocation" : <num>,
         "current work queue length" : <num>,
         "number of flush calls" : <num>,
         "number of times operation allocation failed" : <num>,
         "maximum work queue length" : <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" : {
         "mapped bytes read" : <num>,
         "bytes read" : <num>,
         "bytes written" : <num>,
         "mapped blocks read" : <num>,
         "blocks pre-loaded" : <num>,
         "blocks read" : <num>,
         "blocks written" : <num>
   },
   "cache" : {
         "tracked dirty bytes in the cache" : <num>,
         "tracked bytes belonging to internal pages in the cache" : <num>,
         "bytes currently in the cache" : <num>,
         "tracked bytes belonging to leaf pages in the cache" : <num>,
         "maximum bytes configured" : <num>,
         "tracked bytes belonging to overflow pages in the cache" : <num>,
         "bytes read into cache" : <num>,
         "bytes written from cache" : <num>,
         "pages evicted by application threads" : <num>,
         "checkpoint blocked page eviction" : <num>,
         "unmodified pages evicted" : <num>,
         "page split during eviction deepened the tree" : <num>,
         "modified pages evicted" : <num>,
         "pages selected for eviction unable to be evicted" : <num>,
         "pages evicted because they exceeded the in-memory maximum" : <num>,
         "pages evicted because they had chains of deleted items" : <num>,
         "failed eviction of pages that exceeded the in-memory maximum" : <num>,
         "hazard pointer blocked page eviction" : <num>,
         "internal pages evicted" : <num>,
         "maximum page size at eviction" : <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 populating queue, but not evicting pages" : <num>,
         "eviction server unable to reach eviction goal" : <num>,
         "internal pages split during eviction" : <num>,
         "leaf pages split during eviction" : <num>,
         "pages walked for eviction" : <num>,
         "eviction worker thread evicting pages" : <num>,
         "in-memory page splits" : <num>,
         "in-memory page passed criteria to be split" : <num>,
         "lookaside table insert calls" : <num>,
         "lookaside table remove calls" : <num>,
         "percentage overhead" : <num>,
         "tracked dirty pages in the cache" : <num>,
         "pages currently held in the cache" : <num>,
         "pages read into cache" : <num>,
         "pages read into cache requiring lookaside entries" : <num>,
         "pages written from cache" : <num>,
         "page written requiring lookaside records" : <num>,
         "pages written requiring in-memory restoration" : <num>
   },
   "connection" : {
         "pthread mutex condition wait calls" : <num>,
         "files currently open" : <num>,
         "memory allocations" : <num>,
         "memory frees" : <num>,
         "memory re-allocations" : <num>,
         "total read I/Os" : <num>,
         "pthread mutex shared lock read-lock calls" : <num>,
         "pthread mutex shared lock write-lock calls" : <num>,
         "total write I/Os" : <num>
   },
   "cursor" : {
         "cursor create calls" : <num>,
         "cursor insert calls" : <num>,
         "cursor next calls" : <num>,
         "cursor prev calls" : <num>,
         "cursor remove calls" : <num>,
         "cursor reset calls" : <num>,
         "cursor restarted searches" : <num>,
         "cursor search calls" : <num>,
         "cursor search near calls" : <num>,
         "truncate calls" : <num>,
         "cursor update calls" : <num>
   },
   "data-handle" : {
         "connection data handles currently active" : <num>,
         "session dhandles swept" : <num>,
         "session sweep attempts" : <num>,
         "connection sweep dhandles closed" : <num>,
         "connection sweep candidate became referenced" : <num>,
         "connection sweep dhandles removed from hash list" : <num>,
         "connection sweep time-of-death sets" : <num>,
         "connection sweeps" : <num>
   },
   "log" : {
         "total log buffer size" : <num>,
         "log bytes of payload data" : <num>,
         "log bytes written" : <num>,
         "yields waiting for previous log file close" : <num>,
         "total size of compressed records" : <num>,
         "total in-memory size of compressed records" : <num>,
         "log records too small to compress" : <num>,
         "log records not compressed" : <num>,
         "log records compressed" : <num>,
         "log flush operations" : <num>,
         "maximum log file size" : <num>,
         "pre-allocated log files prepared" : <num>,
         "number of pre-allocated log files to create" : <num>,
         "pre-allocated log files not ready and missed" : <num>,
         "pre-allocated log files used" : <num>,
         "log release advances write LSN" : <num>,
         "records processed by log scan" : <num>,
         "log scan records requiring two reads" : <num>,
         "log scan operations" : <num>,
         "consolidated slot closures" : <num>,
         "written slots coalesced" : <num>,
         "logging bytes consolidated" : <num>,
         "consolidated slot joins" : <num>,
         "consolidated slot join races" : <num>,
         "busy returns attempting to switch slots" : <num>,
         "consolidated slot join transitions" : <num>,
         "consolidated slot unbuffered writes" : <num>,
         "log sync operations" : <num>,
         "log sync_dir operations" : <num>,
         "log server thread advances write LSN" : <num>,
         "log write operations" : <num>,
         "log files manually zero-filled" : <num>
   },
   "reconciliation" : {
         "pages deleted" : <num>,
         "fast-path pages deleted" : <num>,
         "page reconciliation calls" : <num>,
         "page reconciliation calls for eviction" : <num>,
         "split bytes currently awaiting free" : <num>,
         "split objects currently awaiting free" : <num>
   },
   "session" : {
         "open cursor count" : <num>,
         "open session count" : <num>
   },
   "thread-yield" : {
         "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>
   },
   "transaction" : {
         "transaction begins" : <num>,
         "transaction checkpoints" : <num>,
         "transaction checkpoint generation" : <num>,
         "transaction checkpoint currently running" : <num>,
         "transaction checkpoint max time (msecs)" : <num>,
         "transaction checkpoint min time (msecs)" : <num>,
         "transaction checkpoint most recent time (msecs)" : <num>,
         "transaction checkpoint total time (msecs)" : <num>,
         "transactions committed" : <num>,
         "transaction failures due to cache overflow" : <num>,
         "transaction range of IDs currently pinned by a checkpoint" : <num>,
         "transaction range of IDs currently pinned" : <num>,
         "transaction range of IDs currently pinned by named snapshots" : <num>,
         "transactions rolled back" : <num>,
         "number of named snapshots created" : <num>,
         "number of named snapshots dropped" : <num>,
         "transaction sync calls" : <num>
   },
   "concurrentTransactions" : {
         "write" : {
            "out" : <num>,
            "available" : <num>,
            "totalTickets" : <num>
         },
         "read" : {
            "out" : <num>,
            "available" : <num>,
            "totalTickets" : <num>
         }
   }
},

• wiredTiger. uri
  • 3.0 版中的新功能。

一个字符串。供 MongoDB 内部使用。

• wiredTiger. LSM
  • 3.0 版中的新功能。

在 LSM(日志结构合并)树上返回统计信息的文档。该值反映了此服务器中使用的所有 LSM 树的统计信息。

• wiredTiger. async
  • 3.0 版中的新功能。

返回与异步操作 API 相关的统计信息的文档。 MongoDB 未使用它。

• wiredTiger. block-manager
  • 3.0 版中的新功能。

返回有关块 Management 器操作的统计信息的文档。

• wiredTiger. cache
  • 版本 3.0 中的新增功能：一种文档，该文档返回有关缓存的统计信息和来自缓存的页面驱逐。

下面介绍一些关键的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 读入缓存和wiredTiger.cache.pages written from cache可以概述 I/O 活动。

• wiredTiger.cache. pages written from cache

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

要调整 WiredTiger 内部缓存的大小，请参见storage.wiredTiger.engineConfig.cacheSizeGB和--wiredTigerCacheSizeGB。避免将 WiredTiger 内部缓存的大小增加到其默认值以上。

• wiredTiger. connection
  • 3.0 版中的新功能。

返回与 WiredTiger 连接有关的统计信息的文档。

• wiredTiger. cursor
  • 3.0 版中的新功能。

在 WiredTiger 游标上返回统计信息的文档。

• wiredTiger. data-handle
  • 3.0 版中的新功能。

返回有关数据句柄和扫描的统计信息的文档。

• wiredTiger. log
  • 3.0 版中的新功能。

返回有关 WiredTiger 的预写日志(即日志)的统计信息的文档。

• wiredTiger. reconciliation
  • 3.0 版中的新功能。

返回对帐过程统计信息的文档。

• wiredTiger. session
  • 3.0 版中的新功能。

返回会话的打开游标计数和打开会话数的文档。

• wiredTiger. thread-yield
  • 3.0 版中的新功能。

在页面获取过程中返回 Yield 统计信息的文档。

• wiredTiger. transaction
  • 3.0 版中的新功能。

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

• wiredTiger.transaction. transaction checkpoint most recent time

  • 创建最新检查点的时间(以毫秒为单位)。在稳定的写负载下，该值的增加可能表示 I/O 子系统已饱和。

• wiredTiger. concurrentTransactions

  • 3.0 版中的新功能。

返回有关 WiredTiger 存储引擎中允许的读写事务并发数量的信息的文档。这些设置是 MongoDB 特定的。

要更改并发读写事务的设置，请参阅wiredTigerConcurrentReadTransactions和wiredTigerConcurrentWriteTransactions。

writeBacksQueued

"writeBacksQueued" : <boolean>,

• writeBacksQueued
  • 一个布尔值，指示是否有来自mongos实例的操作排队 await 重试。通常，此值为 false。另请参见writeBacks。

mem

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

• mem

  • 一份报告mongod的系统体系结构和当前内存使用情况的文档。

• mem. bits

  • 一个数字64或32，指示 MongoDB 实例是针对 64 位还是 32 位体系结构编译的。

• mem. resident

  • mem.resident的值大致等于数据库进程当前使用的 RAM 量(以兆字节(MiB)为单位)。在正常使用期间，该值趋于增加。在专用数据库服务器中，此数字趋向于接近系统内存总量。

• mem. virtual

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

启用journaling并使用 MMAPv1 存储引擎时，mem.virtual的值至少是mem.mapped的两倍。如果mem.virtual的值明显大于mem.mapped(例如 3 次或更多)，则可能表示内存泄漏。

• mem. supported

  • 一个布尔值，指示基础系统是否支持扩展的内存信息。如果该值为 false，并且系统不支持扩展的内存信息，则数据库服务器可能无法访问其他mem值。

• mem. mapped

  • *仅适用于 MMAPv1 存储引擎。

数据库 Map 的内存量(以兆字节(MB)为单位)。由于 MongoDB 使用内存 Map 文件，因此该值可能大致等于一个或多个数据库的总大小。

• mem. mappedWithJournal
  • *仅适用于 MMAPv1 存储引擎。

Map 的内存量(以兆字节(MB)为单位)，包括用于日记的内存。该值将始终是mem.mapped的两倍。仅当启用日记功能时才包括此字段。

• mem. note
  • 如果mem.supported为假，则出现字段mem.note。

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

metrics

"metrics" : {
   "commands": {
         "<command>": {
            "failed": <num>,
            "total": <num>
         }
   },
   "cursor" : {
         "timedOut" : NumberLong(<num>),
         "open" : {
            "noTimeout" : NumberLong(<num>),
            "pinned" : NumberLong(<num>),
            "multiTarget" : NumberLong(<num>),
            "singleTarget" : NumberLong(<num>),
            "total" : NumberLong(<num>),
         }
   },
   "document" : {
         "deleted" : NumberLong(<num>),
         "inserted" : NumberLong(<num>),
         "returned" : NumberLong(<num>),
         "updated" : NumberLong(<num>)
   },
   "getLastError" : {
         "wtime" : {
            "num" : <num>,
            "totalMillis" : <num>
         },
         "wtimeouts" : NumberLong(<num>)
   },
   "operation" : {
         "scanAndOrder" : NumberLong(<num>),
         "writeConflicts" : NumberLong(<num>)
   },
   "queryExecutor": {
         "scanned" : NumberLong(<num>),
         "scannedObjects" : NumberLong(<num>)
   },
   "record" : {
         "moves" : NumberLong(<num>)
   },
   "repl" : {
      "executor" : {
         "pool" : {
            "inProgressCount" : <num>
         },
         "queues" : {
            "networkInProgress" : <num>,
            "sleepers" : <num>
         },
         "unsignaledEvents" : <num>,
         "shuttingDown" : <boolean>,
         "networkInterface" : <string>
      },
      "apply" : {
         "attemptsToBecomeSecondary" : NumberLong(<num>),
         "batchSize" : NumberLong(<num>),
         "batches" : {
            "num" : <num>,
            "totalMillis" : <num>
         },
         "ops" : NumberLong(<num>)
      },
      "buffer" : {
         "count" : <NumberLong>,
         "maxSizeBytes" : <NumberLong>,
         "sizeBytes" : <NumberLong>
      },
      "initialSync" : {
         "completed" : <NumberLong>,
         "failedAttempts" : <NumberLong>,
         "failures" : <NumberLong>,
      },
      "network" : {
         "bytes" : <NumberLong>,
         "getmores" : {
            "num" : <num>,
            "totalMillis" : <num>
         },
         "ops" : <NumberLong>,
         "readersCreated" : <NumberLong>
      },
      "preload" : {
         "docs" : {
            "num" : <num>,
            "totalMillis" : <num>
         },
         "indexes" : {
            "num" : <num>,
            "totalMillis" : <num>
         }
      }
   },
   "storage" : {
         "freelist" : {
            "search" : {
               "bucketExhausted" : <num>,
               "requests" : <num>,
               "scanned" : <num>
            }
         }
   },
   "ttl" : {
         "deletedDocuments" : NumberLong(<num>),
         "passes" : NumberLong(<num>)
   }
},

• metrics

  • 该文档返回的各种统计信息反映了正在运行的mongod实例的当前使用情况和状态。

• metrics. commands

  • 3.0 版中的新功能。

报告有关数据库命令使用情况的文档。 metrics.commands中的字段是database commands的名称，每个值都是一个文档，其中报告了已执行的命令总数以及失败的执行次数。

• metrics.commands.<command>. failed
  {#serverstatus.metrics.commands.<command>.failed}

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

• metrics.commands.<command>. total
  {#serverstatus.metrics.commands.<command>.total}

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

• metrics. document

  • 反映文档访问和修改模式的文档。将这些值与opcounters文档中的数据进行比较，该文档可跟踪操作总数。

• metrics.document. deleted

  • 删除的文档总数。

• metrics.document. inserted

  • 插入的文档总数。

• metrics.document. returned

  • 查询返回的文档总数。

• metrics.document. updated

  • 更新的文档总数。

• metrics. executor

  • 3.2 版中的新功能。

报告复制执行程序的各种统计信息的文档。

• metrics. getLastError

  • 报告有关getLastError使用情况的文档。

• metrics.getLastError. wtime

  • 报告getLastError操作的文档的w参数大于1。

• metrics.getLastError.wtime. num

  • await 指定副本关注项(即w值大于1)的副本集中的一个或多个成员的，具有指定写关注点(即w)的getLastError个操作的总数。

• metrics.getLastError.wtime. totalMillis

  • mongod花了总时间(以毫秒为单位)，其中getLastError操作具有写关注(即w)，它们 await 副本集的一个或多个成员确认写操作(即w值大于1)。

• metrics.getLastError. wtimeouts

  • 由于wtimeout阈值到getLastError，write concern操作已超时的次数。

• metrics. operation

  • 该文档包含 MongoDB 使用特殊操作类型处理的几种类型的更新和查询操作的计数器。

• metrics.operation. fastmod

  • 从 3.4 中删除

如果使用 MMAPv1 存储引擎，则既不会导致文档增长也不需要更新索引的update操作数。例如，此计数器将记录一个更新操作，该操作使用$inc运算符来递增未索引字段的值。

• metrics.operation. idhack
  • 从 3.4 中删除

包含_id字段的查询数。对于这些查询，MongoDB 将在_id字段上使用默认索引，并跳过所有查询计划分析。

• metrics.operation. scanAndOrder

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

• metrics.operation. writeConflicts

  • 遇到写冲突的查询总数。

• metrics. queryExecutor

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

• metrics.queryExecutor. scanned

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

• metrics.queryExecutor. scannedObjects

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

• metrics. record

  • 报告磁盘上的内存文件中与记录分配有关的数据的文档。

• metrics.record. moves

  • 对于MMAPv1 存储引擎，metrics.record.moves报告在 MongoDB 数据集的磁盘表示中文件移动的总数。文档的移动是将文档的大小增加到超出其分配的记录大小的操作的结果。

• metrics. repl

  • 报告与复制过程相关的 Metrics 的文档。 metrics.repl文档出现在所有mongod实例上，即使不是replica sets成员的实例也是如此。

• metrics.repl. apply

  • 报告复制oplog中的操作应用程序的文档。

• metrics.repl.apply. batchSize

  • 版本 3.6.11 中的新功能。

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

有关更精细的粒度，请参见metrics.repl.apply.ops。

• metrics.repl.apply. batches

  • metrics.repl.apply.batches报告副本集的secondaries成员上的 oplog 应用程序过程。有关 oplog 申请流程的更多信息，请参见Multithreaded Replication

• metrics.repl.apply.batches. num

  • 跨所有数据库应用的批次总数。

• metrics.repl.apply.batches. totalMillis

  • mongod应用操作日志中的操作所花费的总时间(以毫秒为单位)。

• metrics.repl.apply. ops

  • 已应用的oplog个操作总数。每次操作后metrics.repl.apply.ops递增。

• metrics.repl. buffer

  • 在批量应用 oplog 条目之前，MongoDB 会从复制同步源缓冲区中缓冲 oplog 操作。 metrics.repl.buffer提供了一种跟踪操作日志缓冲区的方法。有关 oplog 申请流程的更多信息，请参见Multithreaded Replication。

• metrics.repl.buffer. count

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

• metrics.repl.buffer. maxSizeBytes

  • 缓冲区的最大大小。此值是mongod中的恒定设置，并且不可配置。

• metrics.repl.buffer. sizeBytes

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

• metrics.repl. network

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

• metrics.repl.network. bytes

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

• metrics.repl.network. getmores

  • metrics.repl.network.getmores报告getmore操作，这是操作日志cursor的请求，是操作日志复制过程的一部分。

• metrics.repl.network.getmores. num

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

• metrics.repl.network.getmores. totalMillis

  • metrics.repl.network.getmores.totalMillis报告从getmore操作中收集数据所需的总时间。

• metrics.repl.network. ops

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

• metrics.repl.network. readersCreated

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

• metrics.repl. preload

  • metrics.repl.preload在“预取”阶段报告，其中 MongoDB 将文档和索引加载到 RAM 中以提高复制吞吐量。

有关复制过程的* pre-fetch *阶段的更多信息，请参见Multithreaded Replication。

• metrics.repl.preload. docs

  • 报告在预取阶段加载到内存中的文档的文档。

• metrics.repl.preload.docs. num

  • 复制的预取阶段加载的文档总数。

• metrics.repl.preload.docs. totalMillis

  • 作为复制的“预取”阶段的一部分，加载文档所花费的总时间。

• metrics.repl.preload. indexes

  • 报告在复制的“预取”阶段加载到内存中的索引项的文档。

有关复制的“预取”阶段的更多信息，请参见Multithreaded Replication。

• metrics.repl.preload.indexes. num

  • 成员在复制(预取)阶段中更新文档之前由成员加载的索引条目总数。

• metrics.repl.preload.indexes. totalMillis

  • 作为复制的“预取”阶段的一部分，加载索引条目所花费的总时间(以毫秒为单位)。

• metrics.storage.freelist.search. bucketExhausted

  • mongod检查空闲列表而未找到适当的大记录分配的次数。

• metrics.storage.freelist.search. requests

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

• metrics.storage.freelist.search. scanned

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

• metrics. ttl

  • 报告有关ttl index进程资源使用情况的操作的文档。

• metrics.ttl. deletedDocuments

  • 从集合中以ttl index删除的文档总数。

• metrics.ttl. passes

  • 后台进程从带有ttl index的集合中删除文档的次数。

• metrics. cursor
  • 2.6 版的新功能。

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

• metrics.cursor. timedOut
  • 2.6 版的新功能。

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

• metrics.cursor. open
  • 2.6 版的新功能。

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

• metrics.cursor.open. noTimeout
  • 2.6 版的新功能。

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

• metrics.cursor.open. pinned
  • 2.6 版的新功能。

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

• metrics.cursor.open. total
  • 2.6 版的新功能。

MongoDB 为 Client 端维护的游标数。由于 MongoDB 会耗尽未使用的游标，因此该值通常较小或为零。但是，如果存在队列，陈旧的可尾游标或大量操作，则此值可能会增加。

• metrics.cursor.open. singleTarget
  • 3.0 版中的新功能。

仅以单个分片为目标的游标总数。只有mongos个实例报告metrics.cursor.open.singleTarget个值。

• metrics.cursor.open. multiTarget
  • 3.0 版中的新功能。

仅针对个以上分片的游标总数。只有mongos个实例报告metrics.cursor.open.multiTarget个值。

watchdog

3.6 版的新功能。

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

• watchdog

  • 报告存储节点看门狗状态的文档。

• watchdog. checkGeneration

  • 自启动以来已检查目录的次数。每monitoringPeriod多次检查目录。

• watchdog. monitorGeneration

  • 已检查mongod使用的所有文件系统的状态的次数。每monitoringPeriod递增一次。

• watchdog. monitorPeriod

  • watchdogPeriodSeconds设置的值。这表示两次状态检查之间的时间段。