/ /

Comandos de banco de dados

Diagnóstico

Página inicial do Docs

Manual do banco de dados

Referência

Comandos de banco de dados

Diagnóstico

serverStatus (comando de banco de dados)

Esta versão da documentação foi arquivada e não é mais suportada. Para atualizar seu sistema do 6.0, consulte osprocedimentos de atualização do MongoDB 7.0 .

Definição

serverStatus: O comando serverStatus retorna um documento que fornece uma visão geral do estado do banco de dados. Monitorar aplicativos pode executar este comando em um intervalo regular para coletar estatísticas sobre a instância.

Compatibilidade

Esse comando está disponível em implantações hospedadas nos seguintes ambientes:

MongoDB Atlas: o serviço totalmente gerenciado para implantações do MongoDB na nuvem

Observação

Este comando é aceito em todos os clusters do MongoDB Atlas. Para obter informações sobre o suporte do Atlas a todos os comandos, consulte Comandos não suportados.

MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB
MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

O comando tem a seguinte sintaxe:

db.runCommand(
   {
     serverStatus: 1
   }
)

O valor (ou seja, 1 acima) não afeta a operação do comando. O comando db.serverStatus() retorna uma grande quantidade de dados. Para retornar um objeto ou campo específico do resultado, anexe o nome do objeto ou campo ao comando.

Por exemplo:

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

mongosh fornece o encapsulador db.serverStatus() para o comandoserverStatus.

Dica

Grande parte da saída de serverStatus também é exibida dinamicamente por mongostat. Consulte o comando mongostat para mais informações.

Comportamento

Por padrão, serverStatus exclui em sua saída:

parte do conteúdo no documento repl.
Documento mirroredReads.

Para incluir campos que são excluídos por padrão, especifique o campo de nível superior e defina-o para 1 no comando. Para excluir campos incluídos por padrão, especifique o campo e defina como 0. Você pode especificar campos incorporados ou de nível superior.

Por exemplo, a seguinte operação exclui as informações repl, metrics e locks na saída.

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

Por exemplo, a seguinte operação exclui o campo histogram incorporado na saída.

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

O exemplo a seguir inclui todas as informações de repl na saída:

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

Inicialização

As estatísticas relatadas por serverStatus são redefinidas quando o servidor mongod é reiniciado.

Este comando sempre retornará um valor, mesmo em um banco de dados novo. O comando relacionado db.serverStatus() nem sempre retorna um valor a menos que um contador tenha começado a incrementar para uma métrica específica.

Após executar uma query de atualização, db.serverStatus() e db.runCommand({ serverStatus: 1}) retornam os mesmos valores.

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

Incluir `mirroredReads`

Por padrão, as informações de mirroredReads não são incluídas na saída. Para retornar informações mirroredReads, você deve especificar explicitamente a inclusão:

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

Incluir `latchAnalysis`

Por padrão, as informações do latchAnalysis (disponíveis a partir da versão 4.4) não são incluídas na saída. Para retornar informações latchAnalysis , você deve especificar explicitamente a inclusão:

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

Incluir `latchAnalysis`

Por padrão, as informações de latchAnalysis não são incluídas na saída. Para retornar informações latchAnalysis, você deve especificar explicitamente a inclusão:

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

`tcmalloc` Alterar verbosidade de

Por padrão, as informações tcmalloc são incluídas na saída. Esta seção fornece estatísticas de alocação de memória para seu banco de dados. Para alterar a verbosidade da seção tcmalloc, especifique um número inteiro entre 0 e 2 (inclusive):

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

O comando tem o seguinte comportamento:

Por padrão, tcmalloc está configurado para 1.
Passar um valor inteiro maior aumenta a verbosidade.
Passar 0 ou false omite a seção tcmalloc da saída.
Passar qualquer outra entrada resulta na configuração padrão.

Para mais informações sobre como o MongoDB aloca memória, consulte TCMalloc.

Saída

Observação

Os campos de saída variam dependendo da versão do MongoDB, da plataforma do sistema operacional subjacente, do mecanismo de armazenamento e do tipo de nó, incluindo mongos, mongod ou nó do conjunto de réplicas.

Para ver a saída de serverStatus específica da sua versão do MongoDB, consulte a versão correspondente do Manual do MongoDB.

asserts

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

asserts: Um documento que relata o número de asserções exibidas desde o início do processo MongoDB. Asserções são verificações internas de erros que ocorrem enquanto o banco de dados está operando e podem ajudar a diagnosticar problemas com o servidor MongoDB. Valores de asserção diferentes de zero indicam erros de asserção, que são incomuns e não são motivo imediato de preocupação. Os erros que geram asserções podem ser registrados no arquivo de log ou retornados diretamente a um aplicativo cliente para obter mais informações.

asserts.regular: O número de afirmações regulares levantadas desde o início do processo do MongoDB. Examine o log do MongoDB para obter mais informações.

asserts.warning: Este campo sempre retorna zero 0.

asserts.msg: O número de afirmações de mensagens levantadas desde o início do processo MongoDB. Examine o arquivo de log para obter mais informações sobre essas mensagens.

asserts.user: O número de "asserções de usuário" que ocorreram desde a última vez que o processo MongoDB começou. São erros que o usuário pode gerar, como falta de espaço em disco ou chave duplicada. Você pode evitar essas asserções corrigindo um problema com seu aplicativo ou sistema. Os logs do servidor podem ter informações limitadas sobre "asserções de usuário". Para aprender mais informações sobre a origem de "asserções de usuário", verifique os logs quanto a erros do aplicativo.

asserts.rollovers: O número de vezes que os contadores de afirmação foram reiniciados desde a última vez que o processo do MongoDB foi iniciado. Os contadores voltam a zero após 2 ³⁰ afirmações. Use esse valor para fornecer contexto para os outros valores na estrutura de dados asserts.

bucketCatalog

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

Novidades na versão 5.0.

Um documento que relata métricas relacionadas ao armazenamento interno de coleções de séries temporais.

O bucketCatalog retorna as seguintes métricas:

Métrica	Descrição
`numBuckets`	O número de buckets que armazenam dados de série temporal internamente.
`numOpenBuckets`	O número de gravações ativas e não confirmadas em buckets.
`numIdleBuckets`	O número de buckets que não estão cheios e podem armazenar dados de série temporal recebidos.
`memoryUsage`	O número de bytes usados pelas estruturas de dados de buckets internas.

Você também pode usar a $collStats fases do pipeline de agregação para encontrar métricas de série temporal. Para aprender mais, veja saída do storageStats em coleção de séries temporais.

catalogStats

Novidades na versão 5.1.

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

catalogStats: Um documento que relata estatísticas sobre o uso da coleção por meio de contagens de coleção.

catalogStats.collections: O número total de coleções de usuários (não incluindo coleções do sistema).

catalogStats.capped: O número total de coleções de usuários limitadas.

catalogStats.views: O número total de visualizações do usuário.

catalogStats.timeseries: O número total de coleções de séries temporais.

catalogStats.internalCollections: O número total de coleções do sistema (coleções nos bancos de dados config, admin ou local).

catalogStats.internalViews: O número total de visualizações de coleções do sistema (coleção nos banco de dados config, admin ou local).

conexões

connections : {
   current : <num>,
   available : <num>,
   totalCreated : <num>,
   active : <num>,
   threaded : <num>,
   exhaustIsMaster : <num>,
   exhaustHello : <num>,
   awaitingTopologyChanges : <num>,
   loadBalanced : <num>
},

connections: Um documento que relata o status das conexões. Use esses valores para avaliar os requisitos atuais de carga e capacidade do servidor.

connections.current

O número de conexões de entrada dos clientes com o servidor do banco de dados. Esse número inclui a sessão atual do shell. Considere o valor de connections.available para adicionar mais contexto a este dado.

O valor incluirá todas as conexões de entrada incluindo quaisquer conexões de shell ou conexões de outros servidores, como membros do conjunto de réplicas ou instâncias mongos.

connections.available: O número de conexões de entrada não utilizadas disponíveis. Considere esse valor em combinação com o valor de connections.current para entender a carga de conexão no banco de dados e o documento Configurações do UNIX ulimit para implantações autogerenciadas para obter mais informações sobre os limites do sistema em conexões disponíveis.

connections.totalCreated: Contagem de todas as conexões de entrada criadas para o servidor. Esse número inclui conexões que já foram fechadas.

connections.active: O número de conexões de cliente ativas com o servidor. Conexões de cliente ativas referem-se a conexões de cliente que atualmente têm operações em andamento.

connections.threaded: O número de conexões recebidas de clientes que são atribuídas a threads que o cliente de serviço solicita.
Novidades na versão 5.0.

connections.exhaustIsMaster: O número de conexões cuja última solicitação foi isMaster com exhaustAllowed.
Observação
Se você estiver executando o MongoDB 5.0 ou posterior, não use o comando isMaster. Em vez disso, use hello.

connections.exhaustHello: O número de conexões cuja última solicitação foi hello com exhaustAllowed.
Novidades na versão 5.0.

connections.awaitingTopologyChanges: O número de clientes que atualmente aguardam uma solicitação hello ou isMaster para uma alteração de topologia.
Observação
Se você estiver executando o MongoDB 5.0 ou posterior, não use o comando isMaster. Em vez disso, use hello.

connections.loadBalanced: Novidades na versão 5.3.
O número atual de conexões recebidas através do balancer de carga.

defaultRWConcern

A seção defaultRWConcern fornece informações sobre a cópia local das configurações de read ou write concern padrão globais. Os dados podem estar obsoletos ou desatualizados. Consulte getDefaultRWConcern para mais informações.

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

defaultRWConcern: As últimas configurações de read ou write concern padrão globais conhecidas.

defaultRWConcern.defaultReadConcern

A última configuração de read concern padrão global conhecida.

Se serverStatus não retornar esse campo, a preocupação de leitura padrão global não foi definida ou ainda não foi propagada para a instância.

defaultRWConcern.defaultReadConcern.level

A última configuração de nível de read concern padrão global conhecida.

Se serverStatus não retornar esse campo, o padrão global para essa configuração não foi definido ou ainda não foi propagado para a instância.

defaultRWConcern.defaultWriteConcern

A última configuração de write concern padrão global conhecida.

Se serverStatus não retornar esse campo, a preocupação de gravação padrão global não foi definida ou ainda não foi propagada para a instância.

defaultRWConcern.defaultWriteConcern.w

A última configuração de w padrão global conhecida.

Se serverStatus não retornar esse campo, o padrão global para essa configuração não foi definido ou ainda não foi propagado para a instância.

defaultRWConcern.defaultWriteConcern.wtimeout

A última configuração de wtimeout padrão global conhecida.

Se serverStatus não retornar esse campo, o padrão global para essa configuração não foi definido ou ainda não foi propagado para a instância.

defaultRWConcern.defaultWriteConcernSource: A origem da write concern padrão. Por padrão, o valor é "implicit". Após definir a write concern padrão com setDefaultRWConcern, o valor se torna "global".
Novidades na versão 5.0.

defaultRWConcern.defaultReadConcernSource: A origem da read concern padrão. Por padrão, o valor é "implicit". Depois de definir a read concern padrão com setDefaultRWConcern, o valor se torna "global".
Novidades na versão 5.0.

defaultRWConcern.updateOpTime: O registro de data/hora em que a instância atualizou pela última vez sua cópia de qualquer configuração global de preocupação de leitura ou preocupação de gravação. Se os campos defaultRWConcern.defaultReadConcern e defaultRWConcern.defaultWriteConcern estiverem ausentes, este campo indicará o registro de data/hora quando os padrões foram desconfigurados pela última vez.

defaultRWConcern.updateWallClockTime: A hora do relógio quando a instância atualizou pela última vez sua cópia de qualquer configuração de preocupação de leitura ou gravação global. Se os campos defaultRWConcern.defaultReadConcern e defaultRWConcern.defaultWriteConcern estiverem ausentes, esse campo indicará a hora em que os padrões foram desconfigurados pela última vez.

defaultRWConcern.localUpdateWallClockTime: O horário do sistema local em que a instância atualizou pela última vez sua cópia de qualquer configuração de preocupação de leitura ou gravação global. Se esse campo for o único campo sob defaultRWConcern, a instância nunca teve conhecimento de uma configuração global de preocupação de leitura ou gravação de padrão.

electionMetrics

A seção electionMetrics fornece informações sobre as eleições convocadas por essa instância mongod em uma tentativa de se tornar o primary:

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

Métricas sobre eleições que foram convocadas pelo mongod instância como parte de uma transferência eleitoral quando o primary foi cancelado.

O stepUpCmd inclui o número de eleições convocadas e o número de eleições realizadas.

electionMetrics.priorityTakeover

Métricas sobre eleições que foram convocadas pela instância mongod porque sua priority é maior que a do primary.

O electionMetrics.priorityTakeover inclui o número de eleições convocadas e o número de eleições realizadas.

electionMetrics.catchUpTakeover

Métricas sobre eleições convocadas pela instância mongod porque é mais atual do que o primary.

O catchUpTakeover inclui o número de eleições convocadas e o número de eleições realizadas.

Dica

settings.catchUpTakeoverDelayMillis

electionMetrics.electionTimeout

Métricas sobre eleições convocadas pela instância mongod porque não conseguiu chegar ao primary dentro de settings.electionTimeoutMillis.

O electionTimeout inclui o número de eleições convocadas e o número de eleições realizadas.

Dica

settings.electionTimeoutMillis

electionMetrics.freezeTimeout

Métricas sobre eleições convocadas pela instância mongod após o término do freeze period (durante o qual o nó não pode buscar uma eleição).

O electionMetrics.freezeTimeout inclui o número de eleições convocadas e o número de eleições realizadas.

electionMetrics.numStepDownsCausedByHigherTerm: Número de vezes que a instância mongod diminuiu porque viu um termo maior (especificamente, outros nós participaram de eleições adicionais).

electionMetrics.numCatchUps: Número de eleições em que a instância mongod como primary recém-eleito teve que alcançar a maior entrada conhecida no oplog.

electionMetrics.numCatchUpsSucceeded: Número de vezes que a instância mongod como primary recém-eleito alcançou com sucesso a entrada de oplog mais alta conhecida.

electionMetrics.numCatchUpsAlreadyCaughtUp: Número de vezes que a instância mongod como primary recém-eleito concluiu seu processo de recuperação porque já estava recuperada quando foi eleita.

electionMetrics.numCatchUpsSkipped: Número de vezes que a instância mongod como primary recém-selecionado ignorou o processo de recuperação.

electionMetrics.numCatchUpsTimedOut: Número de vezes que a instância mongod como primary recém-eleito concluiu o processo de recuperação devido ao limite settings.catchUpTimeoutMillis.

electionMetrics.numCatchUpsFailedWithError: Número de vezes que o processo de recuperação do primary recém-eleito falhou com um erro.

electionMetrics.numCatchUpsFailedWithNewTerm: Número de vezes que o processo de recuperação do primary recém-eleito foi concluído porque outros nós tinham um termo mais elevado (especificamente, outros nós participaram de eleições adicionais).

electionMetrics.numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd: Número de vezes que o processo de recuperação do primary recém-eleito foi concluído porque o mongod recebeu o comando replSetAbortPrimaryCatchUp.

