ApsaraDB for MongoDB:Métricas Opcounters e Repl Opcounters

Operações monitoradas

Operações de múltiplos documentos — como updateMany que afeta quatro documentos — são contabilizadas como uma única operação em Opcounters. Se precisar de granularidade no nível de documento, consulte o FAQ abaixo.

Operações internas

Além do tráfego do cliente, Opcounters também registra operações internas. A tabela abaixo explica o que aciona cada contador na ausência de atividade do cliente.

Operações monitoradas

Operações adicionais monitoradas em comparação com Opcounters

Repl Opcounters registra várias operações que Opcounters não registra:

• Operações de insert e update acionadas por descarregamentos de sessão

• Operações de delete causadas por índices TTL

• Exclusões de documentos órfãos (tipicamente com um atraso após a migração de chunk)

• Escritas em coleções de sistema, como escritas retryable para config.transactions. Para detalhes, consulte Retryable Writes.

O ApsaraDB for MongoDB serializa dados de formas diferentes durante a replicação primário/secundário. Portanto, o valor da métrica Repl Opcounters para um nó secundário em uma instância é diferente do valor para o nó primário na instância.

Por que o valor de Repl Opcounters em um nó secundário é muito maior que o valor de Opcounters no nó primário?

Operações de múltiplos documentos são registradas como uma única operação em Opcounters no nó primário, mas a replicação aplica cada alteração de documento individualmente. Um único updateMany que modifica quatro documentos incrementa opcounters.update em 1 no primário, mas incrementa opcountersRepl.update em 4 no secundário.

Exemplo — execute updateMany que modifica quatro documentos:

1. Antes da atualização, verifique os contadores:

   > db.serverStatus().opcounters.update
   NumberLong(13)
   
   > db.serverStatus().opcountersRepl.update
   NumberLong(11)

2. Execute a atualização em lote:

   > db.coll.updateMany({x:2},{$set:{x:3}})
   { "acknowledged" : true, "matchedCount" : 4, "modifiedCount" : 4 }

3. Verifique os contadores novamente:

   > db.serverStatus().opcounters.update
   NumberLong(14)   // +1 (one operation)
   
   > db.serverStatus().opcountersRepl.update
   NumberLong(15)   // +4 (four documents replicated individually)

Por que Repl Opcounters mostra muitas operações de insert quando eu apenas executo operações de update?

Isso acontece quando {upsert: true} é usado e o documento de destino não existe. O MongoDB converte a atualização malsucedida em um insert, registra-a como um insert no oplog e replica-a para nós secundários como um insert. Portanto, opcountersRepl.insert é incrementado em vez de opcountersRepl.update.

Exemplo — execute updateOne com {upsert: true} em um documento inexistente:

1. Antes da atualização:

   > db.serverStatus().opcounters
   { "insert": NumberLong(1516), "update": NumberLong(33), ... }
   
   > db.serverStatus().opcountersRepl
   { "insert": NumberLong(1539), "update": NumberLong(24), ... }

2. Execute o upsert:

   > db.coll.updateOne({x:"a"}, {$set:{x:"b"}}, {upsert:true})
   { "acknowledged": true, "matchedCount": 0, "modifiedCount": 0, "upsertedId": ObjectId("64bf72b829907f52b4b363ea") }

3. Após a atualização — o primário registra um update (+1), o secundário registra um insert (+1):

   > db.serverStatus().opcounters
   { "insert": NumberLong(1516), "update": NumberLong(34), ... }
   
   > db.serverStatus().opcountersRepl
   { "insert": NumberLong(1540), "update": NumberLong(24), ... }

Por que a contagem de update no primário é muito maior que a contagem de update replicada em nós secundários?

Atualizações no-op — em que o novo valor corresponde ao valor existente — são registradas em Opcounters no primário, mas não são escritas no oplog e, portanto, não são replicadas.

Exemplo — execute updateMany que não corresponde a nenhum documento:

1. Antes da atualização: update do primário = 34, update do secundário = 24.

2. Execute uma atualização sem documentos correspondentes:

   > db.coll.updateMany({x:"ab"},{$set:{x:"cd"}})
   { "acknowledged": true, "matchedCount": 0, "modifiedCount": 0 }

3. Após a atualização: update do primário = 35 (+1), update do secundário permanece em 24.

   > db.serverStatus().opcounters
   { "update": NumberLong(35), ... }   // +1
   
   > db.serverStatus().opcountersRepl
   { "update": NumberLong(24), ... }   // unchanged

Por que vejo operações em Opcounters quando nenhum tráfego de cliente está ativo?

O ApsaraDB for MongoDB gera operações em segundo plano continuamente, mesmo sem atividade do cliente:

• Manutenção interna: heartbeats do replica set, sincronização primário/secundário e descarregamentos de sessão

• Operações de gerenciamento: detecção, monitoramento e verificações de saúde do plano de controle

Por que os valores de Opcounters diferem das contagens derivadas do campo op do oplog?

No oplog, o campo op usa estes valores:

kCommand: "c"
kInsert:  "i"
kUpdate:  "u"
kDelete:  "d"
kNoop:    "n"

Todas as operações dentro de uma transação são registradas com op: "c". As operações individuais de insert, update e delete são armazenadas em o.applyOps, não como entradas de nível superior no oplog. Agregar apenas por op omite escritas transacionadas.

Para contabilizar um tipo de operação específico dentro de transações, conecte-se à instância usando o mongo shell e execute:

use local
db.oplog.rs.aggregate([
  {$match: {
    "op": "c",
    "ts": {"$gte": Timestamp(1733849400, 0)},
    "o.applyOps": {$exists: true},
    "o.applyOps.0.op": "u"
  }},
  {$count: "count"}
])

Parâmetros:

Exemplo — duas operações insertOne dentro de uma transação incrementam opcounters.insert de 4 para 6:

1. Antes da transação:

   > db.serverStatus().opcounters
   { "insert": NumberLong(4), "query": NumberLong(6723), "update": NumberLong(110489), ... }

2. Execute a transação:

   session = db.getMongo().startSession({ readPreference: { mode: "primary" } });
   coll1 = session.getDatabase("mydb1").foo;
   coll2 = session.getDatabase("mydb2").bar;
   session.startTransaction({ readConcern: { level: "local" }, writeConcern: { w: "majority" } });
   try {
     coll1.insertOne({ abc: 1 });
     coll2.insertOne({ xyz: 999 });
   } catch (error) {
     session.abortTransaction();
     throw error;
   }
   session.commitTransaction();
   session.endSession();

3. Após a transação — a contagem de insert é 6 (+2):

   > db.serverStatus().opcounters
   { "insert": NumberLong(6), ... }

Para visualizar métricas de transação diretamente no console, consulte a métrica Transaction operations no módulo Monitoring Data. Para obter mais informações, consulte Monitoring items and metrics.