Supervisar eventos de aplicaciones

Overview

En esta guía, puede aprender cómo configurar y ajustar la supervisión en el MongoDB Ruby Driver.

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 Ruby driver te permite entender el uso de recursos y el rendimiento del driver. Esta información puede ayudarle a tomar decisiones informadas al diseñar y depurar la aplicación.

En esta guía, puedes aprender cómo realizar las siguientes tareas:

Supervisar eventos del comando
Supervisar eventos de descubrimiento y supervisión de servidores (SDAM)
Supervisa los eventos del grupo de conexiones

Esta guía muestra cómo utilizar información sobre la actividad del controlador en el código. Para aprender cómo registrar eventos en el driver, consulte la guía de registro de logs del driver de Ruby.

Supervisar eventos del comando

Un evento de comando es un evento relacionado con un comando de base de datos de MongoDB. Puedes acceder a uno o más eventos de supervisión de comandos usando el driver suscribiéndote a ellos en tu aplicación.

Para aprender más sobre los comandos de bases de datos de MongoDB, consulta la guía Comandos de bases de datos en el manual de MongoDB Server.

Suscríbete a Eventos de Comando

Puedes acceder a detalles sobre eventos de comando suscribiéndote a ellos en tu aplicación. Puede suscribirse a eventos a nivel global, lo que supervisa todos los clientes de un clúster, o a nivel de cliente. Este ejemplo demuestra las siguientes acciones:

Instancia un CommandLogSubscriber
Utiliza el método Mongo::Monitoring::Global.subscribe para suscribirte a eventos de comandos a nivel global
Utiliza el método Mongo::Client.subscribe para suscribirse a eventos de comandos a nivel del cliente

require 'mongo'
# Creates a subscriber for command monitoringsubscriber = Mongo::Monitoring::CommandLogSubscriber.new
# Globally subscribes to command monitoring eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::COMMAND, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to command monitoring events at the client levelclient.subscribe( Mongo::Monitoring::COMMAND, subscriber)

Descripciones de eventos

Puedes suscribirte a cualquiera de los siguientes eventos de supervisión de comandos:

Nombre del Evento	Descripción
CommandStarted	Se crea cuando se inicia un comando.
Comando realizado correctamente	Se crea cuando un comando tiene éxito.
CommandFailed	Se crea cuando un comando falla.

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

El driver Ruby crea eventos de topología, también conocidos como eventos SDAM, cuando hay un cambio en el estado de la instancia o clúster al que te conectaste. Por ejemplo, el controlador crea un evento cuando se establece 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.

Suscríbete a los eventos de SDAM

Puedes utilizar el método subscribe del driver de Ruby para suscribirte a eventos. Pase un tema de supervisión, que defina el tipo de evento de supervisión, y un objeto suscriptor como argumentos al método subscribe. Puede suscribirse a eventos a nivel global, que supervisa todos los clientes de un clúster, o a nivel de cliente.

Este ejemplo demuestra las siguientes acciones:

Instancia un/a suscriptor/a ServerOpeningLogSubscriber
Utiliza el método Mongo::Monitoring::Global.subscribe para suscribirse a eventos de ServerOpening a nivel global
Usa el método Mongo::Client.subscribe para suscribirse a eventos ServerOpening a nivel de cliente

require 'mongo'
subscriber = Mongo::Monitoring::ServerOpeningLogSubscriber.new
# Globally subscribes to ServerOpening events by using the SERVER_OPENING monitoring topicMongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to ServerOpening events at the client level by using the SERVER_OPENING monitoring topicclient.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)

La siguiente tabla proporciona los suscriptores disponibles y su tema de supervisión:

Nombre del suscriptor	Supervisión de tema	Descripción
ServerClosedLogSubscriber	`SERVER_CLOSED`	Se suscribe a los eventos `ServerClosed` y los registra.
ServerDescriptionChangedLogSubscriber	`SERVER_DESCRIPTION_CHANGED`	Se suscribe a los eventos `ServerDescriptionChanged` y los registra.
ServerOpeningLogSubscriber	`SERVER_OPENING`	Se suscribe a los eventos `ServerOpening` y los registra.
TopologyChangedLogSubscriber	`TOPOLOGY_CHANGED`	Se suscribe a los eventos `TopologyChanged` y los registra.
TopologyClosedLogSubscriber	`TOPOLOGY_CLOSED`	Se suscribe a los eventos `TopologyClosed` y los registra.
TopologyOpeningLogSubscriber	`TOPOLOGY_OPENING`	Se suscribe a los eventos `TopologyOpening` y los registra.

Puedes encontrar una tabla con las descripciones de los eventos de SDAM en la sección Descripciones de eventos de esta página.

Supervisión SDAM personalizada

Puedes crear un suscriptor SDAM personalizado para acceder a los detalles sobre el servidor y los eventos de topología. Cree una clase separada para cada tipo de evento, ya que los datos disponibles para cada evento varían.

Para todos los eventos, el suscriptor llama al método succeeded y pasa el evento como argumento. Un suscriptor sencillo de registro de SDAM podría verse como el siguiente código:

class SDAMLogSubscriber  include Mongo::Loggable
  def succeeded(event)    log_debug(format_event(event))  end
  private
  def logger    Mongo::Logger.logger  end
  def format_message(message)    format("SDAM | %s", message)  endend  class TopologyOpeningLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Topology type '#{event.topology.display_name}' initializing."  endend
class ServerOpeningLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server #{event.address} initializing."  endend
class ServerDescriptionChangedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server description for #{event.address} changed from " +    "'#{event.previous_description.server_type}' to '#{event.new_description.server_type}'."  endend
class TopologyChangedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    if event.previous_topology != event.new_topology      "Topology type '#{event.previous_topology.display_name}' changed to " +      "type '#{event.new_topology.display_name}'."    else      "There was a change in the members of the '#{event.new_topology.display_name}' " +      "topology."    end  endend
class ServerClosedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Server #{event.address} connection closed."  endend
class TopologyClosedLogSubscriber < SDAMLogSubscriber  private
  def format_event(event)    "Topology type '#{event.topology.display_name}' closed."  endend

Para suscribirse a los eventos, crea el suscriptor apropiado y suscríbete al tema de supervisión correcto. El siguiente código muestra cómo suscribirse a eventos SDAM globalmente:

topology_opening_subscriber = TopologyOpeningLogSubscriber.newserver_opening_subscriber = ServerOpeningLogSubscriber.newserver_description_changed_subscriber = ServerDescriptionChangedLogSubscriber.newtopology_changed_subscriber = TopologyChangedLogSubscriber.newserver_closed_subscriber = ServerClosedLogSubscriber.newtopology_closed_subscriber = TopologyClosedLogSubscriber.new
Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING,  topology_opening_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_OPENING,  server_opening_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED,  server_description_changed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED,  topology_changed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_CLOSED,  server_closed_subscriber)Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CLOSED,  topology_closed_subscriber)

El siguiente código muestra cómo suscribirse a los eventos SDAM para un solo cliente utilizando la opción de cliente sdam-proc:

topology_opening_subscriber = TopologyOpeningLogSubscriber.newserver_opening_subscriber = ServerOpeningLogSubscriber.newserver_description_changed_subscriber = ServerDescriptionChangedLogSubscriber.newtopology_changed_subscriber = TopologyChangedLogSubscriber.newserver_closed_subscriber = ServerClosedLogSubscriber.newtopology_closed_subscriber = TopologyClosedLogSubscriber.new
sdam_proc = Proc.new do |client|  client.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING,    topology_opening_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_OPENING,    server_opening_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED,    server_description_changed_subscriber)  client.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED,    topology_changed_subscriber)  client.subscribe(Mongo::Monitoring::SERVER_CLOSED,    server_closed_subscriber)  client.subscribe(Mongo::Monitoring::TOPOLOGY_CLOSED,    topology_closed_subscriber)end
client = Mongo::Client.new(['127.0.0.1:27017'], database: 'test',  sdam_proc: sdam_proc)