electionMetrics.averageCatchUpOps: Número médio de operações aplicadas durante os processos de recuperação do primary recém-eleito.

extra_info

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

extra_info: Um documento que fornece informações adicionais sobre o sistema subjacente.

extra_info.note: Uma string com o texto 'fields vary by platform'

extra_info.page_faults

O número total de falhas de página. O contador extra_info.page_faults pode aumentar drasticamente durante momentos de desempenho ruim e pode estar correlacionado com ambientes de memória limitada e conjuntos de dados maiores. Falhas de página limitadas e esporádicas não indicam necessariamente um problema.

O Windows diferencia as falhas de página "hard" que envolvem E/S de disco das falhas de página "soft" que exigem apenas a movimentação de páginas na memória. O MongoDB conta falhas de página hard e soft nesta estatística.

flowControl

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

flowControl: Um documento que retorna estatísticas sobre o controle de fluxo. Com o controle de fluxo ativado, à medida que o atraso do ponto majority commit se aproxima de flowControlTargetLagSeconds, as gravações no primary precisam obter tickets antes de aceitar travas. Dessa forma, as métricas retornadas são significativas quando executadas no primary.

flowControl.enabled

Um booleano que indica se o controle de fluxo está habilitado (true) ou desabilitado (false).

Consulte também enableFlowControl.

flowControl.targetRateLimit

Quando executado no primary, o número máximo de tickets que podem ser adquiridos por segundo.

Quando executado em um secundário, o número retornado é um espaço reservado.

flowControl.timeAcquiringMicros

Quando executado no primary, o tempo total de espera das operações de gravação para adquirir um ticket.

Quando executado em um secundário, o número retornado é um espaço reservado.

flowControl.locksPerKiloOp

Quando executado no primary, uma aproximação do número de travas realizadas por 1000 operações.

Quando executado em um secundário, o número retornado é um espaço reservado.

flowControl.sustainerRate

Quando executado no primary, uma aproximação das operações aplicadas por segundo pelo secundário que está sustentando o ponto de commit.

Quando executado em um secundário, o número retornado é um espaço reservado.

flowControl.isLagged

Quando executado no primary, um booleano que indica se o controle de fluxo está ativado. O controle de fluxo é ativado quando o atraso da maioria com commit é maior do que alguma porcentagem de flowControlTargetLagSecondsconfigurado.

O atraso de replicação pode ocorrer sem envolver o controle de fluxo. Um secundário que não responde pode atrasar sem que o conjunto de réplicas receba carga suficiente para acionar o controle de fluxo, deixando o valor flowControl.isLagged em false.

Para obter informações adicionais, consulte Controle de fluxo.

flowControl.isLaggedCount

Quando executado em um primary, o número de vezes que o controle de fluxo foi acionado desde a última reinicialização. O controle de fluxo é ativado quando a maioria dos atrasos com commit é maior do que uma porcentagem de flowControlTargetLagSeconds.

Quando executado em um secundário, o número retornado é um espaço reservado.

flowControl.isLaggedTimeMicros

Quando executado no primary, a quantidade do controle de fluxo de tempo gasto sendo ativado desde a última reinicialização. O controle de fluxo é ativado quando a maioria dos atrasos com commit é maior do que uma porcentagem de flowControlTargetLagSeconds.

Quando executado em um secundário, o número retornado é um espaço reservado.

globalLock

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

globalLock

Um documento que informa sobre o estado de trava do banco de dados.

Em geral, o documento de travas fornece dados mais detalhados sobre os usos das travas.

globalLock.totalTime: O tempo, em microssegundos, desde a última vez que o banco de dados foi iniciado e criou o globalLock. Isso equivale aproximadamente ao tempo de atividade total do servidor.

globalLock.currentQueue: Um documento que fornece informações sobre o número de operações em fila devido a uma trava.

globalLock.currentQueue.total

O número total de operações na fila aguardando o bloqueio (ou seja, a soma de globalLock.currentQueue.readers e globalLock.currentQueue.writers).

Uma fila continuamente pequena, especialmente de operações mais curtas, não deve causar preocupação. As informações de leitores e gravadores de globalLock.activeClients contextualizam esses dados.

globalLock.currentQueue.readers: O número de operações que estão atualmente em fila e aguardando o read lock. Uma fila de leitura consistentemente pequena, especialmente de operações mais curtas, não deve causar preocupação.

globalLock.currentQueue.writers: O número de operações atualmente em fila e aguardando o bloqueio de escrita. Uma fila de escrita consistentemente pequena, especialmente de operações mais curtas, não deve causar preocupação.

globalLock.activeClients

Um documento que fornece informações sobre o número de clientes conectados e as operações de leitura e escrita realizadas por esses clientes.

Use esses dados para fornecer contexto para os dados globalLock.currentQueue.

globalLock.activeClients.total: O número total de conexões de clientes internos com o banco de dados, incluindo threads do sistema, bem como leitores e escritores em fila. Esta métrica será maior que o total de activeClients.readers e activeClients.writers devido à inclusão de threads do sistema.

globalLock.activeClients.readers: O número de conexões ativas do cliente que executam operações de leitura.

globalLock.activeClients.writers: O número de conexões ativas do cliente que executam operações de gravação.

hedgingMetrics

Somente para instâncias mongos.

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

hedgingMetrics

Fornece métricas em leituras distribuídas para a instância mongos.

Somente para instâncias mongos.

hedgingMetrics.numTotalOperations

O número total de operações emitidas com a opção de leitura distribuída ativada para essa instância mongos.

Somente para instâncias mongos.

hedgingMetrics.numTotalHedgedOperations

O número de todas as operações para as quais a instância mongos distribuiu a operação de leitura, ou seja, enviou a operação para um nó adicional de cada shard consultado.

Somente para instâncias mongos.

hedgingMetrics.numAdvantageouslyHedgedOperations

O número total da operação em que a leitura adicional enviada para distribuir a operação de leitura atendeu à solicitação do cliente.

Somente para instâncias mongos.

indexBulkBuilder

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

indexBulkBuilder: Fornece métricas para operações de construtor de índices em massa. Use essas métricas para diagnosticar problemas de compilação de índice com createIndexes, clonagem de collection durante a initial sync, compilações de índice que são retomadas após a inicialização e estatísticas sobre o uso do disco pelo classificador externo.

indexBuildBuilder.bytesSpilled: Novidades na versão 6.0.4.
O número de bytes gravados no disco pelo classificador externo.

indexBuilder.bytesSpilledUncompressed: Novidades na versão 6.0.4.
O número de bytes a serem gravados no disco pelo classificador externo antes da compressão.

indexBulkBuilder.count: O número de instâncias do construtor em massa criado.

indexBulkBuilder.filesClosedForExternalSort: O número de vezes que o classificador externo fechou um identificador de arquivo para passar dados ao disco. Combine esse valor com filesOpenedForExternalSort para determinar o número de identificadores de arquivos abertos em uso pelo classificador externo.

indexBulkBuilder.filesOpenedForExternalSort: O número de vezes que o classificador externo abriu um identificador de arquivo para passar dados ao disco. Combine esse valor com filesClosedForExternalSort para determinar o número de manipuladores de arquivos abertos em uso pelo classificador externo.

indexBulkBuilder.resumed: O número de vezes que o construtor em massa foi criado para uma construção de índice que pode ser retomada.

indexBulkBuilder.spilledRanges: Novidades na versão 6.0.4.
O número de vezes que o classificador externo passou para o disco.

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>") },
      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: Um documento que reporta estatísticas sobre todos os índices em bancos de dados e collections apenas em namespaces fora do sistema. indexStats não reporta estatísticas sobre índices nos bancos de dados admin, local e config.
Novidades na versão 6.0.

indexStats.count: O número total de índices.
Novidades na versão 6.0.

indexStats.features: Um documento que fornece contadores para cada tipo de índice e o número de acessos em cada índice. Cada tipo de índice em indexStats.features tem um campo count que conta o número total de índices para esse tipo e um campo accesses que conta o número de acessos nesse índice.
Novidades na versão 6.0.

Informações da instância

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

host: O nome de host do sistema. Em sistemas Unix/Linux, deve ser igual à saída do comando hostname.

advisoryHostFQDNs: Uma array dos nomes de domínio totalmente qualificados do sistema (FQDNs).

version: A versão do MongoDB do processo atual do MongoDB.

process: O processo atual do MongoDB. Os valores possíveis são: mongos ou mongod.

pid: O número de ID do processo.

uptime: O número de segundos em que o processo do MongoDB atual esteve ativo.

uptimeMillis: O número de milissegundos em que o processo do MongoDB atual esteve ativo.

uptimeEstimate: O tempo de atividade em segundos, conforme calculado a partir do sistema interno de cronometragem detalhado do MongoDB.

localTime: O ISODate representando a hora atual, de acordo com o servidor, em UTC.

latchAnalysis

Novidades na versão 4.4.

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

latchAnalysis

Um documento que reporta métricas relacionadas a primitivos de bloqueio interno (também conhecidos como travas).

Para retornar informações latchAnalysis, você deve especificar explicitamente a inclusão:

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

O latchAnalysis retorna para cada trava o <latch name> e as seguintes métricas associadas:

Métrica	Descrição
`created`	Número de vezes que a trava foi criada.
`destroyed`	Número de vezes em que a trava foi destruída.
`acquired`	Número de vezes em que a trava foi adquirida.
`released`	Número de vezes que a trava foi liberada.
`contended`	Número de vezes em que a trava teve contenção.
`hierarchicalAcquisitionLevelViolations`	Somente retornado se existirem violações Contém os seguintes campos: `onAcquire` Número de vezes em que a hierarquia da trava (ou seja, a ordenação dos níveis da trava) foi violada durante sua aquisição. `onRelease` Número de vezes em que a hierarquia da trava (ou seja, a ordenação dos níveis da trava) foi violada durante sua liberação.

Novidades na versão 4.4.

locks

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

locks

Um documento que reporta para cada trava <type>, dados na trava <modes>.

As possíveis travas <types> são:

Bloquear tipo	Descrição
`ParallelBatchWriterMode`	Representa um bloqueio para o modo de escrita em lote paralelo. Em versões anteriores, as informações do PBWM foram relatadas como parte das informações de bloqueio do `Global`.
`ReplicationStateTransition`	Representa o bloqueio obtido para transições de estado membro do conjunto de réplicas.
`Global`	Representa bloqueio global.
`Database`	Representa bloqueio de banco de dados.
`Collection`	Representa bloqueio de coleção.
`Mutex`	Representa mutex.
`Metadata`	Representa bloqueio de metadados.
`oplog`	Representa bloqueio no oplog.

Os possíveis <modes> são:

Modo de bloqueio	Descrição
`R`	Representa bloqueio compartilhado (S).
`W`	Representa bloqueio exclusivo (X).
`r`	Representa bloqueio de Intent Shared (IS).
`w`	Representa bloqueio Intent Exclusive (IX).

Todos os valores são do tipo Long().

locks.<type>.acquireCount: Número de vezes que a trava foi adquirida no modo especificado.

locks.<type>.acquireWaitCount: Número de vezes que as aquisições de travas locks.<type>.acquireCount encontraram esperas porque as travas foram mantidas em um modo conflitante.

locks.<type>.timeAcquiringMicros

Tempo de espera cumulativo em microssegundos para as aquisições de trava.

locks.<type>.timeAcquiringMicros dividido por locks.<type>.acquireWaitCount fornece um tempo médio aproximado de espera para o modo de bloqueio específico.

locks.<type>.deadlockCount: Número de vezes que as aquisições de trava encontraram imprevistos.

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: Fornece métricas sobre o cache de sessões de servidor.

logicalSessionRecordCache.activeSessionsCount

O número de todas as sessões locais ativas armazenadas em cache na memória pela instância mongod ou mongos desde o último período de atualização.

Dica

logicalSessionRecordCache.sessionsCollectionJobCount: O número que acompanha o número de vezes que o processo de atualização foi executado na collection config.system.sessions.
Dica
logicalSessionRefreshMillis

logicalSessionRecordCache.lastSessionsCollectionJobDurationMillis: O comprimento em milissegundos da última atualização.

logicalSessionRecordCache.lastSessionsCollectionJobTimestamp: A hora em que ocorreu a última atualização.

logicalSessionRecordCache.lastSessionsCollectionJobEntriesRefreshed: O número de sessões que foram atualizadas durante a última atualização.

logicalSessionRecordCache.lastSessionsCollectionJobEntriesEnded: O número de sessões encerradas durante a última atualização.

logicalSessionRecordCache.lastSessionsCollectionJobCursorsClosed: O número de cursores que foram fechados durante a última atualização da collection config.system.sessions.

logicalSessionRecordCache.transactionReaperJobCount: O número que acompanhar o número de vezes que o processo de limpeza do registro de transações foi executado na collection config.transactions.

logicalSessionRecordCache.lastTransactionReaperJobDurationMillis: A duração (em milissegundos) da última limpeza do registro de transações.

logicalSessionRecordCache.lastTransactionReaperJobTimestamp: A hora da última limpeza do registro das transações.

logicalSessionRecordCache.lastTransactionReaperJobEntriesCleanedUp: O número de entradas na collection config.transactions que foram excluídas durante a última limpeza do registro de transações.

logicalSessionRecordCache.sessionCatalogSize

Para uma instância mongod,
O tamanho do cache na memória das entradas de config.transactions. Corresponde a retryable writes ou transações cujas sessões não expiraram dentro de localLogicalSessionTimeoutMinutes.
Para uma instância mongos,
O número do cache na memória de suas sessões que tiveram transações dentro do intervalo localLogicalSessionTimeoutMinutes mais recente.

mem

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

mem: Um documento que relata a arquitetura do sistema do mongod e o uso da memória atual.

mem.bits: Um número, 64 ou 32, que indica se a instância MongoDB é compilada para arquitetura de 64 bits ou 32 bits.

mem.resident: O valor de mem.resident é aproximadamente equivalente à quantidade de RAM, em mebibyte (MiB), atualmente utilizada pelo processo do banco de dados. Durante o uso normal, esse valor tende a crescer. Em servidores de banco de dados dedicados, esse número tende a se aproximar da quantidade total de memória do sistema.

mem.virtual: mem.virtual exibe a quantidade, em mebibyte (MiB), de memória virtual utilizada pelo processo do mongod.

mem.supported: Um booleano que indica se o sistema subjacente permite informações de memória estendida. Se esse valor for falso e o sistema não permitir informações de memória estendida, outros valores mem podem não estar acessíveis ao servidor de banco de dados.

mem.note

O campo mem.note aparece se mem.supported for falso.

O campo mem.note contém o texto: 'not all mem info support on this platform'.

metrics

