Supervisar eventos de aplicaciones

Overview

En esta guía, puede aprender a configurar y ajustar la supervisión en el driver de MongoDB C++.

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).

Monitorear el controlador de C++ le permite comprender el uso de recursos y el rendimiento del controlador. Esta información puede ayudarle a tomar decisiones informadas al diseñar y depurar su aplicación.

Esta guía muestra cómo realizar las siguientes tareas:

Monitorear eventos de comando
Supervisar eventos de descubrimiento y supervisión de servidores (SDAM)

Tip

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

Monitorear eventos de comando

El driver de C++ crea eventos de comandos cuando tu cliente ejecuta un comando de base de datos. Por ejemplo, findLos comandos , insert, delete, y count generan eventos de comando. Puedes iniciar estos comandos ejecutando las operaciones estándar de crear, leer, actualizar o borrar del driver, o utilizando directamente los comandos de la base de datos.

Tip

Para obtener más información sobre los comandos de base de datos, consulte la guía Ejecutar un comando.

Puedes acceder a detalles sobre eventos de comando suscribiéndote a ellos en tu aplicación. Para suscribirse a un evento de comando, cree un objeto mongocxx::options::apm para almacenar la configuración de supervisión del Rendimiento de la Aplicación (APM). Luego, pasa las opciones a tu objeto mongocxx::client. Llamar a los siguientes métodos en el objeto mongocxx::options::apm para establecer el comportamiento de supervisión de comandos:

Método	Descripción
`on_command_started()`	Especifica cómo responde el cliente cuando se inicia un comando, lo que genera un `mongocxx::events::command_started_event`
`on_command_failed()`	Especifica cómo responde el cliente cuando una instrucción no tiene éxito, lo que genera una `mongocxx::events::command_failed_event`
`on_command_succeeded()`	Especifica cómo responde el cliente cuando un comando tiene éxito, lo que genera un `mongocxx::events::command_succeeded_event`

El siguiente código supervisa los eventos de inicio de comando realizando las siguientes acciones:

Llama al método on_command_started() en un objeto mongocxx::options::apm
Pasa una función de retorno a on_command_started() que imprime el nombre de cada comando y el ID de solicitud
Configura tu cliente con estas opciones

1 #include <iostream>
2 #include <mongocxx/client.hpp>
3 #include <mongocxx/instance.hpp>
4 #include <mongocxx/uri.hpp>
5 #include <mongocxx/options/apm.hpp>
6 
7 int main() {
8     mongocxx::instance instance{};
9     
10     int command_started_events = 0;
11     
12     mongocxx::options::apm apm_opts;
13     apm_opts.on_command_started([&command_started_events](const mongocxx::events::command_started_event& event) {
14         command_started_events++;
15         std::cout << "Command started: " << event.command_name() 
16                   << " (request_id: " << event.request_id() << ")" << std::endl;
17     });
18     
19     mongocxx::uri uri("<connection string URI>");
20     mongocxx::options::client client_opts;
21     client_opts.apm_opts(apm_opts);
22     
23     mongocxx::client client{uri, client_opts};
24     
25     // Perform database operations
26     
27     std::cout << "Observed " << command_started_events << " command started events" << std::endl;
28     
29     return 0;
30 }

Cuando se ejecuta un comando de búsqueda, el código imprime mensajes similares al siguiente ejemplo de salida:

Command started: find (request_id: 3)

Supervisar eventos de descubrimiento y supervisión de servidores (SDAM)

El driver de C++ crea eventos de topología, también conocidos como eventos SDAM, cuando cambia el estado de la instancia o clúster al que se conectó. Por ejemplo, el controlador crea un evento cuando estableces una nueva conexión o cuando el clúster elige un nuevo nodo primario.

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

Puedes acceder a los detalles sobre los eventos SDAM suscribiéndote a ellos en tu aplicación. Para suscribirte a un evento SDAM, crea un objeto mongocxx::options::apm para almacenar tu configuración de APM. Luego, pase las opciones a su objeto mongocxx::client. Llama a los siguientes métodos en el objeto mongocxx::options::apm para configurar el comportamiento de supervisión SDAM:

Método	Descripción
`on_server_changed()`	Especifica cómo responde el cliente cuando cambia la descripción del servidor, lo que genera un `mongocxx::events::server_changed_event`
`on_server_opening()`	Especifica cómo responde el cliente cuando se añade un nuevo servidor a la topología, lo que genera un `mongocxx::events::server_opening_event`
`on_server_closed()`	Especifica cómo responde el cliente cuando se elimina un servidor de la topología, lo que genera un `mongocxx::events::server_closed_event`
`on_topology_changed()`	Especifica cómo responde el cliente cuando cambia la descripción de la topología, lo que genera un `mongocxx::events::topology_changed_event`
`on_topology_opening()`	Especifica cómo responde el cliente cuando el controlador se conecta por primera vez al clúster, lo que genera un `mongocxx::events::topology_opening_event`
`on_topology_closed()`	Especifica cómo responde el cliente cuando el controlador se desconecta del clúster, lo que genera un `mongocxx::events::topology_closed_event`
`on_heartbeat_started()`	Especifica cómo responde el cliente cuando se envía un latido al servidor, lo que genera un `mongocxx::events::heartbeat_started_event`
`on_heartbeat_succeeded()`	Especifica cómo responde el cliente cuando un latido tiene éxito, lo que genera un `mongocxx::events::heartbeat_succeeded_event`
`on_heartbeat_failed()`	Especifica cómo responde el cliente cuando un latido falla, lo que genera un `mongocxx::events::heartbeat_failed_event`

