Supervisar eventos de aplicaciones

Overview

En esta guía, aprenderá a usar el controlador de Scala para supervisar los eventos que ocurren durante su funcionamiento. La supervisión implica recopilar información sobre las actividades de un programa en ejecución, la cual puede utilizarse con una aplicación o una biblioteca de gestión del rendimiento de aplicaciones.

Puedes supervisar los eventos de la aplicación para comprender el uso de recursos y el rendimiento del controlador, lo que te ayuda a tomar decisiones informadas al diseñar y depurar tu aplicación.

El controlador Scala organiza los eventos que puede monitorear en las siguientes categorías:

• Eventos de comandos: Eventos relacionados con los comandos de la base de datos MongoDB.

• Eventos de detección y supervisión de servidores (SDAM): Eventos relacionados con cambios en el estado de la instancia o clúster de MongoDB al que está conectado.

• Eventos delgrupo de conexiones: Eventos relacionados con el grupo de conexiones que el controlador mantiene con una instancia de MongoDB.

Las siguientes secciones describen cada categoría de evento y muestran cómo supervisarlos. Para aprender a registrar los eventos del controlador en un archivo de registro, consulte la guía de registro.

Supervisar eventos del comando

Un evento de comando es un evento relacionado con un comando de la base de datos MongoDB. Algunos ejemplos de comandos de base de datos que generan eventos de comando son find, insert, delete y count.

El controlador Scala no publica eventos para los comandos que ejecuta internamente. Esto incluye los comandos que el controlador utiliza para supervisar el clúster y los comandos relacionados con el establecimiento de la conexión, como el comando inicial hello.

Para supervisar los eventos de comando, crea una clase que implemente la interfaz CommandListener y registra una instancia de esa clase en tu instancia de MongoClient.

Para obtener más información sobre los comandos de la base de datos MongoDB, consulte Comandos de la base de datos.

case class CommandCounter() extends CommandListener {
  private val commands =
    scala.collection.mutable.Map[String, Int]()
  override def commandStarted(event: CommandStartedEvent): Unit = {}
  override def commandSucceeded(
      event: CommandSucceededEvent
  ): Unit = {
    val commandName = event.getCommandName
    commands(commandName) =
      commands.getOrElse(commandName, 0) + 1
    println(commands.toMap)
  }
  override def commandFailed(event: CommandFailedEvent): Unit = {}
}

val settings: MongoClientSettings = MongoClientSettings
  .builder()
  .addCommandListener(CommandCounter())
  .applyConnectionString(ConnectionString("<connection string>"))
  .build()
val mongoClient: MongoClient = MongoClient(settings)

Map(find -> 1)
Map(find -> 2)
Map(find -> 2, endSessions -> 1)

Monitorear eventos SDAM

Un evento de detección y monitorización de servidores (SDAM, por sus siglas en inglés) es un evento relacionado con un cambio en el estado de la instancia o clúster de MongoDB al que está conectado.

El controlador Scala define nueve eventos SDAM y proporciona las siguientes interfaces de escucha, cada una de las cuales escucha tres eventos SDAM:

• ClusterListener: Escucha eventos relacionados con cambios de topología, o cambios en el estado y estructura del clúster

• ServerListenerEscucha eventos relacionados con cambios individuales en el servidor

• ServerMonitorListener: Escucha los eventos de latido, que informan sobre el estado de la comunicación entre los miembros del conjunto de réplicas.

Puede utilizar la información de los eventos de SDAM para comprender los cambios en el clúster, evaluar su estado o planificar la capacidad.

case class TestClusterListener(readPreference: ReadPreference) extends ClusterListener {
  var isWritable: Boolean = false
  var isReadable: Boolean = false
  override def clusterOpening(event: ClusterOpeningEvent): Unit =
      println(s"Cluster with ID ${event.getClusterId} opening")
  override def clusterClosed(event: ClusterClosedEvent): Unit =
      println(s"Cluster with ID ${event.getClusterId} closed")
  override def clusterDescriptionChanged(event: ClusterDescriptionChangedEvent): Unit = {
      if (!isWritable) {
          if (event.getNewDescription.hasWritableServer) {
              isWritable = true
              println("Writable server available")
          }
      } else {
          if (!event.getNewDescription.hasWritableServer) {
              isWritable = false
              println("No writable server available")
          }
      }
      if (!isReadable) {
          if (event.getNewDescription.hasReadableServer(readPreference)) {
              isReadable = true
              println("Readable server available")
          }
      } else {
          if (!event.getNewDescription.hasReadableServer(readPreference)) {
              isReadable = false
              println("No readable server available")
          }
      }
  }
}

val uri: ConnectionString = ConnectionString("<connection string>")
val settings: MongoClientSettings = MongoClientSettings
    .builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) =>
            builder.addClusterListener(TestClusterListener(ReadPreference.secondary())))
    .applyConnectionString(uri)
    .build()
val client: MongoClient = MongoClient(settings)

Cluster with ID ClusterId{value='...', description='...'} opening
Writable server available
Readable server available
Cluster with ID ClusterId{value='...', description='...'} closed

Supervisa los eventos del grupo de conexiones

Un evento de grupo de conexiones es un evento relacionado con el grupo de conexiones que el controlador mantiene con una instancia de MongoDB. Un grupo de conexiones es un conjunto de conexiones TCP abiertas que el controlador mantiene con una instancia de MongoDB. Los grupos de conexiones reducen la cantidad de protocolos de enlace de red que su aplicación necesita realizar y pueden ayudar a que su aplicación se ejecute más rápido.

Para supervisar los eventos del grupo de conexiones, cree una clase que implemente la interfaz ConnectionPoolListener y registre una instancia de esa clase con su instancia MongoClient.

case class ConnectionPoolLibrarian()
    extends ConnectionPoolListener {
  override def connectionCheckedOut(
      event: ConnectionCheckedOutEvent
  ): Unit =
    println(
      s"Let me get you the connection with id " +
        s"${event.getConnectionId.getLocalValue}..."
    )
  override def connectionCheckOutFailed(
      event: ConnectionCheckOutFailedEvent
  ): Unit = {}
}

val settings: MongoClientSettings = MongoClientSettings
  .builder()
  .applyToConnectionPoolSettings(
    (builder: ConnectionPoolSettings.Builder) =>
      builder.addConnectionPoolListener(
        ConnectionPoolLibrarian()
      )
  )
  .applyConnectionString(ConnectionString("<connection string>"))
  .build()
val mongoClient: MongoClient = MongoClient(settings)

Let me get you the connection with id 1...

Documentación de la API

Para obtener más información sobre los métodos y tipos tratados en esta guía, consulta la siguiente documentación de la API:

• CommandListener

• EventoComandoIniciado

• CommandSucceededEvent

• CommandFailedEvent

• ClusterListener

• ServerListener

• ServerMonitorListener

• ClusterDescriptionChangedEvent

• clusterOpening()

• clusterClosed()

• Descripción del clúster modificada()

• ConnectionPoolListener

• Evento creado por grupo de conexiones

• Evento ConnectionPoolReady

• Evento ConnectionPoolClosed

• ConnectionCreatedEvent

• ConnectionReadyEvent

• ConnectionClosedEvent

• ConnectionCheckOutStartedEvent

• ConnectionCheckedOutEvent

• ConnectionCheckOutFailedEvent

• ConnectionCheckedInEvent

• Evento ConnectionPoolCleared

• MongoClientSettings

• event paquete