metrics : {
   abortExpiredTransactions: {
      passes: <integer>
   },
   apiVersions: {
      <appName1>: <string>,
      <appName2>: <string>,
      <appName3>: <string>
   },
   aggStageCounters : {
         <aggregation stage> : Long("<num>")
   },
   changeStreams: {
      largeEventsFailed: Long("<num>"),
      largeEventsSplit: Long("<num>")
   },
   commands: {
      <command>: {
         failed: Long("<num>"),
         validator: {
           total: Long("<num>"),
           failed: Long("<num>"),
           jsonSchema: Long("<num>")
         },
         total: Long("<num>")
      }
   },
   cursor : {
         moreThanOneBatch : Long("<num>"),
         timedOut : Long("<num>"),
         totalOpened : Long("<num>"),
         lifespan : {
            greaterThanOrEqual10Minutes : Long("<num>"),
            lessThan10Minutes : Long("<num>"),
            lessThan15Seconds : Long("<num>"),
            lessThan1Minute : Long("<num>"),
            lessThan1Second : Long("<num>"),
            lessThan30Seconds : Long("<num>"),
            lessThan5Seconds : Long("<num>")
         },
         open : {
            noTimeout : Long("<num>"),
            pinned : Long("<num>"),
            multiTarget : Long("<num>"),
            singleTarget : Long("<num>"),
            total : Long("<num>")
         }
   },
   document : {
         deleted : Long("<num>"),
         inserted : Long("<num>"),
         returned : Long("<num>"),
         updated : Long("<num>")
   },
   dotsAndDollarsFields : {
         inserts : Long("<num>"),
         updates : Long("<num>")
   },
   getLastError : {
         wtime : {
            num : <num>,
            totalMillis : <num>
         },
         wtimeouts : Long("<num>"),
         default : {
             unsatisfiable : Long("<num>"),
             wtimeouts : Long("<num>")
         }
   },
   mongos : {
      cursor : {
         moreThanOneBatch : Long("<num>"),
         totalOpened : Long("<num>")
      }
   },
   operation : {
         scanAndOrder : Long("<num>"),
         writeConflicts : Long("<num>")
   },
   operatorCounters : {
      expressions : {
         <command> : Long("<num>")
      },
      match : {
         <command> : Long("<num>")
      }
   },
   query: {
     allowDiskUseFalse: Long("<num>"),
     planCacheTotalSizeEstimateBytes: Long("<num>"),
     updateOneOpStyleBroadcastWithExactIDCount: Long("<num>"),
     lookup: {
       pipelineTotalCount: Long("<num>"),
       slotBasedExecutionCounters: {
         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>") }
            ]
          }
        },
        queryFramework: {
          aggregate: {
            classicHybrid: Long("<num>"),
            classicOnly: Long("<num>"),
            cqf: Long("<num>"),
            sbeHybrid: Long("<num>"),
            sbeOnly: Long("<num>")
          },
          find: { classic: Long("<num>"), cqf: Long("<num>"), sbe: Long("<num>") }
        }
      },
   queryExecutor: {
      scanned : Long("<num>"),
      scannedObjects : Long("<num>"),
      collectionScans : {
         nonTailable : Long("<num>"),
         total : Long("<num>")
      }
   },
   record : {
         moves : Long("<num>")
   },
   repl : {
      executor : {
         pool : {
            inProgressCount : <num>
         },
         queues : {
            networkInProgress : <num>,
            sleepers : <num>
         },
         unsignaledEvents : <num>,
         shuttingDown : <boolean>,
         networkInterface : <string>
      },
      apply : {
         attemptsToBecomeSecondary : Long("<num>"),
         batches : {
            num : <num>,
            totalMillis : <num>
         },
         ops : Long("<num>")
      },
      buffer : {
         count : Long("<num>"),
         maxSizeBytes : Long("<num>"),
         sizeBytes : Long("<num>")
      },
      initialSync : {
         completed : Long("<num>"),
         failedAttempts : Long("<num>"),
         failures : Long("<num>")
      },
      network : {
         bytes : Long("<num>"),
         getmores : {
            num : <num>,
            totalMillis : <num>
         },
         notPrimaryLegacyUnacknowledgedWrites : Long("<num>"),
         notPrimaryUnacknowledgedWrites : Long("<num>"),
         oplogGetMoresProcessed : {
            num : <num>,
            totalMillis : <num>
         },
         ops : Long("<num>"),
         readersCreated : Long("<num>"),
         replSetUpdatePosition : {
             num : Long("<num>")
         }
      },
      reconfig : {
         numAutoReconfigsForRemovalOfNewlyAddedFields :
            Long("<num>")
      },
      stateTransition : {
         lastStateTransition : <string>,
         userOperationsKilled : Long("<num>"),
         userOperationsRunning : Long("<num>")
      },
      syncSource : {
         numSelections : Long("<num>"),
         numTimesChoseSame : Long("<num>"),
         numTimesChoseDifferent : Long("<num>"),
         numTimesCouldNotFind : Long("<num>")
      },
      waiters : {
         opTime : Long("<num>"),
         replication : Long("<num>")
      }
   },
   storage : {
         freelist : {
            search : {
               bucketExhausted : <num>,
               requests : <num>,
               scanned : <num>
            }
         }
   },
   ttl : {
         deletedDocuments : Long("<num>"),
         passes : Long("<num>")
   }
},

metrics: Um documento que retorna várias estatísticas que refletem o uso atual e o estado de uma instância mongod em execução.

metrics.abortExpiredTransactions: documento que retorna estatísticas sobre o estado atual do thread abortExpiredTransactions .

metrics.abortExpiredTransactions.passes

Indica o número de passagens bem-sucedidas abortando transação mais antigas que o parâmetro transactionLifetimeLimitSeconds .

Se o valor passes parar de incrementar, isso indica que o thread abortExpiredTransactions pode estar preso.

metrics.aggStageCounters

Um documento que relata o uso de pipeline de agregação stages. Os campos em metrics.aggStageCounters são os nomes dos pipeline de agregação stages. Para cada etapa do pipeline, o serverStatus relata o número de vezes que esse estágio foi executado.

Atualizado na versão 5.2 (e 5.0.6).

metrics.apiVersions

Um documento que contém:

O nome de cada aplicativo cliente
A versão de API estável com a qual cada aplicativo foi configurado no período de 24 horas

Considere o seguinte ao visualizar metrics.apiVersions:

Os possíveis valores retornados para cada appname são:
- default: O comando foi emitido sem uma versão de API estável especificada.
- 1: O comando foi emitido com a Stable API versão 1.
Observação
Você pode ver ambos os valores de retorno para um appname porque é possível especificar uma versão da API estável no nível do comando. Alguns de seus comandos podem ter sido emitidos sem a versão da API estável, enquanto outros foram emitidos com a versão 1.
As métricas de versão da API são mantidas por 24 horas. Se nenhum comando for emitido com uma versão de API específica de um aplicativo nas últimas 24 horas, esse appname e a versão de API serão removidos das métricas. Isso também se aplica à métrica de versão da API default.
Defina o appname ao se conectar a uma instância MongoDB especificando o appname no URI de conexão. ?appName=ZZZ define appname como ZZZZ.
Os drivers que acessam a API estável podem definir um appname padrão.
Se nenhum appname estiver configurado, um valor padrão será preenchido automaticamente com base no produto. Por exemplo, para uma conexão do MongoDB Compass sem appname no URI, a métrica retorna: 'MongoDB Compass': [ 'default' ].

Novidade na versão 5.0.

metrics.operatorCounters: Um documento que relata o uso de operadores e expressões do aggregation pipeline.

metrics.operatorCounters.expressions

Um documento com um número que indica com que frequência os operadores de expressão são executados.

Para obter métricas de um operador específico, como o operador maior que ($gt), anexe o operador ao comando:

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

Novidades na versão 5.0.

metrics.operatorCounters.match

Um documento com um número que indica com que frequência as expressões de correspondência são executadas.

Os operadores de expressão de correspondência também são incrementados como parte de um estágio $match do aggregation pipeline. Se o estágio $match usar o operador $expr, o contador de $expr será incrementado, mas os contadores de componentes não serão incrementados.

Considere a seguinte query:

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

O contador para $expr é incrementado quando a query é executada. O contador para $gt não.

metrics.changeStreams: Um documento que relata informações sobre eventos de change stream maiores que 16 MB.
Novidade na versão 6.0.9.

metrics.changeStreams.largeEventsFailed: O número de eventos de change stream que causaram uma exceção BSONObjectTooLarge porque o evento tinha mais de 16 MB. Para evitar a exceção, consulte $changeStreamSplitLargeEvent.
Novidades na versão 6.0.9: (Também disponível em 5.0.19)

metrics.changeStreams.largeEventsSplit: O número de eventos de change stream superiores a 16 MB que foram divididos em fragmentos menores. Os eventos só serão divididos se você usar o estágio de pipeline $changeStreamSplitLargeEvent.
Novidade na versão 6.0.9.

metrics.commands

Um documento que relata o uso de comandos de banco de dados. Os campos em metrics.commands são os nomes dos comandos de banco de dados. Para cada comando, o serverStatus relata o número total de execuções e o número de execuções com falha.

metrics.commands inclui replSetStepDownWithForce (ou seja, o comando replSetStepDown com force: true), bem como o replSetStepDowngeral. Nas versões anteriores, o comando relatava apenas as métricas replSetStepDown gerais.

metrics.commands.<command>.failed: O número de vezes que <command> falhou neste mongod.

metrics.commands.<create or collMod>.validator: Para os comandos create e collMod, um documento que relata objetos validator não vazios passados para o comando para especificar regras ou expressões de validação para a coleção.

metrics.commands.<create or collMod>.validator.total: O número de vezes que um objeto validator não vazio foi passado como uma opção para o comando nesse mongod.

metrics.commands.<create or collMod>.validator.failed: O número de vezes que uma chamada para o comando nesse mongod falhou com um objeto validator não vazio devido a um erro de validação de esquema.

metrics.commands.<create or collMod>.validator.jsonSchema: O número de vezes que um objeto validator com $jsonSchema foi passado como uma opção para o comando nesse mongod.

metrics.commands.<command>.total: O número de vezes que <command> executou neste mongod.

metrics.commands.update.pipeline

O número de vezes que um aggregation pipeline foi usado para atualizar documentos neste mongod. Subtraia esse valor do número total de atualizações para obter o número de atualizações feitas com a sintaxe do documento.

O contador pipeline está disponível apenas para operações update e findAndModify.

metrics.commands.findAndModify.pipeline

O número de vezes que findAndModify() foi usado em um aggregation pipeline para atualizar documentos sobre esse mongod.

O contador pipeline está disponível apenas para operações update e findAndModify.

metrics.commands.update.arrayFilters

O número de vezes que um arrayFilter foi usado para atualizar documentos neste mongod.

O contador arrayFilters está disponível apenas para operações update e findAndModify.

metrics.commands.findAndModify.arrayFilters

O número de vezes que um arrayFilter foi usado com findAndModify() para atualizar documentos neste mongod.

O contador arrayFilters está disponível apenas para operações update e findAndModify.

metrics.document: Um documento que reflete os padrões de acesso e modificação do documento. Compare esses valores com os dados do documento opcounters, que acompanha o número total de operações.

metrics.document.deleted: O número total de documentos excluídos.

metrics.document.inserted: O número total de documentos inseridos.

metrics.document.returned: O número total de documentos retornados por queries.

metrics.document.updated: O número total de documentos correspondentes para operações de atualização. Esse valor não é necessariamente igual ao número de documentos modificados por atualizações.

metrics.dotsAndDollarsFields

Um documento com um número que indica a frequência com que as operações de inserção ou atualização foram executadas usando um nome prefixado em dólar ($). O valor não informa o número exato de operações.

Quando uma operação upsert cria um novo documento, ele é considerado um insert em vez de um update.

Novidades na versão 5.0.

metrics.executor: Um documento que relata várias estatísticas para o executor de replicação.

metrics.getLastError: Um documento que relata o uso de write concern.

metrics.getLastError.wtime: Um documento que relata a operação de write concern conta com um argumento de w maior que 1.

metrics.getLastError.wtime.num: O número total de operações com write concern especificado (ou seja, w) que esperam que um ou mais nós de um conjunto de réplicas reconheçam a operação de escrita (ou seja, um valor w maior que 1).

metrics.getLastError.wtime.totalMillis: A quantidade total de tempo, em milissegundos, que o mongod gastou executando operações de write concern com um write concern (ou seja, w) que espera que um ou mais nós de um conjunto de réplicas reconheçam a operação de escrita (ou seja, um valor w maior que 1).

metrics.getLastError.wtimeouts: O número de vezes que as operações de write concern atingiram o tempo limite como resultado do limite wtimeout. Esse número aumenta para especificações de write concern padrão e não padrão.

metrics.getLastError.default

Um documento que relata quando um write concern padrão foi usado (ou seja, um write concern nãoclientSupplied). As possíveis origens de um write concern padrão são:

implicitDefault
customDefault
getLastErrorDefaults

Consulte a tabela a seguir para obter informações sobre cada possível origem de write concern, ou provenance:

Proveniência	Descrição
`clientSupplied`	A preocupação de gravação foi especificada no aplicativo.
`customDefault`	A preocupação de gravação originou-se de um valor padrão personalizado definido. Consulte `setDefaultRWConcern`.
`getLastErrorDefaults`	A preocupação de gravação originada do campo `settings.getLastErrorDefaults` do conjunto de réplicas.
`implicitDefault`	A preocupação de gravação originou-se do servidor na ausência de todas as outras especificações de preocupação de gravação.

metrics.getLastError.default.unsatisfiable: Número de vezes que um write concern diferente declientSupplied retornou o código de erro UnsatisfiableWriteConcern.

metrics.getLastError.default.wtimeouts: Número de vezes que um write concern nãoclientSupplied expirou.

metrics.mongos: Um documento que contém métricas sobre mongos.

metrics.mongos.cursor: Um documento que contém métricas para cursores usados por mongos.

metrics.mongos.cursor.moreThanOneBatch: O número total de cursores que retornaram mais de um lote desde que mongos começou. Lotes adicionais são recuperados usando o comando getMore.
Novidades na versão 5.0.

metrics.mongos.cursor.totalOpened: O número total de cursores que foram abertos desde que mongos iniciou, incluindo cursores atualmente abertos. Difere de metrics.cursor.open.total, que é o número de cursores abertos no momento.
Novidades na versão 5.0.

metrics.operation: Um documento que contém contadores para vários tipos de operações de atualização e query que o MongoDB lida com o uso de tipos de operação especiais.

metrics.operation.scanAndOrder: O número total de queries que retornam números classificados que não podem executar a operação de classificação usando um índice.

metrics.operation.writeConflicts: O número total de queries que encontraram conflitos de escrita.

metrics.query.multiPlanner

Fornece dados detalhados de planejamento de query para o mecanismo de execução de queries baseado em slot e o mecanismo de query clássico. Para obter mais informações sobre o mecanismo de execução de queries baseado em slot, consulte: Otimizações de pipeline do mecanismo de execução de queries baseado em slot.

Essas métricas destinam-se principalmente ao uso interno pelo MongoDB.

Novidades na versão 6.0.0, 5.0.9 e 4.4.15

query.multiPlanner.classicMicros: Agrega o número total de microssegundos gastos no multiplanejador clássico.

query.multiPlanner.classicWorks: Agrega o número total de "trabalhos" realizados no multiplanejador clássico.

query.multiPlanner.classicCount: Agrega o número total de invocações do multiplanejador clássico.

query.multiPlanner.sbeMicros: Agrega o número total de microssegundos gastos no multiplanejador de mecanismo baseado em slot.

