/ /

Driver de Nodo.js

Docs Home

Librerías de clientes

Node.js

Driver de Nodo.js

Docs Home

Librerías de clientes

Node.js

Driver de Nodo.js

Monitorear eventos de aplicaciones

Overview

En esta guía, puede aprender cómo configurar y configurar la supervisión en el controlador MongoDB Node.js.

La monitorización implica la recopilación de información sobre las actividades de un programa en ejecución, que puede utilizar con una biblioteca de gestión del rendimiento de la aplicación.

Monitorear el controlador Node.js le permite comprender el uso y el rendimiento de los recursos del controlador, y puede ayudarlo a tomar decisiones informadas al diseñar y depurar su aplicación.

En esta guía aprenderás a realizar estas tareas:

Monitorear eventos de comando
Supervisar eventos de detección y supervisión del servidor (SDAM)
Supervisa los eventos del grupo de conexiones

Esta guía muestra cómo usar la información sobre la actividad del controlador en el código. Para aprender a registrar eventos en el controlador, consulte el controlador de Node.js. Guía de registro.

Monitorear eventos

Puede monitorear eventos utilizando el controlador Node.js suscribiéndose a ellos en su aplicación.

Un evento es cualquier acción que ocurre dentro del controlador durante su funcionamiento. El controlador de Node.js incluye la funcionalidad para escuchar un subconjunto de estos eventos.

El controlador Node.js organiza los eventos que define en las siguientes categorías:

Eventos de comando
Eventos de detección y supervisión de servidores (SDAM)
Eventos del grupo de conexiones

Las siguientes secciones muestran cómo monitorear cada categoría de evento.

Eventos de comando

Un evento de comando es un evento relacionado con un comando de base de datos MongoDB. Puede acceder a uno o más eventos de monitorización de comandos mediante el controlador suscribiéndose a ellos en su aplicación.

Para obtener más información sobre los comandos de base de datos MongoDB, consulte la guía Comandos de base de datos en el Manual del servidor.

Nota

La monitorización de comandos está deshabilitada de forma predeterminada. Para habilitarla, pase el monitorCommands opción como true a su constructor MongoClient.

Ejemplo

El siguiente ejemplo demuestra cómo conectarse a un conjunto de réplicas y suscribirse a uno de los eventos de monitoreo de comandos creados por la implementación de MongoDB:

/* Subscribe to an event */
const { MongoClient } = require("mongodb");
// Replace the following with your MongoDB deployment's connection string
const uri = "mongodb+srv://<clusterUrl>/?replicaSet=rs&writeConcern=majority";
const client = new MongoClient(uri, { monitorCommands:true });
// Replace <event name> with the name of the event you are subscribing to
const eventName = "<event name>";
// Subscribes to a specified event and print a message when the event is received
client.on(eventName, event => console.log(event));
async function run() {
  try {
    // Establishes and verifies connection to the "admin" database
    await client.db("admin").command({ ping: 1 });
    console.log("Connected successfully");
  } finally {
    // Closes the database connection on completion or error
    await client.close();
  }
}
run().catch(console.dir);

Descripciones de eventos

Puede suscribirse a cualquiera de los siguientes eventos de monitoreo de comandos:

Nombre del evento	Descripción
`commandStarted`	Se crea cuando se inicia un comando.
`commandSucceeded`	Se crea cuando un comando tiene éxito.
`commandFailed`	Se crea cuando falla un comando.

Las siguientes secciones muestran ejemplos de salida para cada uno de los comandos anteriores. La salida puede variar según el comando que ejecute y las opciones que configure.

comandoIniciado

CommandStartedEvent {
  name: 'commandStarted',
  address: 'localhost:27017',
  connectionId: 812613,
  serviceId: undefined,
  requestId: 1534,
  databaseName: 'app',
  commandName: 'find',
  command: {
    find: { firstName: "Jane", lastName: "Doe" }
  },
  serverConnectionId: 27177n
}

