ApsaraDB for MongoDB:Métricas Opcounters y Repl Opcounters

¿Por qué los valores de Repl Opcounters en secundarios son mayores que los de Opcounters en primarios?

Las operaciones que afectan a varios documentos, como una inserción por lotes o una actualización o eliminación de múltiples documentos, se cuentan como una sola operación en el nodo primario. Cuando una operación que afecta a varios documentos se replica en los nodos secundarios, el proceso de replicación se basa en documentos. Como resultado, el valor de Repl Opcounters en un nodo secundario puede ser mayor que el valor de Opcounters en el nodo primario.

El siguiente ejemplo muestra este comportamiento:

1. Antes de la actualización, compruebe los contadores de operaciones.

   • El contador update de Opcounters en el nodo primario es 13.

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

   • El contador update de Repl Opcounters en el nodo secundario es 11.

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

2. Ejecute una actualización por lotes en el nodo primario. El campo modifiedCount devuelto indica que esta actualización por lotes modificó cuatro documentos.

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

3. Después de la actualización, compruebe nuevamente los contadores de operaciones.

   • El contador update de Opcounters en el nodo primario ahora es 14.

     > db.serverStatus().opcounters.update
     NumberLong(14)

   • El contador update de Repl Opcounters en el nodo secundario ahora es 15.

     > db.serverStatus().opcountersRepl.update
     NumberLong(15)

¿Por qué Repl Opcounters muestra inserciones durante las actualizaciones?

Esto puede deberse a que su operación de actualización especifica la opción {upsert:true}. Si el documento que desea update no existe, MongoDB convierte la operación en una operación insert. Si el oplog registra una operación insert, la replicación también aplica una operación insert en el nodo secundario. Por lo tanto, Repl Opcounters registra la operación insert correspondiente.

El siguiente ejemplo muestra este comportamiento:

1. Antes de la actualización, compruebe los contadores de operaciones.

   • En el nodo primario, Opcounters muestra update: 33 e insert: 1516.

     > db.serverStatus().opcounters
     {
       "insert" : NumberLong(1516),
       "query" : NumberLong(70),
       "update" : NumberLong(33),
       "delete" : NumberLong(1043),
       "getmore" : NumberLong(2662),
       "command" : NumberLong(4000)
     }

   • En el nodo secundario, Repl Opcounters muestra update: 24 e insert: 1539.

     > db.serverStatus().opcountersRepl
     {
       "insert" : NumberLong(1539),
       "query" : NumberLong(0),
       "update" : NumberLong(24),
       "delete" : NumberLong(6),
       "getmore" : NumberLong(0),
       "command" : NumberLong(26)
     }

2. En el nodo primario, ejecute una operación de actualización con la opción {upsert:true}. El campo upsertedId devuelto indica que se insertó un documento.

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

3. Después de la actualización, compruebe nuevamente los contadores de operaciones.

   • En el nodo primario, el contador update de Opcounters ahora es 34 y el contador insert sigue siendo 1516.

     > db.serverStatus().opcounters
     {
       "insert" : NumberLong(1516),
       "query" : NumberLong(70),
       "update" : NumberLong(34),   // Note the change in this counter.
       "delete" : NumberLong(1043),
       "getmore" : NumberLong(2706),
       "command" : NumberLong(4286)
     }

   • En el nodo secundario, el contador insert de Repl Opcounters ahora es 1540 y el contador update sigue siendo 24.

     > db.serverStatus().opcountersRepl
     {
       "insert" : NumberLong(1540), // Note the change in this counter.
       "query" : NumberLong(0),
       "update" : NumberLong(24),
       "delete" : NumberLong(6),
       "getmore" : NumberLong(0),
       "command" : NumberLong(26)
     }

¿Por qué el recuento de actualizaciones en el primario es mayor que en el secundario?

Esto puede deberse a que la lógica de su aplicación incluye operaciones update repetitivas. Si una operación update repetida no cambia realmente ningún dato, no se replica en los nodos secundarios. Por lo tanto, la cantidad de operaciones update registradas en los nodos secundarios es menor.

El siguiente ejemplo muestra este comportamiento:

1. Antes de la actualización, compruebe los contadores de operaciones.

   • El recuento de update en Opcounters del nodo primario es 34.

     > db.serverStatus().opcounters
     {
       "insert" : NumberLong(1516),
       "query" : NumberLong(70),
       "update" : NumberLong(34),
       "delete" : NumberLong(1043),
       "getmore" : NumberLong(2760),
       "command" : NumberLong(4609)
     }

   • El recuento de update en Repl Opcounters del nodo secundario es 24.

     > db.serverStatus().opcountersRepl
     {
       "insert" : NumberLong(1540),
       "query" : NumberLong(0),
       "update" : NumberLong(24),
       "delete" : NumberLong(6),
       "getmore" : NumberLong(0),
       "command" : NumberLong(26)
     }