query.multiPlanner.sbeNumReads: Agrega o número total de leituras feitas no multiplanejador de mecanismo baseado em slot.

query.multiPlanner.sbeCount: Agrega o número total de invocações do multiplanejador de mecanismo baseado em slot.

query.multiPlanner.histograms.classicMicros: Um histograma medindo o número de microssegundos gastos em uma invocação do multiplanejador clássico.

query.multiPlanner.histograms.classicWorks: Um histograma que mede o número de "trabalhos" realizados durante uma invocação do multiplanejador clássico.

query.multiPlanner.histograms.classicNumPlans: Um histograma medindo o número de planos no conjunto de candidatos durante uma invocação do multiplanejador clássico.

query.multiPlanner.histograms.sbeMicros: Um histograma medindo o número de microssegundos gastos em uma invocação do multiplanejador de mecanismo baseado em slot.

query.multiPlanner.histograms.sbeNumReads: Um histograma medindo o número de leituras durante uma invocação do multiplanejador de mecanismo baseado em slot.

query.multiPlanner.histograms.sbeNumPlans: Um histograma medindo o número de planos no conjunto de candidatos durante uma invocação do multiplanejador de mecanismo baseado em slot.

query.queryFramework.aggregate: Um documento que relata o número de operações de aggregation executadas em cada framework de query. Os subcampos em query.queryFramework.aggregate indicam o número de vezes que cada framework foi usado para executar uma operação de aggregation.

query.queryFramework.find: Um documento que relata o número de operações de localização executadas em cada framework de query. Os subcampos em query.queryFramework.find indicam o número de vezes que cada framework foi usado para executar uma operação de localização.

metrics.queryExecutor: Um documento que relata dados do sistema de execução de query.

metrics.queryExecutor.scanned: O número total de itens de índice verificados durante queries e avaliação do plano de queries. Este contador é o mesmo que totalKeysExamined na saída de explain().

metrics.queryExecutor.scannedObjects: O número total de documentos digitalizados durante queries e avaliação do plano de queries. Este contador é o mesmo que totalDocsExamined na saída de explain().

metrics.queryExecutor.collectionScans: Um documento que relata o número de queries que realizaram uma varredura de collection.

metrics.queryExecutor.collectionScans.nonTailable: O número de queries que executaram uma varredura de collection que não usou um cursor tailable.

metrics.queryExecutor.collectionScans.total: O número total de queries que executou uma varredura de collection. O total consiste em queries que usaram e não usaram um cursor tailable.

metrics.record: Um documento que reporta dados relacionados à alocação de registros nos arquivos de memória em disco.

metrics.repl: Um documento que comunica métricas relacionadas ao processo de replicação. O documento metrics.repl aparece em todas as instâncias mongod, mesmo naquelas que não são membros de conjuntos de réplicas.

metrics.repl.apply: Um documento que reporta a aplicação de operações a partir do oplog de replicação.

metrics.repl.apply.batchSize

O número total de operações de oplog aplicadas. metrics.repl.apply.batchSize é incrementado com o número de operações em um lote nos limites do lote, em vez de ser incrementado uma vez após cada operação.

Para granularidade mais fina, consulte metrics.repl.apply.ops.

metrics.repl.apply.batches: metrics.repl.apply.batches reporta sobre o processo do aplicativo oplog em nós secundários de conjuntos de réplicas. Consulte Replicação multithreaded para obter mais informações sobre os processos do aplicativo oplog.

metrics.repl.apply.batches.num: O número total de lotes aplicados em todos os bancos de dados.

metrics.repl.apply.batches.totalMillis: A quantidade total de tempo, em milissegundos, que o mongod gastou aplicando operações de oplog.

metrics.repl.apply.ops: O número total de operações de oplog aplicadas. metrics.repl.apply.ops é incrementado após cada operação.
Dica
metrics.repl.apply.batchSize

metrics.repl.buffer: O MongoDB oferece buffers de operações de oplog do buffer de origem de sincronização de replicação antes de aplicar entradas de oplog em um lote. metrics.repl.buffer oferece uma maneira de rastrear o buffer do oplog. Consulte replicação multithreaded para ver mais informações sobre o processo do aplicativo do oplog.

metrics.repl.buffer.count: O número atual de operações no buffer de oplog.

metrics.repl.buffer.maxSizeBytes: O tamanho máximo do buffer. Este valor é uma configuração constante no mongod e não é configurável.

metrics.repl.buffer.sizeBytes: O tamanho atual do conteúdo do buffer de oplog.

metrics.repl.network: metrics.repl.network reporta o uso da rede pelo processo de replicação.

metrics.repl.network.bytes: metrics.repl.network.bytes reporta a quantidade total de leitura de dados da origem de sincronização de replicação.

metrics.repl.network.getmores: metrics.repl.network.getmores comunica as operações getmore, que são solicitações de mais resultados do cursor oplog como parte do processo de replicação do oplog.

metrics.repl.network.getmores.num: metrics.repl.network.getmores.num reporta o número total de operações getmore. Essas operações solicitam um conjunto adicional de operações da origem de sincronização de replicação.

metrics.repl.network.getmores.totalMillis: metrics.repl.network.getmores.totalMillis comunica o tempo total necessário para coletar dados das operações getmore.
Observação
Esse número pode ser bem grande, pois o MongoDB aguardará mais dados mesmo que a operação getmore não retorne dados inicialmente.

metrics.repl.network.getmores.numEmptyBatches

O número de lotes oplog vazios que um secundário recebe de sua origem de sincronização. Um secundário recebe um lote vazio se estiver totalmente sincronizado com sua origem e se:

getmore atinge o tempo limite aguardando mais dados ou
O ponto de commit da maioria da origem de sincronização avançou desde o último lote enviado para este secundário.

Para um primary, se a instância era anteriormente secundária, o número relata os lotes vazios recebidos quando era secundário. Caso contrário, para um primary, esse número é 0.

metrics.repl.network.notPrimaryLegacyUnacknowledgedWrites: O número de operações de gravação legadas não reconhecidas (w: 0) (consulte Códigos de operação) que falharam porque o mongod atual não está no estado PRIMARY.

metrics.repl.network.notPrimaryUnacknowledgedWrites: O número de operações de gravação não reconhecidas (w: 0) que falharam porque o mongod atual não está no estado PRIMARY.

metrics.repl.network.oplogGetMoresProcessed: Um documento que reporta o número de comandos getMore para buscar o oplog que um nó processou como origem de sincronização.

metrics.repl.network.oplogGetMoresProcessed.num: O número de comandos getMore para buscar o oplog que um nó processou como uma origem de sincronização.

metrics.repl.network.oplogGetMoresProcessed.totalMillis: O tempo, em milissegundos, que o nó passou processando os comandos getMore contabilizados em metrics.repl.network.oplogGetMoresProcessed.num.

metrics.repl.network.ops: O número total de operações lidas a partir da origem de replicação.

metrics.repl.network.readersCreated: O número total de processos de query do oplog criados. O MongoDB criará uma nova query do oplog quando quer que ocorra um erro na conexão, incluindo de tempo limite ou uma operação de rede. Além disso, metrics.repl.network.readersCreated incrementará toda vez que o MongoDB selecionar uma nova origem para replicação.

metrics.repl.network.replSetUpdatePosition: Um documento que relata o número de comandos do replSetUpdatePosition que um nó enviou para sua origem de sincronização.

metrics.repl.network.replSetUpdatePosition.num: O número de comandos replSetUpdatePosition que um nó enviou para sua origem de sincronização. Os comandos replSetUpdatePosition são comandos internos de replicação que comunicam o progresso da replicação dos nós para suas origens de sincronização.
Observação
Os nós do conjunto de réplicas no estado STARTUP2 não enviam o comando replSetUpdatePosition para sua origem de sincronização.

metrics.repl.reconfig: Um documento contendo o número de vezes que os campos do nó newlyAdded foram automaticamente removidos pelo primary. Quando um nó é adicionado pela primeira vez ao conjunto de réplicas, o campo newlyAdded do nó é configurado para true.
Novidades na versão 5.0.

metrics.repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields: O número de vezes que newlyAdded campos de nós foram automaticamente removidos pelo primary. Quando um nó é adicionado pela primeira vez ao conjunto de réplicas, o campo newlyAdded do nó é configurado para true. Depois que o primary recebe a resposta de heartbeat do membro indicando que o estado do nó é SECONDARY, RECOVERING ou ROLLBACK, o primary remove automaticamente o campo newlyAdded do nó. Os campos do newlyAdded são armazenados na collection local.system.replset.
Novidades na versão 5.0.

metrics.repl.stateTransition

Informações sobre operações do usuário quando o nó passa por uma das seguintes transições que podem interromper as operações do usuário:

O nó avança para se tornar um primary.
O nó recua para se tornar secundário.
O nó está executando ativamente um rollback.

metrics.repl.stateTransition.lastStateTransition

A transição que está sendo relatada:

Mudança de estado	Descrição
`"stepUp"`	O nó avança para se tornar um primary.
`"stepDown"`	O nó recua para se tornar secundário.
`"rollback"`	O nó está executando ativamente um rollback.
`""`	O nó não sofreu nenhuma alteração de estado.

metrics.repl.stateTransition.userOperationsKilled: O número de operações interrompidas durante a mudança de estado da instância mongod .
Observação
Essa métrica reflete o número total de operações eliminadas, independentemente de terem sido iniciadas pelo usuário ou pelo servidor.

metrics.repl.stateTransition.userOperationsRunning: O número de operações que permaneceram em execução durante a mudança de estado da instância mongod.
Observação
Essa métrica reflete o número total de operações em execução, independentemente de terem sido iniciadas pelo usuário ou pelo servidor.

metrics.repl.syncSource: Informações sobre o processo de seleção da origem de sincronização de um nó de conjunto de réplicas.

metrics.repl.syncSource.numSelections: Número de vezes que um nó tentou escolher um nó para sincronizar dentre as opções de origem de sincronização disponíveis. Um nó tenta escolher um nó para sincronizar se, por exemplo, a origem de sincronização for reavaliada ou se o nó receber um erro de sua origem de sincronização atual.

metrics.repl.syncSource.numTimesChoseSame: Número de vezes que um nó manteve sua origem de sincronização original após reavaliar se sua origem de sincronização atual foi ideal.

metrics.repl.syncSource.numTimesChoseDifferent: Número de vezes que um nó escolheu uma nova origem de sincronização após reavaliar se a origem de sincronização atual era a ideal.

metrics.repl.syncSource.numTimesCouldNotFind: Número de vezes que um nó não conseguiu encontrar uma origem de sincronização disponível ao tentar escolher um nó para sincronizar.

metrics.repl.waiters.replication: O número de threads que aguardam confirmações de preocupação de gravação replicadas ou registradas no diário.
Novidades na versão 6.0.16: (Também disponível em 5.0.27)

metrics.repl.waiters.opTime: O número de threads em fila para atribuições de optime de replicação local.
Novidades na versão 6.0.16: (Também disponível em 5.0.27)

metrics.storage.freelist.search.bucketExhausted: O número de vezes que o mongod examinou a lista livre sem encontrar uma grande alocação de registro.

metrics.storage.freelist.search.requests: O número de vezes que mongod pesquisou alocações de registro disponíveis.

metrics.storage.freelist.search.scanned: O número de alocações de registro disponíveis que o mongod pesquisou.

metrics.ttl: Um documento que reporta a operação do uso do recurso do processo de índice TTL.

metrics.ttl.deletedDocuments: O número total de documentos excluídos de collections com um índice TTL.

metrics.ttl.passes: O número de vezes que o processo de background remove documentos de collections com um índice TTL.

metrics.cursor: Um documento que contém dados sobre o estado e o uso do cursor.

metrics.cursor.moreThanOneBatch: O número total de cursores que retornaram mais de um lote desde o início do processo do servidor. Os lotes adicionais são recuperados usando o comando getMore.
Novidades na versão 5.0.

metrics.cursor.timedOut: O número total de cursores que atingiram o tempo limite desde o início do processo do servidor. Se esse número for grande ou estiver crescendo regularmente, isso pode indicar um erro no aplicativo.

metrics.cursor.totalOpened: O número total de cursores que foram abertos desde o início do processo do servidor, incluindo cursores abertos agora. É diferente de metrics.cursor.open.total, que é apenas o número de cursores abertos agora.
Novidades na versão 5.0.

metrics.cursor.lifespan

Um documento que reporta o número de cursores que têm duração dentro de períodos especificados. A duração do cursor é o período de tempo de quando o cursor é criado até quando o cursor é eliminado usando o comando killCursors ou o cursor não tem objetos restantes no lote.

Os períodos de duração são:

< 1 segundo
>= 1 segundo a < 5 segundos
>= 5 segundos a < 15 segundos
>= 15 segundos a < 30 segundos
>= 30 segundos a < 1 minuto
>= 1 minuto a < 10 minutos
>= 10 minutos

Novidades na versão 5.0.

metrics.cursor.lifespan.greaterThanOrEqual10Minutes: O número de cursores com duração >= 10 minutos.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan10Minutes: O número de cursores com duração >= 1 minuto a < 10 minutos.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan15Seconds: O número de cursores com duração > = 5 segundos a < 15 segundos.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan1Minute: O número de cursores com duração >= 30 segundos a < 1 minuto.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan1Second: O número de cursores com duração < 1 segundo.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan30Seconds: O número de cursores com duração >= 15 segundos a < 30 segundos.
Novidades na versão 5.0.

metrics.cursor.lifespan.lessThan5Seconds: O número de cursores com duração >= 1 segundo a < 5 segundos.
Novidades na versão 5.0.

metrics.cursor.open: Um documento que contém dados sobre cursores abertos.

metrics.cursor.open.noTimeout: O número de cursores abertos com a opção DBQuery.Option.noTimeout definida para evitar o tempo limite após um período de inatividade.

metrics.cursor.open.pinned: O número de cursores abertos " fixados".

metrics.cursor.open.total: O número de cursores que o MongoDB está mantendo para os clientes. Como o MongoDB exausta cursores não utilizados, normalmente esse valor é pequeno ou zero. No entanto, se houver uma fila, ou cursors tailable, ou um grande número de operações, esse valor pode aumentar.

metrics.cursor.open.singleTarget: O número total de cursores que visam um único fragmento. Somente instâncias mongos comunicam valores de metrics.cursor.open.singleTarget.

metrics.cursor.open.multiTarget: O número total de cursores direcionados apenas a mais de um fragmento. Somente instâncias mongos reportam valores de metrics.cursor.open.multiTarget.

mirroredReads

Disponível apenas em mongod.

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

mirroredReads

Disponível apenas em mongod.

Um documento que reporta leituras espelhadas. Para retornar informações mirroredReads, você deve especificar explicitamente a inclusão:

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

mirroredReads.seen: O número de operações que permitem espelhamento recebido por este nó.
Dica
mirrorReads Parâmetro

mirroredReads.sent: O número de leituras espelhadas enviadas por este nó quando primary. Por exemplo, se uma leitura é espelhada e enviada para dois secundários, o número de leituras espelhadas é 2.
Dica
mirrorReads Parâmetro