comando exitoso

CommandSucceededEvent {
  name: 'commandSucceeded',
  address: 'localhost:27017',
  connectionId: 812613,
  serviceId: undefined,
  requestId: 1534,
  commandName: 'find',
  duration: 15,
  reply: {
    cursor: {
      firstBatch: [
        {
          _id: ObjectId("5e8e2ca217b5324fa9847435"),
          firstName: "Jane",
          lastName: "Doe"
        }
      ],
      _id: 0,
      ns: "app.users"
    },
    ok: 1,
    operationTime: 1586380205
  },
  serverConnectionId: 27096n,
  databaseName: 'app'
}

comandoFailed

CommandFailedEvent {
  name: 'commandFailed',
  address: 'localhost:27017',
  connectionId: 812613,
  serviceId: undefined,
  requestId: 1534,
  commandName: 'find',
  duration: 11,
  failure: Error("something failed"),
  serverConnectionId: 27208n,
  databaseName: 'app'
}

Eventos de detección y supervisión del servidor

El controlador de Node.js crea eventos de topología, también conocidos como eventos SDAM, cuando se produce un cambio en el estado de la instancia o el clúster al que se conectó. Por ejemplo, el controlador crea un evento al establecer una nueva conexión o si el clúster elige un nuevo nodo principal.

Para obtener más información sobre los eventos de topología, consulte la guía de replicación en el Manual del servidor.

Las siguientes secciones demuestran cómo registrar cambios de topología en su aplicación y exploran la información proporcionada en estos eventos.

Ejemplo de suscripción a eventos

Puede acceder a uno o más eventos SDAM suscribiéndose a ellos en su aplicación. El siguiente ejemplo muestra cómo conectarse a un conjunto de réplicas y suscribirse a uno de los eventos SDAM creados por la implementación de MongoDB:

/* Subscribe to SDAM event */
const { MongoClient } = require("mongodb");
// Replace the following with your MongoDB deployment's connection string
const uri = "mongodb+srv://<clusterUrl>/?replicaSet=rs&writeConcern=majority";
const client = new MongoClient(uri);
// Replace <event name> with the name of the event you are subscribing to
const eventName = "<event name>";
// Subscribes to a specified event and prints a message when the event is received
client.on(eventName, event => {
  console.log(`received ${eventName}: ${JSON.stringify(event, null, 2)}`);
});
async function run() {
  try {
    // Establishes and verifies connection to the database
    await client.db("admin").command({ ping: 1 });
    console.log("Connected successfully");
  } finally {
    // Closes the database connection on completion or error
    await client.close();
  }
}
run().catch(console.dir);

Descripciones de eventos

Puedes suscribirte a cualquiera de los siguientes eventos SDAM:

Nombre del evento	Descripción
`serverOpening`	Se crea cuando se abre una conexión a una instancia.
`serverClosed`	Se crea cuando se cierra una conexión a una instancia.
`serverDescriptionChanged`	Se crea cuando cambia el estado de una instancia (por ejemplo, de secundaria a principal).
`topologyOpening`	Creado antes de intentar una conexión a una instancia.
`topologyClosed`	Se crea después de que se cierran todas las conexiones de instancia en la topología.
`topologyDescriptionChanged`	Se crea cuando la topología cambia, como por ejemplo cuando se elige un nuevo servidor principal o se desconecta un proxy mongos.
`serverHeartbeatStarted`	Creado antes de emitir un comando `hello` a una instancia de MongoDB.
`serverHeartbeatSucceeded`	Se crea cuando el comando `hello` regresa exitosamente desde una instancia de MongoDB.
`serverHeartbeatFailed`	Se crea cuando un comando `hello` emitido a una instancia específica de MongoDB no logra devolver una respuesta exitosa.

Documentos de eventos de ejemplo