2. Ejecute una operación de actualización en el nodo primario. La información devuelta indica que no se produjo ninguna modificación real.

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

3. Después de la actualización, compruebe nuevamente los contadores de operaciones.

   • El recuento de update en Opcounters del nodo primario ahora es 35.

     > db.serverStatus().opcounters
     {
       "insert" : NumberLong(1516),
       "query" : NumberLong(70),
       "update" : NumberLong(35),    // Note the change in this counter.
       "delete" : NumberLong(1043),
       "getmore" : NumberLong(2778),
       "command" : NumberLong(4729)
     }

   • El recuento de update en Repl Opcounters del nodo secundario sigue siendo 24.

     > db.serverStatus().opcountersRepl
     {
       "insert" : NumberLong(1540),
       "query" : NumberLong(0),
       "update" : NumberLong(24),
       "delete" : NumberLong(6),
       "getmore" : NumberLong(0),
       "command" : NumberLong(26)
     }

¿Por qué hay actividad en Opcounters con la base de datos inactiva?

Incluso sin tráfico de usuarios, los datos de monitoreo siguen reportando una pequeña cantidad de operaciones. Estas consisten en lo siguiente:

• Operaciones internas básicas que mantienen en funcionamiento la base de datos MongoDB, como los heartbeats del conjunto de réplicas, la sincronización primaria/secundaria y las actualizaciones de sesión.

• Operaciones rutinarias de los componentes de gestión de ApsaraDB for MongoDB, como comprobaciones de estado, monitoreo y escucha de eventos.

¿Por qué difieren las métricas Opcounters de las agregaciones del oplog?

En el oplog, puede usar el campo op para distinguir entre tipos de operaciones. Los valores comunes incluyen:

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

Las transacciones se registran en el oplog con un tipo de operación op: "c". Las operaciones individuales de insert, update y delete dentro de la transacción se almacenan internamente en el campo o.applyOps. Si agrega resultados basándose únicamente en el campo op de nivel superior del oplog, sus resultados no coincidirán con las métricas Opcounters en escenarios que impliquen transacciones. Para obtener más información sobre el formato del oplog, consulte Analysis of oplog fields.

Para contar los tipos específicos de operaciones dentro de una transacción, conéctese a su instancia de MongoDB mediante mongo shell y ejecute el siguiente comando.

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

A continuación se describen los parámetros de este comando:

• Timestamp(1733849400,0): Límite inferior para la marca de tiempo ts en la consulta del oplog. Reemplace este valor con la hora de consulta deseada. Puede leer esta marca de tiempo desde local.oplog.rs o usar una marca de tiempo UNIX estándar.

• "o.applyOps.0.op":"u": Especifica que la primera operación en el oplog de la transacción es una actualización. Puede reemplazar esto con otros tipos de operaciones. Por ejemplo, si la primera operación es una inserción, use "o.applyOps.0.op":"i".

• {$count:"count"}: Cuenta solo el número de entradas del oplog que coinciden. Puede usar otros operadores de agregación para otros tipos de análisis.

Para ver las métricas de monitoreo relacionadas con transacciones, vaya a la página Monitoring Information en la consola de ApsaraDB for MongoDB y consulte la métrica Transaction Operands. Para obtener más información sobre esta métrica, consulte Monitoring items and metrics.

El siguiente ejemplo muestra este comportamiento:

1. Antes de la actualización, compruebe Opcounters.

   > db.serverStatus().opcounters
   {
     "insert" : NumberLong(4), 
     "query" : NumberLong(6723),
     "update" : NumberLong(110489),
     "delete" : NumberLong(3065),
     "getmore" : NumberLong(222670),
     "command" : NumberLong(1917525)
   }

2. En el nodo primario, ejecute una operación de escritura dentro de una transacción.

   // Start a session.
   session = db.getMongo().startSession( { readPreference: { mode: "primary" } } );
   coll1 = session.getDatabase("mydb1").foo;
   coll2 = session.getDatabase("mydb2").bar;
   // Start a transaction.
   session.startTransaction( { readConcern: { level: "local" }, writeConcern: { w: "majority" } } );
   // Execute two insert operations in the transaction.
   try {
      coll1.insertOne( { abc: 1 } );
      coll2.insertOne( { xyz: 999 } );
   } catch (error) {
      // Abort the transaction if an error occurs.
      session.abortTransaction();
      throw error;
   }
   // Commit the transaction.
   session.commitTransaction();
   session.endSession();

3. Después de la actualización, compruebe nuevamente Opcounters. El recuento de insert en Opcounters cambió de 4 a 6.

   > db.serverStatus().opcounters
   {
     "insert" : NumberLong(6),   // Note the change in this counter.
     "query" : NumberLong(6728),
     "update" : NumberLong(110532),
     "delete" : NumberLong(3067),
     "getmore" : NumberLong(222823),
     "command" : NumberLong(1918887)
   }