/ /

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

Supervisar eventos de aplicaciones

Overview

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

La supervisión implica recopilar información sobre las actividades de un programa en ejecución, la cual se puede usar con una librería de gestión de rendimiento de aplicaciones (APM).

La supervisión del driver de nodo.js te permite comprender el uso de recursos y el rendimiento del driver, y puede ayudarte a tomar decisiones informadas al diseñar y depurar tu aplicación.

En esta guía aprenderás cómo realizar las siguientes tareas:

Monitorear eventos de comando
Supervisar eventos de descubrimiento y supervisión de servidores (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. Logging guía.

Supervisar eventos

Puedes supervisar eventos usando el driver de Node.js al suscribirte a ellos en tu 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 supervisar cada categoría de eventos.

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 de MongoDB, consulta la guía Database Commands en el Manual del Servidor.

Nota

La supervisión de comandos está deshabilitada por defecto. Para habilitar la supervisión de comandos, pasa el monitorCommands opción como true para tu constructor MongoClient.

Ejemplo

El siguiente ejemplo demuestra cómo conectar a un set de réplicas y suscribirse a uno de los eventos de supervisión de comandos generados 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 un comando falla.

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.

commandStarted

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'
}

CommandFailed

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 Descubrimiento y Supervisión de Servidores

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, consulta la guía de replicación en el manual del servidor.

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

Ejemplo de suscripción a eventos

Puedes acceder a uno o más eventos SDAM 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 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 una conexión a una instancia se cierra.
`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 la elección de un nuevo primario o la desconexión de un proxy mongos.
`serverHeartbeatStarted`	Creado antes de emitir un comando `hello` a una instancia de MongoDB.
`serverHeartbeatSucceeded`	Se crea cuando el comando `hello` se ejecuta correctamente en 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.

serverDescriptionChanged

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 autónoma
`Mongos`	Instancia de proxy de Mongos
`PossiblePrimary`	Al menos un servidor reconoce esto como el principal, pero aún no ha sido verificado por todas las instancias.
`RSPrimary`	Instancia principal
`RSSecondary`	Instancia secundaria
`RSArbiter`	Instancia de árbitro
`RSOther`	Consulta la especificación de RSGhost y RSOther para más detalles
`RSGhost`	Consulta la especificación de RSGhost y RSOther para más detalles

serverHeartbeatStarted

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'
}

serverHeartbeatFailed

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

serverOpening

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

servidorCerrado

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

topologyOpening

TopologyOpeningEvent {
  topologyId: 0
}

topologíaCerrada

TopologyClosedEvent {
  topologyId: 0
}

topologyDescriptionChanged

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 autónoma
`ReplicaSetWithPrimary`	Set de réplicas con un primario
`ReplicaSetNoPrimary`	Set de réplicas sin primario
`Sharded`	Clúster fragmentado
`Unknown`	Topología desconocida

Eventos del grupo de conexiones

Un pool de conexiones es un conjunto de conexiones TCP abiertas que su driver mantiene con una instancia de MongoDB. Los grupos de conexiones ayudan a reducir el número de handshakes de red que su aplicación necesita realizar y pueden ayudar a que su aplicación funcione más rápido.

Las siguientes secciones demuestran cómo registrar eventos del pool de conexiones en tu aplicación y explorar la información proporcionada en estos eventos.

Ejemplos de suscripción 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 supervisió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 supervisión del pool de conexiones para devolver un recuento de conexiones prestadas en el 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 pool de conexiones.
`connectionPoolReady`	Se crea cuando un pool 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 establece 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 la 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 todas las conexiones están cerradas y el pool de conexiones está vaciado.

Documentos de eventos de ejemplo

Las siguientes secciones muestran la salida de muestra para cada tipo de evento de supervisión del pool de conexiones.

connectionPoolCreated

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
}

connectionCheckOutStarted

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

connectionCheckOutFailed

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
}

connectionCheckedIn

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

connectionPoolCleared

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 tratados en esta guía, consulte la siguiente documentación de la API:

Volver

Búsqueda vectorial de MongoDB

Registro