Las siguientes secciones muestran la salida de ejemplo para cada tipo de evento SDAM.

Descripción del servidor modificada

ServerDescriptionChangedEvent {
  topologyId: 0,
  address: 'localhost:27017',
  previousDescription: ServerDescription {
    address: 'localhost:27017',
    error: null,
    roundTripTime: 0,
    lastUpdateTime: 1571251089030,
    lastWriteDate: null,
    opTime: null,
    type: 'Unknown',
    minWireVersion: 0,
    maxWireVersion: 0,
    hosts: [],
    passives: [],
    arbiters: [],
    tags: []
  },
  newDescription: ServerDescription {
    address: 'localhost:27017',
    error: null,
    roundTripTime: 0,
    lastUpdateTime: 1571251089051,
    lastWriteDate: 2019-10-16T18:38:07.000Z,
    opTime: { ts: Timestamp, t: 18 },
    type: 'RSPrimary',
    minWireVersion: 0,
    maxWireVersion: 7,
    maxBsonObjectSize: 16777216,
    maxMessageSizeBytes: 48000000,
    maxWriteBatchSize: 100000,
    me: 'localhost:27017',
    hosts: [ 'localhost:27017' ],
    passives: [],
    arbiters: [],
    tags: [],
    setName: 'rs',
    setVersion: 1,
    electionId: ObjectID,
    primary: 'localhost:27017',
    logicalSessionTimeoutMinutes: 30,
    '$clusterTime': ClusterTime
  }
}

El campo type del objeto ServerDescription en este evento contiene uno de los siguientes valores posibles:

Tipo	Descripción
`Unknown`	Instancia desconocida
`Standalone`	Instancia independiente
`Mongos`	Instancia de proxy de Mongos
`PossiblePrimary`	Al menos un servidor reconoce esto como el principal, pero aún no está verificado por todas las instancias.
`RSPrimary`	Instancia principal
`RSSecondary`	Instancia secundaria
`RSArbiter`	Instancia de árbitro
`RSOther`	Consulte las especificaciones RSGhost y RSOther para obtener más detalles.
`RSGhost`	Consulte las especificaciones RSGhost y RSOther para obtener más detalles.

Latido del servidor iniciado

ServerHeartbeatStartedEvent {
  connectionId: 'localhost:27017'
}

serverHeartbeatSucceeded

ServerHeartbeatSucceededEvent {
  duration: 1.939997,
  reply:{
    hosts: [ 'localhost:27017' ],
    setName: 'rs',
    setVersion: 1,
    isWritablePrimary: true,
    secondary: false,
    primary: 'localhost:27017',
    me: 'localhost:27017',
    electionId: ObjectID,
    lastWrite: {
      opTime: { ts: [Timestamp], t: 18 },
      lastWriteDate: 2019-10-16T18:38:17.000Z,
      majorityOpTime: { ts: [Timestamp], t: 18 },
      majorityWriteDate: 2019-10-16T18:38:17.000Z
    },
    maxBsonObjectSize: 16777216,
    maxMessageSizeBytes: 48000000,
    maxWriteBatchSize: 100000,
    localTime: 2019-10-16T18:38:19.589Z,
    logicalSessionTimeoutMinutes: 30,
    minWireVersion: 0,
    maxWireVersion: 7,
    readOnly: false,
    ok: 1,
    operationTime: Timestamp,
    '$clusterTime': ClusterTime
  },
  connectionId: 'localhost:27017'
}

Error en el latido del servidor

ServerHeartbeatFailed {
  duration: 20,
  failure: MongoError('some error'),
  connectionId: 'localhost:27017'
}

Apertura del servidor

ServerOpeningEvent {
  topologyId: 0,
  address: 'localhost:27017'
}

servidor cerrado

ServerClosedEvent {
  topologyId: 0,
  address: 'localhost:27017'
}

Apertura de topología

TopologyOpeningEvent {
  topologyId: 0
}