El siguiente código monitorea los eventos de apertura del servidor realizando las siguientes acciones:

Llama al método on_server_opening() en un objeto mongocxx::options::apm
Pasa una función de retorno a on_server_opening() que imprime el host y el puerto de cada servidor
Configura tu cliente con estas opciones

1 #include <iostream>
2 #include <mongocxx/client.hpp>
3 #include <mongocxx/instance.hpp>
4 #include <mongocxx/uri.hpp>
5 #include <mongocxx/options/apm.hpp>
6 
7 int main() {
8     mongocxx::instance instance{};
9     
10     int server_opening_events = 0;
11     
12     mongocxx::options::apm apm_opts;
13     apm_opts.on_server_opening([&server_opening_events](const mongocxx::events::server_opening_event& event) {
14         server_opening_events++;
15         std::cout << "Server opening: " << event.host() << ":" << event.port() << std::endl;
16     });
17     
18     mongocxx::uri uri("<connection string URI>");
19     mongocxx::options::client client_opts;
20     client_opts.apm_opts(apm_opts);
21     
22     mongocxx::client client{uri, client_opts};
23     
24     // Perform database operations
25     
26     std::cout << "Observed " << server_opening_events << " server opening events" << std::endl;
27     
28     return 0;
29 }

Cuando se realiza una operación de base de datos, el controlador establece una nueva conexión con el servidor y su suscriptor registra el evento de apertura del servidor. El código genera mensajes que se asemejan a los siguientes:

Server opening: <host>:<port number>

Descripciones de eventos

Puedes suscribirte a los eventos de supervisión creando una función de retorno que acepte un objeto de clase de evento como parámetro. La siguiente tabla proporciona el nombre de cada clase de evento, enlaces a la documentación de la API del tipo y describe cuándo se publica el evento:

Clase de controlador de eventos	Descripción
mongocxx::events::command_started_event	Se crea cuando se inicia un comando.
mongocxx::events::command_succeeded_event	Se crea cuando un comando tiene éxito.
mongocxx::events::command_failed_event	Se crea cuando un comando falla.
mongocxx::eventos::evento_cambiado_del_servidor	Se crea cuando la descripción del servidor cambia, como cuando el tipo de servidor cambia de secundario a primario.
mongocxx::events::server_opening_event	Se crea cuando se agrega un nuevo servidor a la topología.
mongocxx::eventos::evento_cerrado_del_servidor	Se crea cuando un servidor existente se elimina de la topología.
mongocxx::events::evento_topology_changed	Se crea cuando la descripción de la topología cambia, como cuando se elige un nuevo primario.
mongocxx::events::topology_opening_event	Se crea cuando el driver se conecta por primera vez al clúster.
mongocxx::events::topology_closed_event	Se crea cuando el controlador se desconecta del clúster.
mongocxx::eventos::heartbeat_started_event	Se crea cuando el monitor del servidor envía un comando `hello` al servidor. Esta acción se denomina latido.
mongocxx::events::heartbeat_succeeded_event	Se crea cuando el latido cardíaco tiene éxito.
mongocxx::events::heartbeat_failed_event	Se crea cuando falla la señal de vida.

Puedes encontrar información sobre cada tipo de suscriptor de supervisión y método de evento en la sección Supervisión del Rendimiento de la Aplicación de la documentación de la API.

Documentación de la API

Para obtener más información sobre las clases y los métodos analizados en esta guía, consulte la siguiente documentación de API:

Volver

Registro

Flujos de cambio

1	#include <iostream>
2	#include <mongocxx/client.hpp>
3	#include <mongocxx/instance.hpp>
4	#include <mongocxx/uri.hpp>
5	#include <mongocxx/options/apm.hpp>
6
7	int main() {
8	mongocxx::instance instance{};
9
10	int command_started_events = 0;
11
12	mongocxx::options::apm apm_opts;
13	apm_opts.on_command_started([&command_started_events](const mongocxx::events::command_started_event& event) {
14	command_started_events++;
15	std::cout << "Command started: " << event.command_name()
16	<< " (request_id: " << event.request_id() << ")" << std::endl;
17	});
18
19	mongocxx::uri uri("<connection string URI>");
20	mongocxx::options::client client_opts;
21	client_opts.apm_opts(apm_opts);
22
23	mongocxx::client client{uri, client_opts};
24
25	// Perform database operations
26
27	std::cout << "Observed " << command_started_events << " command started events" << std::endl;
28
29	return 0;
30	}