Monitorear eventos de aplicaciones

Overview

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

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 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 detección y supervisión del servidor (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 deeventos del controlador de registro.

Monitorear eventos de comando

El controlador de C++ crea eventos de comando cuando el cliente ejecuta un comando de base de datos. Por ejemplo, findLos comandos insert, delete y count generan eventos de comando. Puede iniciar estos comandos ejecutando las operaciones estándar de creación, lectura, actualización o eliminación del controlador, o usando 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.

Puede acceder a los detalles de los eventos de comando suscribiéndose a ellos en su aplicación. Para suscribirse a un evento de comando, cree un objeto mongocxx::options::apm para almacenar la configuración de Monitoreo del Rendimiento de Aplicaciones (APM). Luego, pase las opciones a su objeto mongocxx::client. Invoque los siguientes métodos en el objeto mongocxx::options::apm para configurar el comportamiento del monitoreo 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 un comando no tiene éxito, lo que genera un `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 monitorea eventos iniciados por comandos realizando las siguientes acciones:

Llama al método on_command_started() en un objeto mongocxx::options::apm
Pasa una devolución de llamada 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 detección y supervisión del servidor (SDAM)

El controlador de C++ crea eventos de topología, también conocidos como eventos SDAM, cuando cambia 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 cuando 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.

Puede acceder a detalles sobre los eventos SDAM suscribiéndose a ellos en su aplicación. Para suscribirse a un evento SDAM, cree un objeto mongocxx::options::apm para almacenar su configuración de APM. Luego, pase las opciones a su objeto mongocxx::client. Invoque los siguientes métodos en el objeto mongocxx::options::apm para configurar el comportamiento de monitorización de 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 agrega 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 se produce un latido, lo que genera un `mongocxx::events::heartbeat_succeeded_event`
`on_heartbeat_failed()`	Especifica cómo responde el cliente cuando falla un latido, 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 devolución de llamada 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 }

Al realizar una operación de base de datos, el controlador establece una nueva conexión con el servidor y el suscriptor registra el evento de apertura del servidor. El código genera mensajes similares a los siguientes:

Server opening: <host>:<port number>

Descripciones de eventos

Puede suscribirse a la monitorización de eventos creando una función de devolución de llamada 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::eventos::evento_iniciado_por_comando	Se crea cuando se inicia un comando.
mongocxx::eventos::evento_de_comando_exitoso	Se crea cuando un comando tiene éxito.
mongocxx::eventos::evento_de_comando_fallido	Se crea cuando falla un comando.
mongocxx::eventos::evento_cambiado_del_servidor	Se crea cuando cambia la descripción del servidor, como cuando el tipo de servidor cambia de secundario a principal.
mongocxx::eventos::evento_de_apertura_del_servidor	Se crea cuando se agrega un nuevo servidor a la topología.
mongocxx::eventos::evento_cerrado_del_servidor	Se crea cuando se elimina un servidor existente de la topología.
mongocxx::eventos::evento_de_topología_cambiada	Se crea cuando cambia la descripción de la topología, como cuando hay una elección de un nuevo primario.
mongocxx::eventos::evento_de_apertura_de_topología	Se crea cuando el controlador se conecta por primera vez al clúster.
mongocxx::eventos::evento_cerrado_de_topología	Se crea cuando el controlador se desconecta del clúster.
mongocxx::eventos::evento_iniciado_por_latido	Se crea cuando el monitor del servidor envía un comando `hello` al servidor. Esta acción se denomina latido.
mongocxx::eventos::evento_de_latido_exitoso	Se crea cuando el latido tiene éxito.
mongocxx::eventos::evento_de_latido_fallido	Se crea cuando falla el latido del corazón.

Puede encontrar información sobre cada tipo de suscriptor de monitoreo y método de evento en la sección Monitoreo 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	}