topologíaCerrada

TopologyClosedEvent {
  topologyId: 0
}

Descripción de topología modificada

TopologyDescriptionChangedEvent {
  topologyId: 0,
  previousDescription: TopologyDescription {
    type: 'ReplicaSetNoPrimary',
    setName: null,
    maxSetVersion: null,
    maxElectionId: null,
    servers: Map {
      'localhost:27017' => ServerDescription
    },
    stale: false,
    compatible: true,
    compatibilityError: null,
    logicalSessionTimeoutMinutes: null,
    heartbeatFrequencyMS: 10000,
    localThresholdMS: 15,
    options: Object,
    error: undefined,
    commonWireVersion: null
  },
  newDescription: TopologyDescription {
    type: 'ReplicaSetWithPrimary',
    setName: 'rs',
    maxSetVersion: 1,
    maxElectionId: null,
    servers: Map {
      'localhost:27017' => ServerDescription
    },
    stale: false,
    compatible: true,
    compatibilityError: null,
    logicalSessionTimeoutMinutes: 30,
    heartbeatFrequencyMS: 10000,
    localThresholdMS: 15,
    options: Object,
    error: undefined,
    commonWireVersion: 7
  }
}

El campo type del objeto TopologyDescription en este evento contiene uno de los siguientes valores posibles:

Tipo	Descripción
`Single`	Instancia independiente
`ReplicaSetWithPrimary`	Conjunto de réplicas con un primario
`ReplicaSetNoPrimary`	Conjunto de réplicas sin primario
`Sharded`	Clúster fragmentado
`Unknown`	Topología desconocida

Eventos del grupo de conexiones

Un grupo de conexiones es un conjunto de conexiones TCP abiertas que su controlador mantiene con una instancia de MongoDB. Los grupos de conexiones ayudan a reducir el número de protocolos de enlace de red que su aplicación debe realizar y pueden acelerar su ejecución.

Las siguientes secciones demuestran cómo registrar eventos del grupo de conexiones en su aplicación y exploran la información proporcionada en estos eventos.

Ejemplos de suscripciones a eventos

Puedes acceder a uno o más eventos de pool de conexiones utilizando el driver suscribiéndote a ellos en tu aplicación. El siguiente ejemplo demuestra cómo conectarse a un set de réplicas y suscribirse a uno de los eventos de supervisión de pool de conexiones creados por la implementación de MongoDB:

const { MongoClient } = require("mongodb");
// Replace the following with your MongoDB deployment's connection string
const uri =
  "mongodb+srv://<clusterUrl>/?replicaSet=rs&writeConcern=majority";
const client = new MongoClient(uri);
// Replace <event name> with the name of the event you are subscribing to
const eventName = "<event name>";
// Subscribes to the event
client.on(eventName, (event) =>
  console.log("\nreceived event:\n", event)
);
async function run() {
  try {
    // Establishes and verifies connection
    await client.db("admin").command({ ping: 1 });
    console.log("\nConnected successfully!\n");
  } finally {
    // Ensures that the client will close when you finish/error
    await client.close();
  }
}
run().catch(console.dir);

Los eventos de monitorización del pool de conexiones pueden ayudarle a depurar y comprender el comportamiento del pool de conexiones de su aplicación. El siguiente ejemplo utiliza eventos de monitorización del pool de conexiones para obtener un recuento de las conexiones extraídas del pool:

function connectionPoolStatus(client) {
  let checkedOut = 0;
  function onCheckout() {
    checkedOut++;
  }
  function onCheckin() {
    checkedOut--;
  }
  function onClose() {
    client.removeListener('connectionCheckedOut', onCheckout);
    client.removeListener('connectionCheckedIn', onCheckin);
    checkedOut = NaN;
  }
  // Decreases count of connections checked out of the pool when connectionCheckedIn event is triggered
  client.on('connectionCheckedIn', onCheckin);
  // Increases count of connections checked out of the pool when connectionCheckedOut event is triggered
  client.on('connectionCheckedOut', onCheckout);
  // Cleans up event listeners when client is closed
  client.on('close', onClose);
  return {
    count: () => checkedOut,
    cleanUp: onClose
  };
}