network

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: Um documento que reporta dados sobre o uso da rede do MongoDB. Essas estatísticas medem apenas as conexões de entrada, especificamente o tráfego visto pelo mongod ou mongos em conexões de rede iniciadas por clientes ou outras instâncias mongod ou mongos. O tráfego das conexões de rede iniciadas por essa instância mongod ou mongos (especificamente, conexões de saída) não é medido nessas estatísticas.

network.bytesIn: O número total de bytes lógicos que o servidor recebeu por conexões de rede iniciadas por clientes ou outras instâncias do mongod ou mongos. Os bytes lógicos são o número exato de bytes que um determinado arquivo contém.

network.bytesOut: O número total de bytes lógicos que o servidor enviou por meio de conexões de rede iniciadas por clientes ou outras instâncias mongod ou mongos. Os bytes lógicos correspondem ao número de bytes que um determinado arquivo contém.

network.physicalBytesIn: O número total de bytes físicos que o servidor recebeu através de conexões de rede iniciadas por clientes ou outras instâncias mongod ou mongos . Bytes físicos são o número de bytes que realmente residem no disco.

network.physicalBytesOut: O número total de bytes físicos que o servidor enviou por meio de conexões de rede iniciadas por clientes ou outras instâncias mongod ou mongos . Bytes físicos são o número de bytes que realmente residem no disco.

network.numSlowDNSOperations: O número total de operações de resolução de DNS que demoraram mais de 1 segundo.

network.numSlowSSLOperations: O número total de operações de handshake SSL que demoraram mais de 1 segundo.

network.numRequests: O número total de solicitações distintas que o servidor recebeu. Use esse valor para contextualizar para os valores network.bytesIn e network.bytesOut para garantir que a utilização da rede do MongoDB seja consistente com as expectativas e o uso do aplicativo.

network.tcpFastOpen: Um documento que reporta dados sobre o suporte e uso do MongoDB de conexões TCP Fast Open (TFO).

network.tcpFastOpen.kernelSetting

Linux only

Retorna o valor de /proc/sys/net/ipv4/tcp_fastopen:

0 - O TCP Fast Open está desabilitado no sistema.
1 - O TCP Fast Open está habilitado para conexões de saída.
2 - O TCP Fast Open está habilitado para conexões de entrada.
3 - O TCP Fast Open está habilitado para conexões de entrada e saída.

network.tcpFastOpen.serverSupported

Retorna true se o sistema operacional do host permitir conexões TCP Fast Open (TFO) de entrada.
Retorna false se o sistema operacional do host não permitir conexões TCP Fast Open (TFO) de entrada.

network.tcpFastOpen.clientSupported

Retorna true se o sistema operacional do host permitir conexões TCP Fast Open (TFO) de saída.
Retorna false se o sistema operacional do host não permitir conexões TCP Fast Open (TFO) de saída.

network.tcpFastOpen.accepted: O número total de conexões TCP Fast Open (TFO) de entrada aceitas para mongod ou mongos desde a última inicialização de mongod ou mongos.

network.compression: Um documento que reporta a quantidade de dados compactados e descompactados por cada biblioteca de compressor de rede.

network.compression.snappy: Um documento que retorna estatísticas sobre o número de bytes que foram compactados e descompactados com a biblioteca snappy.

network.compression.zstd: Um documento que retorna estatísticas sobre o número de bytes que foram compactados e descompactados com a biblioteca zstd.

network.compression.zlib: Um documento que retorna estatísticas sobre o número de bytes que foram compactados e descompactados com a biblioteca zlib.

network.serviceExecutors: Novidades na versão 5.0.
Um documento que reporta dados sobre os executores de serviço, que executam operações para solicitações do cliente.

network.serviceExecutors.passthrough: Novidades na versão 5.0.
Um documento que reporta dados sobre os threads e clientes para o executor de serviço passthrough. O executor de serviço passthrough cria um novo thread para cada cliente e destrói o thread após o término do cliente.

network.serviceExecutors.passthrough.threadsRunning: Novidades na versão 5.0.
Número de threads em execução no executor de serviço passthrough.

network.serviceExecutors.passthrough.clientsInTotal: Novidades na versão 5.0.
Número total de clientes alocados ao executor de serviço passthrough. Um cliente pode ser alocado para o executor de serviço passthrough e não está executando solicitações atualmente.

network.serviceExecutors.passthrough.clientsRunning: Novidades na versão 5.0.
Número de clientes que atualmente usam o executor de serviço passthrough para executar solicitações.

network.serviceExecutors.passthrough.clientsWaitingForData: Novidades na versão 5.0.
Número de clientes que usam o executor de serviço passthrough que estão aguardando dados de entrada da rede.

network.serviceExecutors.fixed: Novidades na versão 5.0.
Um documento que reporta dados sobre os threads e clientes para o executor de serviço fixed. O executor de serviço fixed tem um número fixo de threads. Um thread é atribuído temporariamente a um cliente e preservado após o término do cliente.

network.serviceExecutors.fixed.threadsRunning: Novidades na versão 5.0.
Número de threads em execução no executor de serviço fixed.

network.serviceExecutors.fixed.clientsInTotal: Novidades na versão 5.0.
Número total de clientes alocados ao executor de serviço fixed. Um cliente pode ser alocado para o executor de serviço fixed e não está executando solicitações atualmente.

network.serviceExecutors.fixed.clientsRunning: Novidades na versão 5.0.
Número de clientes que atualmente usam o executor de serviço fixed para executar solicitações.

network.serviceExecutors.fixed.clientsWaitingForData: Novidades na versão 5.0.
Número de clientes que usam o executor de serviço fixed que estão aguardando dados de entrada da rede.

network.listenerProcessingTime: Novidades na versão 6.1.
Um documento que reporta o tempo total que o ouvinte do banco de dados gasta alocando solicitações de conexão de banco de dados de entrada para threads dedicados.

network.listenerProcessingTime.durationMicros: Novidades na versão 6.1.
Tempo total em microssegundos que o ouvinte do banco de dados gasta alocando solicitações de conexão do banco de dados de entrada a threads dedicados que executam operações do banco de dados.

opLatencies