Nota

La opción de cliente :sdam_proc se aplica únicamente al cliente dado. Cuando se cambian ciertas opciones del cliente utilizando la llamada Client#with, el controlador puede crear un nuevo clúster con un conjunto predeterminado de suscriptores de eventos. Si esto sucede, no se invoca el :sdam_proc proporcionado, y la aplicación puede perder eventos.

Cuando ejecutas la aplicación, tu suscriptor registra el evento SDAM y emite mensajes como los siguientes:

D, [2018-10-09T13:58:03.489461 #22079] DEBUG -- : SDAM | Topology type 'Unknown' initializing.D, [2018-10-09T13:58:03.489699 #22079] DEBUG -- : SDAM | Server 127.0.0.1:27100 initializing.D, [2018-10-09T13:58:03.491384 #22079] DEBUG -- : SDAM | Server description for 127.0.0.1:27100 changed from 'unknown' to 'unknown'.D, [2018-10-09T13:58:03.491642 #22079] DEBUG -- : SDAM | Server localhost:27100 initializing.D, [2018-10-09T13:58:03.493199 #22079] DEBUG -- : SDAM | Server description for localhost:27100 changed from 'unknown' to 'primary'.D, [2018-10-09T13:58:03.493473 #22079] DEBUG -- : SDAM | Server localhost:27101 initializing.D, [2018-10-09T13:58:03.494874 #22079] DEBUG -- : SDAM | Server description for localhost:27101 changed from 'unknown' to 'secondary'.D, [2018-10-09T13:58:03.495139 #22079] DEBUG -- : SDAM | Server localhost:27102 initializing.D, [2018-10-09T13:58:03.496504 #22079] DEBUG -- : SDAM | Server description for localhost:27102 changed from 'unknown' to 'secondary'.D, [2018-10-09T13:58:03.496777 #22079] DEBUG -- : SDAM | Topology type 'Unknown' changed to type 'ReplicaSetNoPrimary'.D, [2018-10-09T13:58:03.497306 #22079] DEBUG -- : SDAM | Server 127.0.0.1:27100 connection closed.D, [2018-10-09T13:58:03.497606 #22079] DEBUG -- : SDAM | Topology type 'ReplicaSetNoPrimary' changed to type 'ReplicaSetWithPrimary'.
# client.close
D, [2018-10-09T13:58:05.342057 #22079] DEBUG -- : SDAM | Server localhost:27100 connection closed.D, [2018-10-09T13:58:05.342299 #22079] DEBUG -- : SDAM | Server localhost:27101 connection closed.D, [2018-10-09T13:58:05.342565 #22079] DEBUG -- : SDAM | Server localhost:27102 connection closed.D, [2018-10-09T13:58:05.342693 #22079] DEBUG -- : SDAM | Topology type 'ReplicaSetWithPrimary' closed.

Latidos del corazón del servidor

También puedes crear un suscriptor personalizado para supervisar los latidos del servidor, que se producen cuando el supervisor del servidor envía un comando hello al servidor.

Los suscriptores del latido personalizado del servidor difieren de otros suscriptores de SDAM, ya que deben implementar los siguientes tres métodos:

started: Se invoca cuando el escuchante recibe el latido de corazón
succeeded: Respuesta para un resultado exitoso de latido
failed: Respuesta ante un resultado fallido de latido cardíaco

El siguiente ejemplo muestra un suscriptor de eventos de latido:

class HeartbeatLogSubscriber  include Mongo::Loggable
  def started(event)    log_debug("#{event.address} | STARTED")  end
  def succeeded(event)    log_debug("#{event.address} | SUCCEEDED | #{event.duration}s")  end
  def failed(event)    log_debug("#{event.address} | FAILED | #{event.error.class}: #{event.error.message} | #{event.duration}s")  end
  private
  def logger    Mongo::Logger.logger  end
  def format_message(message)    format("HEARTBEAT | %s", message)  endend

Puedes suscribirte a eventos de latido a nivel global o para un cliente específico, como se muestra en el siguiente ejemplo:

subscriber = HeartbeatLogSubscriber.new
# Globally subscribes to Server Opening eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)
# Subscribes to Server Opening events at the client levelclient = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'test' )client.subscribe( Mongo::Monitoring::SERVER_HEARTBEAT, subscriber )

Cuando ejecuta la aplicación, su suscriptor registra el evento de latido y muestra mensajes como los siguientes:

D, [2018-09-23T13:44:10.707018 #1739] DEBUG -- : HEARTBEAT | 127.0.0.1:27027 | STARTEDD, [2018-09-23T13:44:10.707778 #1739] DEBUG -- : HEARTBEAT | 127.0.0.1:27027 | SUCCEEDED | 0.000772381s

Descripciones de eventos

La siguiente tabla provee el nombre y la descripción de cada evento SDAM:

Tipo de evento	Descripción
ServerClosed	Evento creado cuando la instancia del servidor se cierra.
ServerDescriptionChanged	Evento creado cuando se cambia la descripción de un servidor.
ServerHeartbeatFailed	Evento que se crea cuando falla un latido del servidor.
ServerHeartbeatStarted	Evento creado cuando un oyente recibe un latido del servidor.
ServerHeartbeatSucceeded	Evento creado cuando una verificación de estado del servidor es exitosa.
ServerOpening	Evento creado cuando el controlador se conecta al servidor.
TopologyChanged	Evento que se genera cuando la topología cambia.
T opologíacerrada	Evento creado cuando se cierran todas las conexiones de instancia en la topología.
TopologyOpening	Evento creado antes de que el controlador intente conectarse a una instancia.

Supervisa los 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.

Suscribirse a los eventos del pool de conexiones

Puedes acceder a detalles sobre todos los eventos del pool de conexiones suscribiéndote a ellos en tu aplicación. Se puede suscribirse a eventos a nivel global, lo que supervisa a todos los clientes de un clúster, o a nivel de cliente:

Este ejemplo demuestra las siguientes acciones:

Instancia un/a suscriptor/a CmapLogSubscriber
Usa el método Mongo::Monitoring::Global.subscribe para suscribirse a todos los eventos del pool de conexiones a nivel global.
Utiliza el método Mongo::Client.subscribe para suscribirse a todos los eventos del pool de conexiones a nivel de cliente

require 'mongo'
# Creates a subscriber for connection pool monitoringsubscriber = Mongo::Monitoring::CmapLogSubscriber.new
# Globally subscribes to connection pool monitoring eventsMongo::Monitoring::Global.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
# Replace with your connection string and connect to your clienturi = '<connection string>'client = Mongo::Client.new(uri)
# Subscribes to connection pool monitoring events at the client levelclient.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)

Descripciones de eventos

Puedes suscribirte a cualquiera de los siguientes eventos de supervisión del pool de conexiones:

Nombre del Evento	Descripción
ConexiónRevisión Fallida	Se crea cuando una operación no logra adquirir una conexión para la ejecución.
ConnectionCheckOutStarted	Se crea cuando una operación intenta adquirir 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.
ConnectionCheckedOut	Se crea cuando una operación obtiene con éxito una conexión para su ejecución.
ConnectionClosed	Se crea cuando se cierra una conexión.
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.
PoolCleared	Se crea cuando todas las conexiones están cerradas y el pool de conexiones está vaciado.
PoolClosed	Se crea cuando se cierra un pool de conexiones antes de la destrucción de la instancia del servidor.
PoolCreated	Se crea cuando se crea un pool de conexiones.
PoolReady	Se crea cuando un pool de conexiones está listo.

Documentación de la API

Para obtener más información sobre cualquiera de las clases o métodos tratados en esta guía, consulta la siguiente documentación de la API:

Volver

Búsqueda vectorial de MongoDB

Registro