Descripciones de eventos

Puede suscribirse a cualquiera de los siguientes eventos de monitoreo de pool de conexiones:

Nombre del evento	Descripción
`connectionPoolCreated`	Se crea cuando se crea un grupo de conexiones.
`connectionPoolReady`	Se crea cuando un grupo de conexiones está listo.
`connectionPoolClosed`	Se crea cuando se cierra un grupo de conexiones antes de la destrucción de la instancia del servidor.
`connectionCreated`	Se crea cuando se crea una conexión, pero no necesariamente cuando se utiliza para una operación.
`connectionReady`	Creado después de que una conexión haya completado exitosamente un apretón de manos y esté lista para usarse en operaciones.
`connectionClosed`	Se crea cuando se cierra una conexión.
`connectionCheckOutStarted`	Se crea cuando una operación intenta adquirir una conexión para su ejecución.
`connectionCheckOutFailed`	Se crea cuando una operación no logra adquirir una conexión para su ejecución.
`connectionCheckedOut`	Se crea cuando una operación obtiene con éxito una conexión para su ejecución.
`connectionCheckedIn`	Se crea cuando una conexión se revisa de nuevo en el pool después de ejecutar una operación.
`connectionPoolCleared`	Se crea cuando se cierran todas las conexiones y se borra el grupo de conexiones.

Documentos de eventos de ejemplo

Las siguientes secciones muestran una salida de muestra para cada tipo de evento de monitoreo de grupo de conexiones.

Grupo de conexiones creado

ConnectionPoolCreatedEvent {
  time: 2023-02-13T15:54:06.944Z,
  address: '...',
  options: {...}
}

conexiónPoolReady

ConnectionPoolReadyEvent {
  time: 2023-02-13T15:56:38.440Z,
  address: '...'
}

Grupo de conexiones cerrado

ConnectionPoolClosedEvent {
  time: 2023-02-13T15:56:38.440Z,
  address: '...'
}

conexiónCreada

ConnectionCreatedEvent {
  time: 2023-02-13T15:56:38.291Z,
  address: '...',
  connectionId: 1
}

Conexión lista

ConnectionReadyEvent {
  time: 2023-02-13T15:56:38.291Z,
  address: '...',
  connectionId: 1,
  durationMS: 60
}

Conexión cerrada

ConnectionClosedEvent {
  time: 2023-02-13T15:56:38.439Z,
  address: '...',
  connectionId: 1,
  reason: 'poolClosed',
  serviceId: undefined
}

ConexiónCheckOutStarted

ConnectionCheckOutStartedEvent {
  time: 2023-02-13T15:56:38.291Z,
  address: '...',
}

Error en la verificación de conexión

ConnectionCheckOutFailedEvent {
  time: 2023-02-13T15:56:38.291Z,
  address: '...',
  reason: ...,
  durationMS: 60
}

Conexión verificada

ConnectionCheckedOutEvent {
  time: 2023-02-13T15:54:07.188Z,
  address: '...',
  connectionId: 1,
  durationMS: 60
}

conexión registrada

ConnectionCheckedInEvent {
  time: 2023-02-13T15:54:07.189Z,
  address: '...',
  connectionId: 1
}

grupo de conexiones despejado

ConnectionPoolClearedEvent {
  time: 2023-02-13T15:56:38.439Z,
  address: '...',
  serviceId: undefined,
  interruptInUseConnections: true,
}

Documentación de la API

Para obtener más información sobre cualquiera de las opciones o tipos analizados en esta guía, consulte la siguiente documentación de API:

Volver

Búsqueda vectorial de MongoDB

Registro