Monitorar eventos de aplicativos

Visão geral

Neste guia, você pode aprender como usar o driver Scala para monitorar eventos que ocorrem durante a operação do driver. O monitoramento envolve a coleta de informações sobre as atividades de um programa em execução, que você pode usar com um aplicativo ou uma biblioteca de gerenciamento de desempenho de aplicativo.

Você pode monitorar eventos de aplicativo para entender o uso e o desempenho dos recursos do driver, o que ajuda a tomar decisões informadas ao projetar e depurar seu aplicativo.

O driver Scala organiza os eventos que você pode monitorar nas seguintes categorias:

• Eventos de comando: eventos relacionados a comandos de banco de dados MongoDB

• Eventos de descoberta e monitoramento de servidor (SDAM): Eventos relacionados a alterações no estado da instância ou cluster do MongoDB ao qual você está conectado

• Evento do pool de conexões: Evento relacionado ao pool de conexões que o driver mantém com uma instância do MongoDB

As seções a seguir descrevem cada categoria de evento e mostram como monitorar eventos. Para aprender a registrar eventos de driver em um log, consulte o guia Logging.

Monitorar eventos de comando

Um evento de comando é um evento relacionado a um comando de banco de dados MongoDB. Exemplos de comandos de banco de dados que produzem eventos de comando incluem find, insert, delete e count.

O driver Scala não publica eventos para comandos que chama internamente. Isso inclui comandos que o driver usa para monitorar seu cluster e comandos relacionados ao estabelecimento de conexão, como o comando hello inicial.

Para monitorar eventos de comando, crie uma classe que implemente a interface do CommandListener e registre uma instância dessa classe com sua instância do MongoClient .

Para aprender mais sobre os comandos do banco de dados MongoDB, consulte Comandos de banco de dados.

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)

Monitorar evento SDAM

Um evento de descoberta e monitoramento de servidor (SDAM) é um evento relacionado a uma alteração no estado da instância MongoDB ou cluster ao qual você está conectado.

O driver Scala define nove eventos SDAM e fornece as seguintes interfaces de ouvinte, que escutam três eventos SDAM cada:

• ClusterListener: Ouve eventos relacionados a alterações de topologia ou alterações no estado e na estrutura do cluster

• ServerListener: escuta eventos relacionados a alterações individuais do servidor

• ServerMonitorListener: escuta eventos de pulsação, que relatam o status da comunicação entre os nós do conjunto de réplicas

Você pode usar informações de eventos SDAM para entender as alterações do cluster, avaliar a integridade do cluster ou planejar a capacidade.

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

Monitorar eventos do pool de conexões

Um evento de pool de conexões é um evento relacionado ao pool de conexões que o driver mantém com uma instância do MongoDB. Um pool de conexões é um conjunto de conexões TCP abertas que seu driver mantém com uma instância do MongoDB. Os pools de conexões reduzem o número de negociações de rede que seu aplicativo precisa executar e podem ajudar seu aplicativo a ser executado mais rapidamente.

Para monitorar eventos do pool de conexões , crie uma classe que implemente a interface ConnectionPoolListener e registre uma instância dessa classe com sua instância 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...

Documentação da API

Para saber mais sobre os métodos e tipos discutidos neste guia, consulte a seguinte documentação da API:

• CommandListener

• CommandStartedEvent

• CommandSucceededEvent

• CommandFailedEvent

• ClusterListener

• ServerListener

• ServerMonitorListener

• ClusterDescriptionChangedEvent

• clusterOpening()

• clusterClosed()

• clusterDescriptionChanged()

• ConnectionPoolListener

• ConnectionPoolCreatedEvent

• ConnectionPoolReadyEvent

• ConnectionPoolClosedEvent

• ConnectionCreatedEvent

• ConnectionReadyEvent

• ConnectionClosedEvent

• ConnectionCheckOutStartedEvent

• ConnectionCheckedOutEvent

• ConnectionCheckOutFailedEvent

• ConnectionCheckedInEvent

• ConnectionPoolClearedEvent

• Configurações do Mongo Client

• Pacote de evento