Somente para instâncias `'mongod''

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

opLatencies

Um documento contendo latências de operação para a instância como um todo. Consulte o Documento latencyStats para obter uma descrição desse documento.

Somente mongod instâncias informam opLatencies.

opLatencies.reads: Estatísticas de latência para solicitações de leitura.

opLatencies.writes: Estatísticas de latência para operações de gravação.

opLatencies.commands: Estatísticas de latência para comandos de banco de dados.

opReadConcernCounters

Aviso

Removed

A partir da versão 5.0, opReadConcernCounters é substituído por readConcernCounters.

Somente para instâncias mongod

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

opReadConcernCounters

Removido na versão 5.0. Substituído por readConcernCounters.

Um documento que reporta no nível de read concern especificado pelas operações de query para a instância mongod desde sua última inicialização.

Especificadas `w`	Descrição
`"available"`	Número de operações de query que especificaram o nível de read concern `"available"`.
`"linearizable"`	Número de operações de query que especificaram o nível de read concern `"linearizable"`.
`"local"`	Número de operações de query que especificaram o nível de read concern `"local"`.
`"majority"`	Número de operações de query que especificaram o nível de read concern `"majority"`.
`"snapshot"`	Número de operações de query que especificaram o nível de read concern `"snapshot"`.
`"none"`	Número de operações de query que não especificaram um nível de read concern e, em vez disso, usaram o nível de read concern padrão.

A soma de opReadConcernCounters é igual a opcounters.query.

opWriteConcernCounters

Somente para instâncias 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

Um documento que reporta sobre os write concerns especificados pelas operações de gravação na instância mongod desde sua última inicialização.

Mais especificamente, o relatório opWriteConcernCounters no w: <value> especificado pelas operações de gravação. A opção de sinalização de diário (j) e a opção de tempo limite (wtimeout) das preocupações de gravação não afetam a contagem. A contagem é incrementada mesmo que a operação expire.

Observação

Somente disponível quando o parâmetro reportOpWriteConcernCountersInServerStatus estiver configurado para true (false por padrão).

opWriteConcernCounters.insert

Um documento que reporta o w: <value> especificado por operações de inserção para a instância mongod desde sua última inicialização:

Observação

Somente disponível quando o parâmetro reportOpWriteConcernCountersInServerStatus estiver configurado para true (false por padrão).

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

Especificadas `w`	Descrição
`"wmajority"`	Número de operações de inserção que especificaram `w: "majority"`.
`"wnum"`	Número de operações de inserção que especificaram `w: <num>`. As contagens são agrupadas pelo ''<num>'' específico.
`"wtag"`	Número de operações de inserção que especificaram `w: <tag>`. As contagens são agrupadas pelo `<tag>` específico.
`"none"`	Número de operações de inserção que não especificaram o valor `w`. Essas operações usam o valor padrão `w` de "maioria".
`"noneInfo"`	Número de operações de query sem transação que usam write concerns padrão. As métricas acompanham o uso de `cluster wide write concern` (write concern padrão global) e o write concern padrão implícito. A soma dos valores em `opWriteConcernCounters.noneInfo` deve ser igual ao valor de `opWriteConcernCounters.none`.

A soma de opWriteConcernCounters.insert é igual a opcounters.insert.

opWriteConcernCounters.update

Um documento que reporta o w: <value> especificado pelas operações de atualização para a instância mongod desde sua última inicialização:

Observação

Somente disponível quando o parâmetro reportOpWriteConcernCountersInServerStatus estiver configurado para true (false por padrão).

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

Especificadas `w`	Descrição
`"wmajority"`	Número de operações de atualização que especificaram `w: "majority"`.
`"wnum"`	Número de operações de atualização que especificaram `w: <num>`. As contagens são agrupadas pelo `<num>` específico.
`"wtag"`	Número de operações de atualização que especificaram `w: <tag>`. As contagens são agrupadas pelo `<tag>` específico.
`"none"`	Número de operações de atualização que não especificaram o valor `w`. Essas operações usam o valor padrão `w` de `1`.
`"noneInfo"`	Número de operações de query sem transação que usam write concerns padrão. As métricas acompanham o uso de `cluster wide write concern` (write concern padrão global) e o write concern padrão implícito. A soma dos valores em `opWriteConcernCounters.noneInfo` deve ser igual ao valor de `opWriteConcernCounters.none`.

A soma de opWriteConcernCounters.update é igual a opcounters.update.

opWriteConcernCounters.delete

Um documento que reporta o w: <value> especificado pelas operações de exclusão para a instância mongod desde sua última inicialização:

Observação

Somente disponível quando o parâmetro reportOpWriteConcernCountersInServerStatus estiver configurado para true (false por padrão).

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

Especificadas `w`	Descrição
`"wmajority"`	Número de operações de exclusão que especificaram `w: "majority"`.
`"wnum"`	Número de operações de exclusão que especificaram `w: <num>`. As contagens são agrupadas pelo `<num>` específico.
`"wtag"`	Número de operações de exclusão que especificaram `w: <tag>`. As contagens são agrupadas pelo `<tag>` específico.
`"none"`	Número de operações de exclusão que não especificaram o valor `w`. Essas operações usam o valor padrão `w` de `1`.
`"noneInfo"`	Número de operações de query sem transação que usam write concerns padrão. As métricas acompanham o uso de `cluster wide write concern` (write concern padrão global) e o write concern padrão implícito. A soma dos valores em `opWriteConcernCounters.noneInfo` deve ser igual ao valor de `opWriteConcernCounters.none`.

A soma de opWriteConcernCounters.delete é igual a opcounters.delete.

opcounters

Os opcounters devolvidos.* retornados são do tipo NumberLong.

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

opcounters

Um documento que reporta as operações do banco de dados por tipo desde a última vez que a instância mongod foi iniciada.

Esses números aumentarão com o tempo até a próxima reinicialização. Analise esses valores ao longo do tempo para acompanhar a utilização do banco de dados.

Observação

Os dados em opcounters tratam as operações que afetam vários documentos, como operações de inserção em massa ou de várias atualizações, como uma única operação. Consulte metrics.document para acompanhamento mais detalhado das operações no nível do documento.

Além disso, esses valores refletem as operações recebidas e aumentam mesmo quando as operações não são bem-sucedidas.

opcounters.insert

O número total de operações de inserção recebidas desde a última vez que a instância mongod foi iniciada.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.query

O número total de queries recebidas desde a última vez que a instância mongod foi iniciada.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.update

O número total de operações de atualização recebidas desde a última vez que a instância mongod foi iniciada.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.delete

O número total de operações de exclusão desde a última vez que a instância mongod foi iniciada.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.getmore

O número total de operações getMore desde a última vez que a instância mongod foi iniciada. Esse contador pode ser alto mesmo se a contagem de query for baixa. Os nós secundários enviam operações getMore como parte do processo de replicação.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.command

O número total de comandos emitidos para o banco de dados desde a última vez que a instância mongod foi iniciada.

opcounters.command conta todos os comandos , exceto os comandos de gravação: insert, update e delete.

Os opcounters devolvidos.* retornados são do tipo NumberLong.

opcounters.deprecated

Esta seção só aparece no resultado db.serverStatus() quando um dos seguintes códigos de operação obsoletos tiver sido usado:

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

Esses opcodes foram preteridos no MongoDB 5.0 e o suporte para esses opcodes foi removido no MongoDB 5.1. A partir do MongoDB 5.1, mongod recusa solicitações que usam um opcode obsoleto e incrementa o contador correspondente.

OP_QUERY é uma exceção à regra geral. mongod continua suportando solicitações hello e isMaster que usam OP_QUERY. mongod recusa quaisquer outras solicitações OP_QUERY .

Os contadores são reiniciados quando mongod começa.

opcountersRepl

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

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

opcountersRepl

Um documento que reporta as operações de replicação do banco de dados por tipo desde a última vez que a instância mongod foi iniciada.

Estes valores aparecem somente quando o host atual é um nó de um conjunto de réplicas.

Estes valores serão diferentes dos valores de opcounters por causa da forma pela qual o MongoDB serializa as operações durante a replicação. Consulte a página Replicação para obter mais informações sobre replicação.

Estes números crescerão ao longo do tempo em resposta ao uso do banco de dados até a próxima reinicialização. Analise esses valores ao longo do tempo para acompanhar a utilização do banco de dados.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.insert

O número total de operações de inserção replicadas desde a última vez que a instância mongod foi iniciada.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.query

O número total de consultas replicadas desde a última vez que a instância mongod foi iniciada.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.update

O número total de operações de atualização replicadas desde a última vez que a instância mongod foi iniciada.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.delete

O número total de operações de exclusão replicadas desde a última vez que a instância mongod foi iniciada.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.getmore

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

opcountersRepl.command

O número total de comandos replicados emitidos para o banco de dados desde a última vez que a instância mongod foi iniciada.

Os valores de opcountersRepl.* retornados são do tipo NumberLong.

oplogTruncation

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

oplogTruncation

Um documento que reporta truncamentos de oplog .

O campo só aparece quando a instância atual é membro de um conjunto de réplicas e usa o Mecanismo de armazenamento WiredTiger ou o Mecanismo de armazenamento In-Memory para implantações autogerenciadas.

Disponível no mecanismo de armazenamento WiredTiger.

oplogTruncation.totalTimeProcessingMicros

O tempo total gasto, em microssegundos, para analisar ou amostrar o oplog para determinar os pontos de truncamento do oplog.

totalTimeProcessingMicros só é significativo se a instância mongod tiver sido iniciada em arquivos de dados existentes (ou seja, não é significativo para o In-Memory Storage Engine (para implantações autogerenciadas).

Veja oplogTruncation.processingMethod

Disponível no mecanismo de armazenamento WiredTiger.

oplogTruncation.processingMethod

O método utilizado na inicialização para determinar os pontos de truncamento do oplog. O valor pode ser "sampling" ou "scanning".

processingMethod só é significativo se a instância mongod tiver sido iniciada em arquivos de dados existentes (ou seja, não é significativo para o In-Memory Storage Engine (para implantações autogerenciadas).

Disponível no mecanismo de armazenamento WiredTiger.

oplogTruncation.oplogMinRetentionHours

O período mínimo de retenção para o oplog em horas. Se o oplog tiver excedido o tamanho para oplog, o mongod apenas trunca as entradas do oplog mais antigas do que o valor de retenção configurado.

Somente visível se o mongod for um nó de um conjunto de réplicas e:

O mongod foi iniciado com a opção de linha de comando --oplogMinRetentionHours ou a opção de arquivo de configuração storage.oplogMinRetentionHours,
ou
O período mínimo de retenção foi configurado após a inicialização usando replSetResizeOplog.

oplogTruncation.totalTimeTruncatingMicros

O tempo cumulativo gasto, em microssegundos, realizando truncamentos de oplog.

Disponível no mecanismo de armazenamento WiredTiger.

oplogTruncation.truncateCount

O número cumulativo de truncamentos de oplog.

Disponível no mecanismo de armazenamento WiredTiger.

queryStats

Novidade na versão 6.0.7.

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

queryStats: Um documento que contém métricas para o estágio de agregação $queryStats .

queryStats.numEvicted: Número de query que a collection virtual $queryStats evitou devido a restrições de espaço.

queryStats.numRateLimitedRequests: Número de vezes que as estatísticas de query não foram registradas para uma query devido à limitação de taxa.

queryStats.queryStatsStoreSizeEstimateBytes: Tamanho estimado atual dos objetos na collection virtual $queryStats .

queryStats.numQueryStatsStoreWriteErrors: Número de vezes que este processo do MongoDB falhou ao armazenar uma nova chave de estatísticas de query. Geralmente, essas falhas acontecem quando a collection virtual $queryStats fica sem espaço.

queryStats.numHmacApplicationErrors: Número de vezes que esse processo do MongoDB falhou ao calcular uma chave de estatísticas de query tokenizada unidirecional quando $queryStats foi chamado com a opção transformIdentifiers .

readConcernCounters

Novidades na versão 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: Documento que comunica o nível de preocupação de leitura especificado pelas operações de query. Este documento contém os documentos readConcernCounters.nonTransactionOps e readConcernCounters.transactionOps.

readConcernCounters.nonTransactionOps: Documento que reporta o nível de read concern especificado por operações de query não transacionais executadas desde a última vez que o servidor de banco de dados foi iniciado.

readConcernCounters.nonTransactionOps.none

Número de operações de query sem transação que não especificaram um nível de read concern e, em vez disso, usaram:

o nível de read concern padrão, ou
a configuração de leitura padrão global, caso tenha sido definida pelo comando setDefaultRWConcern.

readConcernCounters.nonTransactionOps.noneInfo

O número de operações de query não transacionais que usam o read concern padrão global e um read concern padrão implícito.

A soma dos valores em readConcernCounters.nonTransactionOps.noneInfo deve ser igual ao valor de readConcernCounters.nonTransactionOps.none.

readConcernCounters.nonTransactionOps.local: Número de operações de query não transacional que especificaram o nível de read concern do "local".

readConcernCounters.nonTransactionOps.available: Número de operações de query não transacional que especificaram o nível de read concern do "available".

readConcernCounters.nonTransactionOps.majority: Número de operações de query não transacional que especificaram o nível de read concern do "majority".

readConcernCounters.nonTransactionOps.snapshot: Documento contendo operações de query sem transação que especificaram o nível de read concern do "snapshot".

readConcernCounters.nonTransactionOps.snapshot.withClusterTime: Número de operações de query sem transação que especificaram o nível de read concern "snapshot" e o tempo do cluster, que especificou um ponto no tempo.

readConcernCounters.nonTransactionOps.snapshot.withoutClusterTime: Número de operações de query sem transação que especificaram o nível de read concern do "snapshot" sem o tempo do cluster, o que significa que um ponto no tempo foi omitido e o servidor lerá o snapshot confirmado mais recente disponível para o nó.

readConcernCounters.nonTransactionOps.linearizable: Número de operações de query não transacional que especificaram o nível de read concern do "linearizable".

readConcernCounters.transactionOps: Documento que reporta o nível de read concern especificado pelas operações de query de transação realizadas desde a última vez que o servidor de banco de dados foi iniciado.

readConcernCounters.transactionOps.none: Número de operações de query de transação que não especificaram um nível de read concern e, em vez disso, usaram o nível de read concern padrão ou a configuração de read ou write concern padrão global adicionada com o comando setDefaultRWConcern.

readConcernCounters.transactionOps.noneInfo: Informações sobre o read concern padrão global e o read concern padrão implícito usados por operações de query de transação.

readConcernCounters.transactionOps.local: Número de operações de query de transação que especificaram o nível de read concern "local".

readConcernCounters.transactionOps.available: Número de operações de query de transação que especificaram o nível de read concern "available".

readConcernCounters.transactionOps.majority: Número de operações de query de transação que especificaram o nível de read concern "majority".

readConcernCounters.transactionOps.snapshot: Documento contendo operações de query de transação que especificaram o nível de read concern do "snapshot".

readConcernCounters.transactionOps.snapshot.withClusterTime: Número de operações de query de transação que especificaram o nível de read concern "snapshot" e o tempo de cluster, que especificou um ponto no tempo.

readConcernCounters.transactionOps.snapshot.withoutClusterTime: Número de operações de query de transação que especificaram o nível de read concern "snapshot" sem o tempo do cluster, o que significa que um ponto no tempo foi omitido e o servidor lerá o snapshot confirmado mais recente disponível para o nó.

readPreferenceCounters

Disponível a partir do MongoDB 6.0.11.

Disponível apenas em 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

Disponível apenas em mongod.

Documento que reporta o número de operações recebidas por este nó mongod com a preferência de leitura especificada.

O subcampo tagged refere-se a qualquer preferência de leitura transmitida com uma marcação.

readPreferenceCounters.executedOnPrimary

Disponível apenas em mongod.

Documento que conta quantas operações de preferência de leitura internas e externas o nó recebeu enquanto servia como primary.

readPreferenceCounters.executedOnSecondary

Disponível apenas em mongod.

Documento que conta quantas operações de preferência de leitura internas e externas o nó recebeu enquanto atuava como secundário.

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: Documento que reporta a configuração do conjunto de réplicas. repl só aparece quando o host atual é um conjunto de réplicas. Consulte a página Replicação para obter mais informações sobre replicação.

repl.hosts: Um conjunto de informações de porta e nome de host dos nós do conjunto de réplicas atual ("host:port").

repl.setName: Uma string com o nome do conjunto de réplicas atual. Esse valor reflete o argumento da linha de comando --replSet ou o valor replSetName no arquivo de configuração.

repl.isWritablePrimary: Um booleano que indica se o nó atual é o primary do conjunto de réplicas.

repl.secondary: Um booleano que indica se o nó atual é um nó secundário do conjunto de réplicas.

repl.primary: As informações de porta e nome do host ("host:port") do atual nó primary do conjunto de réplicas.

repl.me: As informações de porta e nome do host ("host:port") do atual conjunto de réplicas.

repl.primaryOnlyServices: Documento que contém o número e o status das instâncias de cada serviço primary ativo no servidor. Os serviços primary só podem ser iniciados quando um servidor é primary, mas podem continuar sendo executados até a conclusão depois que o servidor muda de estado.
Novidades na versão 5.0.

repl.primaryOnlyServices.ReshardingRecipientService

Documento que contém o estado e o número de instâncias do ReshardingRecipientService.

Os destinatários são os fragmentos que, como resultado da operação de refragmentação, seriam os proprietários dos partes, de acordo com a nova chave de fragmento e as zonas.

O coordenador de refragmentação instrui cada primary shard doador e destinatário a renomear a collection fragmentada temporária. A collection temporária torna-se a nova collection refragmentada.

Novidades na versão 5.0.

repl.primaryOnlyServices.RenameCollectionParticipantService

Documento que contém o estado e o número de instâncias do RenameCollectionParticipantService.

O RenameCollectionParticipantService garante que, depois que um fragmento receber uma solicitação renameCollection, ele poderá retomar a renomeação local em caso de falha do sistema.

Novidades na versão 5.0.

repl.primaryOnlyServices.ShardingDDLCoordinator

Documento que contém o estado e o número de instâncias do ShardingDDLCoordinator.

O serviço do ShardingDDLCoordinator gerencia operações de DDL para bancos de dados primários como: criar banco de dados, descartar banco de dados, renameCollection.

O ShardingDDLCoordinator garante que uma operação DDL para cada banco de dados possa acontecer em qualquer momento específico em um cluster fragmentado.

Novidades na versão 5.0.

repl.primaryOnlyServices.ReshardingDonorService

Documento que contém o estado e o número de instâncias do ReshardingDonorService.

Os doadores são os shards que possuem chunks da collection fragmentada antes da operação de renomeação ser concluída.

O coordenador de refragmentação instrui cada primary shard doador e destinatário a renomear a collection fragmentada temporária. A collection temporária torna-se a nova collection refragmentada.

Novidades na versão 5.0.

repl.rbid: Identificador de rollback. Usado para determinar se ocorreu um rollback para esta instância mongod.

repl.replicationProgress

Uma array com um documento para cada nó do conjunto de réplicas que reporta o processo de replicação para esse nó. Normalmente, este é o primary ou secundário, se estiver usando replicação encadeada.

Para incluir essa saída, você deve passar a opção repl para serverStatus, como no exemplo a seguir:

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

O conteúdo da seção repl.replicationProgress depende da origem da replicação de cada nó. Esta seção trata da operação interna e serve apenas para uso interno e diagnóstico.

repl.replicationProgress[n].rid: Um ObjectId usado como ID para os nós do conjunto de réplicas. Somente para uso interno.

repl.replicationProgress[n].optime: Informações sobre a última operação do oplog que o nó aplicou, conforme reportado deste nó.

repl.replicationProgress[n].host: O nome do host no formato [hostname]:[port] para o nó do conjunto de réplicas.

repl.replicationProgress[n].memberID: O identificador inteiro para este nó do conjunto de réplicas.

security

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

Documento que reporta:

O número de vezes que um determinado mecanismo de autenticação foi usado para autenticar na instância mongod ou mongos .
O certificado TLS/SSL da instância do mongod / mongos. (Só aparece para instâncias mongod ou mongos com suporte para TLS)

security.authentication.saslSupportedMechsReceived: Novidades na versão 5.0.
O número de vezes que um pedido hello inclui um campo hello.saslSupportedMechs válido.

security.authentication.mechanisms: Documento que reporta o número de vezes que um determinado mecanismo de autenticação foi usado para autenticar na instância mongod ou mongos. Os valores no documento distinguem entre autenticação padrão e autenticação especulativa. [1]
Observação
Os campos no documento mechanisms dependem da configuração do parâmetro authenticationMechanisms. O documento mechanisms inclui um campo para cada mecanismo de autenticação suportado por sua instância mongod ou mongos.
O exemplo a seguir mostra a forma do documento do mechanisms para uma implantação que permite somente autenticação X.509.

security.authentication.mechanisms.MONGODB-X509

Um documento que relata o número de vezes que X.509 foi usado para autenticar na instância mongod ou mongos.

Inclui o número total de tentativas de autenticação X.509 e o subconjunto dessas tentativas que foram especulativas. [1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.received: Número de tentativas de autenticação especulativa recebidas usando X.509. Inclui tentativas de autenticação especulativa bem-sucedidas e fracassadas. [1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.successful: Número de tentativas de autenticação especulativa bem-sucedidas recebidas usando X.509. [1]

security.authentication.mechanisms.MONGODB-X509.authenticate.received: Número de tentativas de autenticação bem-sucedidas e com falha recebidas usando X.509. Esse valor inclui tentativas de autenticação especulativa recebidas usando X.509.

security.authentication.mechanisms.MONGODB-X509.authenticate.successful: Número de tentativas de autenticação bem-sucedidas recebidas usando x.508. Esse valor inclui tentativas de autenticação especulativa bem-sucedidas que usaram X.509.

[1]	(1, 2, 3, 4) A autenticação especulativa minimiza o número de idas e voltas da rede durante o processo de autenticação para otimizar o desempenho.

security.SSLServerSubjectName: O nome do assunto associado ao certificado TLS/SSL da instância mongod / mongos.

security.SSLServerHasCertificateAuthority

Um booleano que é:

true quando o certificado TLS/SSL da instância do mongod / mongos está associado a uma autoridade de certificação.
false quando o certificado TLS/SSL é autoassinado.

security.SSLServerCertificateExpirationDate: A data e a hora de expiração do certificado TLS/SSL da instância mongod / mongos.

Fragmentação

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

sharding: Documento com dados sobre o cluster fragmentado. O lastSeenConfigServerOpTime está presente somente para um mongos ou um nó do fragmento, não para um servidor de configuração.

sharding.configsvrConnectionString: A connection string para os servidores de configuração.

sharding.lastSeenConfigServerOpTime

A última optime do CSRS primary que o mongos ou o nó do shard visualizou. O documento optime inclui:

ts, o timestamp da operação.
t, o term no qual a operação foi originalmente gerada na primária.

O lastSeenConfigServerOpTime está presente somente se o cluster fragmentado usar CSRS.

sharding.maxChunkSizeInBytes: O limite máximo de tamanho para uma faixa migrar. Se esse valor foi atualizado recentemente no servidor de configuração, o maxChunkSizeInBytes poderá não refletir o valor mais recente.

shardingStatistics

Ao executar em um membro de um shard:

shardingStatistics : {
   countStaleConfigErrors : Long("<num>"),
   countDonorMoveChunkStarted : Long("<num>"),
   countDonorMoveChunkCommitted : Long("<num>"),
   countDonorMoveChunkAborted : Long("<num>"),
   totalDonorMoveChunkTimeMillis : Long("<num>"),
   totalDonorChunkCloneTimeMillis : Long("<num>"),
   totalCriticalSectionCommitTimeMillis : Long("<num>"),
   totalCriticalSectionTimeMillis : Long("<num>"),
   countDocsClonedOnRecipient : Long("<num>"),
   countBytesClonedOnRecipient : Long("<num>"),
   countDocsClonedOnCatchUpOnRecipient : Long("<num>"),
   countBytesClonedOnCatchUpOnRecipient : Long("<num>"),
   countDocsClonedOnDonor : Long("<num>"),
   countRecipientMoveChunkStarted : Long("<num>"),
   countDocsDeletedByRangeDeleter : Long("<num>"),
   countDonorMoveChunkLockTimeout : Long("<num>"),
   unfinishedMigrationFromPreviousPrimary : Long("<num>"),
   chunkMigrationConcurrency : Long("<num>"),
   catalogCache : {
      numDatabaseEntries : Long("<num>"),
      numCollectionEntries : Long("<num>"),
      countStaleConfigErrors : Long("<num>"),
      totalRefreshWaitTimeMicros : Long("<num>"),
      numActiveIncrementalRefreshes : Long("<num>"),
      countIncrementalRefreshesStarted : Long("<num>"),
      numActiveFullRefreshes : Long("<num>"),
      countFullRefreshesStarted : Long("<num>"),
      countFailedRefreshes : Long("<num>")
   },
   rangeDeleterTasks : <num>,
   resharding : {
      countReshardingOperations : Long("<num>"),
      countReshardingSuccessful : Long("<num>"),
      countReshardingFailures : Long("<num>"),
      countReshardingCanceled : Long("<num>"),
      totalOperationTimeElapsedMillis : Long("<num>"),
      remainingOperationTimeEstimatedMillis : Long("<num>"),
      approxDocumentsToCopy : Long("<num>"),
      documentsCopied : Long("<num>"),
      approxBytesToCopy : Long("<num>"),
      bytesCopied : Long("<num>"),
      totalCopyTimeElapsedMillis : Long("<num>"),
      oplogEntriesFetched : Long("<num>"),
      oplogEntriesApplied : Long("<num>"),
      totalApplyTimeElapsedMillis : Long("<num>"),
      countWritesDuringCriticalSection : Long("<num>"),
      totalCriticalSectionTimeElapsedMillis : Long("<num>"),
      donorState : <num>,
      recipientState : <num>,
      coordinatorState : <num>,
      opStatus : <num>,
      lastOpEndingChunkImbalance: Long("<num>")
   }
},

Quando executado em um 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>")
   }
}

Ao executar em um servidor de configuração:

"shardingStatistics" : {
   "numShardedCollections" : Long(<num>)
}

shardingStatistics: Documento que contém métricas sobre atualização de metadados em clusters fragmentados.

shardingStatistics.countStaleConfigErrors

O número total de vezes que os threads atingem a exceção de configuração obsoleta. Como a exceção de configuração obsoleta aciona uma atualização dos metadados, esse número é aproximadamente proporcional ao número de atualizações de metadados.

Presente apenas quando executado em um shard.

shardingStatistics.countDonorMoveChunkStarted

O número total de vezes que o MongoDB inicia o comando moveChunk ou moveRange no nó primary do shard como parte do procedimento de migração de intervalo. Esse número crescente não considera se as migrações de chunk são bem-sucedidas ou não.

Presente apenas quando executado em um shard.

shardingStatistics.countDonorMoveChunkCommitted

O número total de migrações de chunk que o MongoDB comete no nó primary do shard.

A migração de chunks é executada por comandosmoveChunk e moveRange em um procedimento de migração de faixa.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.countDonorMoveChunkAborted

O número total de migrações de chunk que MongoDB aborta no nó primary do shard.

A migração de chunks é executada por comandosmoveChunk e moveRange em um procedimento de migração de faixa.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.totalDonorMoveChunkTimeMillis

Tempo cumulativo em milissegundos para mover chunks do shard atual para outro shard. Para cada migração de chunk, o tempo começa quando um comando moveRange ou moveChunk inicia e termina quando o chunk é movido para outro shard em um procedimento de migração de faixa.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.totalDonorChunkCloneTimeMillis

O tempo cumulativo, em milissegundos, que a fase de clone do procedimento de migração de faixa assume o nó primary do shard. Especificamente, para cada migração neste shard, o tempo monitorado começa com os comandos moveRange e moveChunk e termina antes que o shard de destino entre em uma fase catchup para aplicar alterações que ocorreram durante o procedimento de organização de faixa.

Presente apenas quando executado em um shard.

shardingStatistics.totalCriticalSectionCommitTimeMillis

O tempo cumulativo, em milissegundos, que a fase de atualização de metadados do procedimento de migração de faixa assume no nó primary do shard. Durante a fase de atualização de metadados, o MongoDB bloqueia todas as operações na collection.

Presente apenas quando executado em um shard.

shardingStatistics.totalCriticalSectionTimeMillis

O tempo cumulativo, em milissegundos, que a fase de captura e a fase de atualização de metadados do procedimento de migração de faixa assume o nó primary do shard.

Para calcular a duração da fase de captura, subtraia totalCriticalSectionCommitTimeMillis de totalCriticalSectionTimeMillis:

totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis

Presente apenas quando executado em um shard.

shardingStatistics.countDocsClonedOnRecipient

A contagem cumulativa, sempre crescente de documentos que o MongoDB clona no nó primary do shard do destinatário.

Presente apenas quando executado em um shard.

shardingStatistics.countBytesClonedOnRecipient

O número cumulativo de bytes que o MongoDB clona no nó primary do shard do destinatário durante o procedimento de migração de faixa.

Para detalhes sobre sincronização de dados, consulte Sincronização de dados do conjunto de réplicas.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.countDocsClonedOnCatchUpOnRecipient

O número cumulativo de documentos que o MongoDB clona no nó primary do shard destinatário durante a fase de captura do procedimento de migração de faixa.

Para detalhes sobre sincronização de dados, consulte Sincronização de dados do conjunto de réplicas.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.countBytesClonedOnCatchUpOnRecipient

O número cumulativo de bytes que o MongoDB clona no nó primary do shard destinatário durante a fase de captura do procedimento de migração de faixa.

Para detalhes sobre sincronização de dados, consulte Sincronização de dados do conjunto de réplicas.

Disponível apenas em um shard.

Disponível a partir do MongoDB 6.0.6 (e 5.0.18).

shardingStatistics.countDocsClonedOnDonor

A contagem cumulativa e sempre crescente de documentos que o MongoDB clona no nó primary do shard do doador.

Presente apenas quando executado em um shard.

shardingStatistics.countRecipientMoveChunkStarted

Contagem cumulativa e sempre crescente de partes que esse nó, atuando como o primary do shard do destinatário, começou a receber (quer a movimentação tenha sido bem-sucedida ou não).

Presente apenas quando executado em um shard.

shardingStatistics.countDocsDeletedByRangeDeleter

A contagem cumulativa e sempre crescente de documentos que o MongoDB exclui no nó primary do shard do doador durante a migração de chunks.

Presente apenas quando executado em um shard.

Alterado na versão 7.1.

shardingStatistics.countDonorMoveChunkLockTimeout

A contagem cumulativa e sempre crescente de migrações de chunk que o MongoDB cancela no nó primary do shard do doador devido ao tempo limite de aquisição.

Presente apenas quando executado em um shard.

shardingStatistics.unfinishedMigrationFromPreviousPrimary

O número de migrações não concluídas deixadas pelo primary anterior após uma eleição. Esse valor só é atualizado depois que o mongod recém-eleito conclui a transição para o primary.

Presente apenas quando executado em um shard.

shardingStatistics.chunkMigrationConcurrency

O número de threads no shard de origem e o shard de recebimento para executar operações de migração de chunks .

Presente apenas quando executado em um shard.

Disponível a partir do MongoDB 6.3 (e 6.0.5 e 5.0.15)

shardingStatistics.catalogCache: Documento com estatísticas sobre o cache de informações de roteamento do cluster.

shardingStatistics.catalogCache.numDatabaseEntries: O número total de entradas de banco de dados que estão atualmente no cache do catálogo.

shardingStatistics.catalogCache.numCollectionEntries: O número total de entradas de collection (em todos os bancos de dados) que estão atualmente no cache do catálogo.

shardingStatistics.catalogCache.countStaleConfigErrors: O número total de vezes que os threads atingem a exceção de configuração obsoleta. Uma exceção de configuração obsoleta aciona uma atualização dos metadados.

shardingStatistics.catalogCache.totalRefreshWaitTimeMicros: O tempo cumulativo, em microssegundos, que os threads tiveram que esperar por uma atualização dos metadados.

shardingStatistics.catalogCache.numActiveIncrementalRefreshes: O número de atualizações de cache de catálogo incremental que estão atualmente esperando para serem concluídas.

shardingStatistics.countIncrementalRefreshesStarted: O número cumulativo de atualizações incrementais que começaram.

shardingStatistics.catalogCache.numActiveFullRefreshes: O número de atualizações completas do cache do catálogo que estão aguardando para serem concluídas no momento.

shardingStatistics.catalogCache.countFullRefreshesStarted: O número cumulativo de atualizações completas que começaram.

shardingStatistics.catalogCache.countFailedRefreshes: O número cumulativo de atualizações completas ou incrementais que falharam.

shardingStatistics.rangeDeleterTasks

O total atual das tarefas de exclusão de intervalo de chunks em fila que estão prontas para serem executadas ou estão sendo executadas como parte do procedimento de migração de faixa.

Inspecione os documentos na collection config.rangeDeletions para obter informações sobre as faixas de chunk pendentes de exclusão de um shard após uma migração de chunk.

Presente somente quando executado em um nó do shard.

shardingStatistics.resharding

Documento com estatísticas sobre operações de refragmentação.

Cada shard retorna suas próprias estatísticas de operação de refragmentação. Se um shard não estiver envolvido em uma operação de refragmentação, esse shard não conterá estatísticas sobre a operação de refragmentação.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.countReshardingOperations

A soma de countReshardingSuccessful, countReshardingFailures e countReshardingCanceled. A soma é ainda incrementada em 1 se uma operação de refragmentação tiver sido iniciada, mas ainda não tiver sido concluída. A soma é definida como 0 quando mongod é iniciado ou reiniciado.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.countReshardingSuccessful

Número de operações de refragmentação bem-sucedidas. O número é configurado para 0 quando mongod é iniciado ou reiniciado.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.countReshardingFailures

Número de operações de refragmentação falhadas. O número é configurado para 0 quando mongod é iniciado ou reiniciado.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.countReshardingCanceled

Número de operações de refragmentação canceladas. O número é configurado para 0 quando mongod é iniciado ou reiniciado.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.totalOperationTimeElapsedMillis

Tempo total decorrido, em milissegundos, para a operação de refragmentação atual. O tempo é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.remainingOperationTimeEstimatedMillis

Tempo restante estimado, em milissegundos, para a operação de refragmentação atual. O tempo é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.approxDocumentsToCopy

Número aproximado de documentos a serem copiados de shards do doador para shards do destinatário para a operação de refragmentação atual . O número é uma estimativa que é definida quando a operação de refragmentação é iniciada e o número não é atualizado à medida que a operação avança. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.documentsCopied

Número de documentos copiados de shards de doadores para shards de destinatários para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.approxBytesToCopy

Número aproximado de bytes a serem copiados dos shards do doador para os shards do destinatário para a operação de refragmentação atual . O número é uma estimativa que é definida quando a operação de refragmentação é iniciada e o número não é atualizado à medida que a operação avança. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.bytesCopied

Número de bytes copiados dos shards do doador para os shards do destinatário para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.totalCopyTimeElapsedMillis

Tempo total decorrido, em milissegundos, para tarefas de cópia de dados contínuas de fragmentos de doadores para fragmentos de receptores para a operação de refragmentação atual. O tempo é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.oplogEntriesFetched

Número de entradas obtidas do oplog para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

shardingStatistics.resharding.oplogEntriesApplied

Número de entradas aplicadas ao oplog para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.totalApplyTimeElapsedMillis

Tempo total decorrido, em milissegundos, para a etapa de aplicação da operação de refragmentação atual. Na etapa de aplicação, os shards do destinatário modificam seus dados com base nas novas gravações recebidas dos shards do doador. O tempo é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.countWritesDuringCriticalSection

Número de gravações realizadas na seção crítica para a operação de refragmentação atual. A seção crítica evita novas gravações recebidas na collection sendo refragmentada. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.totalCriticalSectionTimeElapsedMillis

Tempo total decorrido, em milissegundos, para a seção crítica da operação de refragmentação atual. A seção crítica evita novas gravações recebidas na collection sendo refragmentada. O tempo é definido como 0 quando uma nova operação de refragmentação é iniciada.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.donorState

Estado do shard do doador para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Número retornado	Significado	Descrição
0	`unused`	O shard não é um doador na operação de refragmentação atual.
1	`preparing-to-donate`	O shard do doador está se preparando para doar dados para os shards do destinatário.
2	`donating-initial-data`	O shard do doador está doando dados para os shards do destinatário.
3	`donating-oplog-entries`	O shard do doador está doando entradas do oplog para os shards do destinatário.
4	`preparing-to-block-writes`	O shard do doador está prestes a impedir a entrada de novas operações de gravação na collection que está sendo refragmentada.
5	`error`	Ocorreu um erro durante a operação de refragmentação.
6	`blocking-writes`	O shard do doador está evitando novas operações de escrita recebidas e o shard do doador notificou todos os shards do destinatário de que novas gravações recebidas são evitadas.
7	`done`	O shard do doador descartou a collection fragmentada antiga e a operação de refragmentação foi concluída.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.recipientState

Estado do shard do destinatário para a operação de refragmentação atual. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Número retornado	Significado	Descrição
0	`unused`	O shard não é um destinatário na operação de refragmentação atual.
1	`awaiting-fetch-timestamp`	O shard do destinatário está esperando que os shards do doador estejam preparados para doar os dados
2	`creating-collection`	O shard do destinatário está criando a nova collection fragmentada.
3	`cloning`	O shard do destinatário está recebendo dados dos shards do doador.
4	`applying`	O shard do destinatário está aplicando entradas do oplog para modificar sua cópia dos dados com base nas novas gravações recebidas dos shards do doador.
5	`error`	Ocorreu um erro durante a operação de refragmentação.
6	`strict-consistency`	O shard do destinatário tem todas as alterações de dados armazenadas em uma collection temporária.
7	`done`	A operação de refragmentação foi concluída.

Presente apenas quando executado em um shard ou servidor de configuração. Retorna 0 em um servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.numHostsTargeted

Indica o número de shards direcionados para CRUD operações e comandos de aggregation. Quando uma operação CRUD ou comando de aggregation é executado, as seguintes métricas serão incrementadas.

Nome	Descrição
`allShards`	Um comando teve como alvo todos os shards
`manyShards`	Um comando direcionado a mais de um shard
`oneShard`	Um comando destinado a um shard
`unsharded`	Um comando foi executado em uma collection não fragmentada

Observação

A execução do comando serverStatus em mongos fornecerá informações sobre o CRUD e as operações de agregação que são executadas em um cluster fragmentado.

As operações de vários fragmentos podem ser de dispersão ou específicas do fragmento. As operações de dispersão em vários fragmentos podem consumir mais recursos. Ao usar as métricas shardingStatistics.numHostsTargeted, você pode ajustar as queries de agregação que são executadas em um cluster fragmentado.

shardingStatistics.numShardedCollections

Indica o número de collections fragmentadas no cluster.

Presente somente quando executado em um servidor de configuração.

shardingStatistics.resharding.coordinatorState

Estado do coordenador de refragmentação para a operação de refragmentação atual. O coordenador de refragmentação é um thread que é executado no servidor de configuração principal. O número é definido como 0 quando uma nova operação de refragmentação é iniciada.

Número retornado	Significado	Descrição
0	`unused`	O shard não é o coordenador na operação de refragmentação atual.
1	`initializing`	O coordenador de refragmentação inseriu o documento do coordenador no `config.reshardingOperations` e adicionou o `reshardingFields` à entrada `config.collections` para a collection original.
2	`preparing-to-donate`	O coordenador de refragmentação criou uma entrada `config.collections` para a collection de refragmentação temporária. inseriu entradas em `config.chunks` para faixas baseadas na nova chave de shard. inseriu entradas em `config.tags` para quaisquer zonas associadas à nova chave de shard. O coordenador informa aos shards participantes para que iniciem a operação de refragmentação. O coordenador então aguarda até que todos os shards doadores tenham escolhido um `minFetchTimestamp` e estejam prontos para doar.
3	`cloning`	O coordenador de refragmentação informa os shards do doador para doar dados aos shards do destinatário. O coordenador espera que todos os destinatários terminem de clonar os dados do doador.
4	`applying`	O coordenador de refragmentação informa aos shards do destinatário que modifiquem suas cópias dos dados com base nas novas gravações recebidas dos shards do doador. O coordenador espera que todos os destinatários terminem de aplicar as entradas do oplog.
5	`blocking-writes`	O coordenador de refragmentação informa os shards doadores para impedir novas operações de gravação de entrada na collection que está sendo redistribuída. O coordenador então espera que todos os destinatários tenham todas as alterações de dados.
6	`aborting`	Ocorreu um erro irrecuperável durante a operação de refragmentação ou o comando `abortReshardCollection` (ou o método `sh.abortReshardCollection()`) foi executado.
6	`committing`	O coordenador de refragmentação remove a entrada `config.collections` para a collection de refragmentação temporária. O coordenador então adiciona o `recipientFields` à entrada da collection de origem.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.opStatus

Status da operação de refragmentação atual.

Número retornado	Descrição
-1	A operação de refragmentação não está em andamento.
0	Operação de refragmentação bem-sucedida.
1	Falha na operação de refragmentação.
2	Operação de refragmentação cancelada.

Presente apenas quando executado em um shard ou servidor de configuração.

Novidades na versão 5.0.

shardingStatistics.resharding.lastOpEndingChunkImbalance

Este campo contém a diferença numérica mais alta para (maxNumChunksInShard - minNumChunksInShard) entre todas as zonas da collection que foi processada pela operação de refragmentaçãomais recente.

Consulte Tamanho da faixa.

Atualizado apenas em servidores de configuração.

Novidades na versão 5.0.

shardedIndexConsistency

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

shardedIndexConsistency

Disponível apenas em instâncias do servidor de configuração.

Documento que retorna resultados de verificações de consistência do índice para collections fragmentadas.

As métricas retornadas são significativas somente quando executadas no primário do conjunto de réplicas do servidor de configuração para um cluster fragmentado.

Dica

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

shardedIndexConsistency.numShardedCollectionsWithInconsistentIndexes

Disponível apenas em instâncias do servidor de configuração.

Número de collections fragmentadas cujos índices são inconsistentes nos shards. Uma collection fragmentada terá um índice inconsistente se a collection não tiver exatamente os mesmos índices (inclusive as opções de índice) em cada shard que contiver chunks para a collection.

Para investigar se uma collection fragmentada tem índices inconsistentes, consulte Encontrar índices inconsistentes em todos os shards.

As métricas retornadas são significativas somente quando executadas no primário do conjunto de réplicas do servidor de configuração para um cluster fragmentado.

Dica

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

storageEngine

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

storageEngine: Documento com dados sobre o mecanismo de armazenamento atual.

storageEngine.name: O nome do mecanismo de armazenamento atual.

storageEngine.supportsCommittedReads: Um booleano que indica se o mecanismo de armazenamento permite "majority" read concern.

storageEngine.persistent: Um booleano que indica se o mecanismo de armazenamento persiste ou não dados para o disco.

transações

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

Quando executado em um mongod, um documento com dados sobre as transações e retryable writes .

Ao executar em um mongos, um documento com dados sobre as transações executadas na instância.

transactions.retriedCommandsCount

Disponível apenas em mongod.

O número total de novas tentativas que foram recebidas depois que o comando de gravação com possibilidade de nova tentativa correspondente já foi confirmado. Ou seja, uma tentativa de gravação repetitiva é tentada mesmo que a gravação tenha sido bem-sucedida anteriormente e tenha um registro associado para a transação e a sessão na collection config.transactions, como quando a resposta de gravação inicial para o cliente é perdida.

Observação

O MongoDB não reexecuta as gravações comprometidas.

O total está em todas as sessões.

O total não inclui retryable writes que possam acontecer internamente como parte de uma migração de chunk.

transactions.retriedStatementsCount

Disponível apenas em mongod.

O número total de instruções de gravação associadas aos comandos repetidos em transactions.retriedCommandsCount.

Observação

O MongoDB não reexecuta as gravações comprometidas.

O total não inclui retryable writes que possam acontecer internamente como parte de uma migração de chunk.

transactions.transactionsCollectionWriteCount

Disponível apenas em mongod.

O número total de gravações na collection config.transactions, acionado quando uma nova instrução de gravação que pode ser repetida é confirmada.

Para comandos de atualização e exclusão, como somente as operações de documento único podem ser tentadas novamente, há uma gravação por declaração.

Para operações de inserção, há uma gravação por lote de documentos inseridos, exceto quando uma falha leva a que cada documento seja inserido separadamente.

O total inclui gravações na collection config.transactions de um servidor que ocorrem como parte de uma migração.

transactions.currentActive

Disponível no mongod e no mongos.

O número total de transações abertas que atualmente executam um comando.

transactions.currentInactive

Disponível no mongod e no mongos.

O número total de transações abertas que atualmente não executam um comando.

transactions.currentOpen

Disponível no mongod e no mongos.

O número total de transações abertas. Uma transação é aberta quando o primeiro comando é executado como parte dessa transação e permanece aberta até que a transação seja confirmada ou abortada.

transactions.totalAborted

Para o mongod, o número total de transações abortadas nesta instância desde sua última inicialização.

Para mongos, o número total de transações abortadas por essa instância desde sua última inicialização.

transactions.totalCommitted

Para o mongod, o número total de transações com commit na instância desde a última inicialização.

Para mongos, o número total de transações com commit por essa instância desde sua última inicialização.

transactions.totalStarted

Por mongod, o número total de transações iniciadas nessa instância desde sua última inicialização.

Por mongos, o número total de transações iniciadas nessa instância desde sua última inicialização.

transactions.abortCause

Disponível apenas no mongos.

Distribuição do transactions.totalAborted por causa. Se um cliente emitir um abortTransaction explícito, a causa será listada como abort.

Por exemplo:

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

transactions.totalContactedParticipants

Disponível apenas no mongos.

O número total de shards contatados para todas as transações iniciadas por este mongos desde sua última inicialização.

O número de shards contatados durante os processos de transação pode incluir shards que podem não ser incluídos como parte do commit.

transactions.totalParticipantsAtCommit

Disponível apenas no mongos.

Número total de shards envolvidos no commit de todas as transações iniciadas por este mongos desde a última inicialização.

transactions.totalRequestsTargeted

Disponível apenas no mongos.

Número total de solicitações de rede direcionadas por mongos como parte de suas transações.

transactions.commitTypes

Disponível apenas no mongos.

Detalhamento dos commits por tipos. Por exemplo:

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

Os tipos de commit são:

Tipo	Descrição
`noShards`	Commits de transações que não contataram nenhum shard.
`singleShard`	Commits de transações que afetaram um único shard.
`singleWriteShard`	Commits de transações que contataram vários shards, mas cujas operações de gravação afetaram um único shard.
`readOnly`	Commits de transações que envolvem apenas operações de leitura.
`twoPhaseCommit`	Commits de transações que incluíram gravações em vários shards
`recoverWithToken`	Commits que recuperaram o resultado de transações de outra instância ou depois que essa instância foi reiniciada.

Para cada tipo de commit, o comando retorna as seguintes métricas:

Métricas	Descrição
`initiated`	Número total de vezes que commits desse tipo foram iniciados.
`successful`	Número total de vezes que commits desse tipo foram bem-sucedidos.
`successfulDurationMicros`	Tempo total, em microssegundos, gasto por commits bem-sucedidos desse tipo.

transactions.totalPrepared

Disponível apenas em mongod.

O número total de transações em estado preparado neste servidor desde a última inicialização do processo mongod.

transactions.totalPreparedThenCommitted

Disponível apenas em mongod.

O número total de transações que foram preparadas e confirmadas neste servidor desde a última inicialização do processo mongod.

transactions.totalPreparedThenAborted

Disponível apenas em mongod.

O número total de transações que foram preparadas e abortadas neste servidor desde a última inicialização do processo mongod.

transactions.currentPrepared

Disponível apenas em mongod.

O número atual de transações no estado preparado neste servidor.

transactions.lastCommittedTransaction

Disponível apenas em mongod.

Os detalhes da última transação com commit quando o mongod é primary.

Quando retornado de um secundário, lastCommittedTransaction retorna os detalhes da última transação enviada quando esse secundário era um primário.

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

Métricas	Descrição
`operationCount`	O número de operações de gravação na transação.
`oplogOperationBytes`	O tamanho da entrada ou entradas correspondentes do oplog para a transação. [2]
`writeConcern`	O write concern usado para a transação.

[2]	O MongoDB cria quantas entradas de oplog forem necessárias para encapsular todas as operações de gravação em uma transação. Consulte Limite de tamanho do oplog para obter detalhes.

transportSecurity

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

transportSecurity.<version>: O número cumulativo de conexões TLS <version> que foram feitas para esta instância mongod ou mongos. O valor é redefinido na reinicialização.

watchdog

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

Observação

A seção watchdog só estará presente se o Storage Node Watchdog estiver habilitado.

watchdog: Documento que reporta o status do Storage Node Watchdog.

watchdog.checkGeneration: O número de vezes que os diretórios foram verificados desde a inicialização. Os diretórios são verificados várias vezes a cada monitoringPeriod.

watchdog.monitorGeneration: O número de vezes que o status de todos os sistemas de arquivos usados pelo mongod foi examinado. Incrementado uma vez a cada monitoringPeriod.

watchdog.monitorPeriod: O valor definido por watchdogPeriodSeconds. Esse é o período entre as verificações de status.

wiredTiger

wiredTiger As informações só aparecem se estiver usando o mecanismo de armazenamento WiredTiger. Algumas das estatísticas chegam para o servidor.

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

Observação

A lista a seguir não é definitiva.

wiredTiger.uri: Uma string. Para uso interno do MongoDB.

wiredTiger.async: Documento que retorna estatísticas relacionadas à API de operações assíncronas. Não é usado pelo MongoDB.

wiredTiger.block-manager: Documento que retorna estatísticas sobre as operações do gerenciador de chunks.

wiredTiger.cache

Documento que retorna estatísticas sobre o cache e remoções de página do cache.

Veja a seguir uma descrição de algumas das estatísticas da chave wiredTiger.cache:

wiredTiger.cache.maximum bytes configured: Tamanho máximo do cache.

wiredTiger.cache.bytes currently in the cache: Tamanho em bytes dos dados atualmente em cache. Esse valor não deve ser maior que o valor maximum bytes configured .

wiredTiger.cache.unmodified pages evicted: Principais estatísticas para remoção de páginas.

wiredTiger.cache.tracked dirty bytes in the cache: Tamanho em bytes dos dados sujos no cache. Esse valor deve ser menor que o valor de bytes currently in the cache.

wiredTiger.cache.pages read into cache: Número de páginas lidas no cache. wiredTiger.cache.pages read into cache com wiredTiger.cache.pages written from cache pode fornecer uma visão geral da atividade de E/S.

wiredTiger.cache.pages written from cache: Número de páginas gravadas no cache. wiredTiger.cache.pages written from cache com wiredTiger.cache.pages read into cache pode fornecer uma visão geral da atividade de E/S.

Para ajustar o tamanho do cache interno do WiredTiger, consulte storage.wiredTiger.engineConfig.cacheSizeGB e --wiredTigerCacheSizeGB. Evite aumentar o tamanho do cache interno do WiredTiger acima do valor padrão.

wiredTiger.connection: Documento que retorna estatísticas relacionadas às conexões WiredTiger.

wiredTiger.cursor: Documento que retorna estatísticas no cursor do WiredTiger.

wiredTiger.data-handle: Documento que retorna estatísticas sobre identificadores e varreduras de dados.

wiredTiger.log: Documento que retorna estatísticas sobre o registro de gravação adiantado do WiredTiger (ou seja, o diário).
Dica
Journaling e o WiredTiger Storage Engine

wiredTiger.reconciliation: Documento que retorna estatísticas sobre o processo de reconciliação.

wiredTiger.session: Documento que retorna a contagem de cursor aberto e a contagem de sessão aberta para a sessão.

wiredTiger.thread-yield: Documento que retorna estatísticas sobre os rendimentos durante as aquisições de páginas.

wiredTiger.transaction

Documento que retorna estatísticas sobre checkpoints de transação e operações.

wiredTiger.transaction.transaction checkpoint most recent time (msecs): Quantidade de tempo, em milissegundos, para criar o checkpoint mais recente. Um aumento nesse valor sob carga de gravação constante pode indicar saturação no subsistema de E/S.

wiredTiger.concurrentTransactions

Documento que retorna informações sobre o número de transação de escrita simultâneas permitidas no storage engine WiredTiger. Essas configurações são específicas do MongoDB.

Para alterar as configurações das transações de leitura e gravação simultâneas, consulte storageEngineConcurrentReadTransactions e storageEngineConcurrentWriteTransactions.

writeBacksQueued

writeBacksQueued : <boolean>,

writeBacksQueued: Um booleano que indica se há operações de uma instância mongos enfileirada para tentar novamente. Normalmente, esse valor é falso. Consulte também writeBacks.

Voltar

perfil

shardConnPoolStats

Definição

Compatibilidade

Observação

Sintaxe

Dica

Comportamento

Inicialização

Incluir mirroredReads

Incluir latchAnalysis

Incluir latchAnalysis

tcmalloc Alterar verbosidade de

Saída

Observação

asserts

bucketCatalog

catalogStats

conexões

Observação

Observação

defaultRWConcern

electionMetrics

Dica

Dica

extra_info

flowControl

globalLock

hedgingMetrics

indexBulkBuilder

indexStats

Informações da instância

latchAnalysis

locks

logicalSessionRecordCache

Dica

Dica

mem

metrics

Observação

Dica

Observação

Observação

Observação

Observação

mirroredReads

Dica

Dica

network

opLatencies

opReadConcernCounters

Aviso

Removed

opWriteConcernCounters

Observação

Observação

Observação

Observação

opcounters

Observação

opcountersRepl

oplogTruncation

queryStats

readConcernCounters

readPreferenceCounters

repl

security

Observação

Fragmentação

shardingStatistics

Observação

shardedIndexConsistency

Dica

Dica

storageEngine

transações

Observação

Observação

transportSecurity

watchdog

Observação

wiredTiger

Incluir `mirroredReads`

Incluir `latchAnalysis`

Incluir `latchAnalysis`

`tcmalloc` Alterar verbosidade de