Monitoramento

Nesta página

Monitoramento de comandos

Monitoramento de clusters
Monitoramento de pool de conexões

O driver usa JMX para criar MXBeans que permitem monitorar vários aspectos do driver.

O driver cria instâncias MXBean de um único tipo, ConnectionPoolStatisticsMBean. O driver registra uma instância ConnectionPoolStatisticsMBean para cada servidor ao qual se conecta. Por exemplo, quando conectado a um conjunto de réplicas, o driver cria uma instância para cada membro não oculto do conjunto de réplicas.

Cada instância MXBean deve ser registrada com um nome de objeto exclusivo, que consiste em um domínio e um conjunto de propriedades nomeadas. Todas as instâncias do MXBean criadas pelo driver estão sob o domínio org.mongodb.driver. As instâncias de ConnectionPoolStatisticsMBean têm as seguintes propriedades:

clusterId: um identificador exclusivo gerado pelo cliente, necessário para garantir a exclusividade do nome do objeto em situações em que um aplicação tenha várias instâncias MongoClient conectadas ao mesmo sistema do servidor MongoDB
host: o nome do host do servidor
port: a porta na qual o servidor está escutando
minSize: o tamanho mínimo permitido do pool, incluindo membros ociosos e em uso
maxSize: o tamanho máximo permitido do pool, incluindo membros ociosos e em uso
size: o tamanho atual do pool, incluindo membros ociosos e em uso
checkedOutCount: a contagem atual de conexões que estão em uso no momento

O monitoramento do pool de conexões JMX está desabilitado por padrão. Para habilitá-lo, adicione uma instância com.mongodb.management.JMXConnectionPoolListener ao criar uma instância MongoClientSettings :

val settings: MongoClientSettings =
        MongoClientSettings.builder()
        .applyToConnectionPoolSettings((builder: ConnectionPoolSettings.Builder) => builder.addConnectionPoolListener(new JMXConnectionPoolListener()))
        .build()

Monitoramento de comandos

O driver implementa a especificação de monitoramento de comando, permitindo que um aplicação seja notificado quando um comando é iniciado e quando ele é bem-sucedido ou falha.

Um aplicação registra ouvintes de comando com um MongoClient configurando uma instância do MongoClientSettings com instâncias de classes que implementam a interface do CommandListener . O exemplo a seguir é uma implementação simples da interface do CommandListener :

case class TestCommandListener() extends CommandListener {
  override def commandStarted(event: CommandStartedEvent): Unit = {
    println(s"""Sent command '${event.getCommandName}:${event.getCommand.get(event.getCommandName)}'
         | with id ${event.getRequestId} to database '${event.getDatabaseName}'
         | on connection '${event.getConnectionDescription.getConnectionId}' to server
         | '${event.getConnectionDescription.getServerAddress}'""".stripMargin)
  }
  override def commandSucceeded(event: CommandSucceededEvent): Unit = {
    println(s"""Successfully executed command '${event.getCommandName}}'
               | with id ${event.getRequestId}
               | on connection '${event.getConnectionDescription.getConnectionId}' to server
               | '${event.getConnectionDescription.getServerAddress}'""".stripMargin)
  }
  override def commandFailed(event: CommandFailedEvent): Unit = {
    println(s"""Failed execution of command '${event.getCommandName}}'
               | with id ${event.getRequestId}
               | on connection '${event.getConnectionDescription.getConnectionId}' to server
               | '${event.getConnectionDescription.getServerAddress}
               | with exception '${event.getThrowable}'""".stripMargin)
  }
}

O exemplo seguinte cria uma instância do MongoClientSettings configurada com uma instância do TestCommandListener:

val settings: MongoClientSettings = MongoClientSettings.builder()
        .addCommandListener(TestCommandListener())
        .build()
val client: MongoClient = MongoClient(settings)

Um MongoClient configurado com estas opções imprime uma mensagem para System.out antes de enviar cada comando para um servidor MongoDB e imprime outra mensagem após a conclusão bem-sucedida ou falha de cada comando.

Monitoramento de clusters

O driver implementa a especificação de monitoramento SDAM, permitindo que um aplicação seja notificado quando o driver detectar alterações na topologia do cluster MongoDB ao qual está conectado.

Um aplicativo registra ouvintes com um MongoClient configurando MongoClientSettings com instâncias de classes que implementam qualquer uma das interfaces ClusterListener, ServerListener ou ServerMonitorListener .

O seguinte código demonstra como criar um ouvinte de cluster:

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 unique client identifier ${event.getClusterId} opening")
  override def clusterClosed(event: ClusterClosedEvent): Unit =
    println(s"Cluster with unique client identifier ${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!")
      }
    }
  }
}

O exemplo seguinte cria uma instância do MongoClientSettings configurada com uma instância do TestClusterListener:

val settings: MongoClientSettings = MongoClientSettings.builder()
        .applyToClusterSettings((builder: ClusterSettings.Builder) =>
                builder.addClusterListener(TestClusterListener(ReadPreference.secondary())))
        .build()
val client: MongoClient = MongoClient(settings)

Um MongoClient configurado com estas opções imprime uma mensagem para System.out quando o MongoClient é criado com estas opções e quando este MongoClient é fechado. Além disso, ele imprime uma mensagem quando o cliente insere qualquer um dos seguintes estados:

Tem um servidor disponível que aceitará gravações
Não tiver um servidor disponível que aceite gravações
Tem um servidor disponível que aceitará leituras usando o configurado ReadPreference
Não tiver um servidor disponível que aceite leituras usando o configurado ReadPreference

Monitoramento de pool de conexões

O driver suporta o monitoramento de eventos relacionados ao pool de conexões.

Um aplicativo registra ouvintes com um MongoClient configurando MongoClientSettings com instâncias de classes que implementam a interface ConnectionPoolListener .

O seguinte código demonstra como criar um ouvinte do pool de conexões :

case class TestConnectionPoolListener() extends ConnectionPoolListener {
  override def connectionPoolOpened(event: ConnectionPoolOpenedEvent): Unit = println(event)
  override def connectionPoolClosed(event: ConnectionPoolClosedEvent): Unit = println(event)
  override def connectionCheckedOut(event: ConnectionCheckedOutEvent): Unit = println(event)
  override def connectionCheckedIn(event: ConnectionCheckedInEvent): Unit = println(event)
  override def waitQueueEntered(event: ConnectionPoolWaitQueueEnteredEvent): Unit = println(event)
  override def waitQueueExited(event: ConnectionPoolWaitQueueExitedEvent): Unit = println(event)
  override def connectionAdded(event: ConnectionAddedEvent): Unit = println(event)
  override def connectionRemoved(event: ConnectionRemovedEvent): Unit = println(event)
}

O exemplo seguinte cria uma instância do MongoClientSettings configurada com uma instância do TestConnectionPoolListener:

val settings: MongoClientSettings = MongoClientSettings.builder()
        .applyToConnectionPoolSettings((builder: ConnectionPoolSettings.Builder) =>
                builder.addConnectionPoolListener(TestConnectionPoolListener()))
        .build()
val client: MongoClient = MongoClient(settings)

Um MongoClient configurado com estas opções imprime uma mensagem em System.out para cada evento relacionado ao pool de conexões para cada servidor MongoDB ao qual o MongoClient está conectado.

Voltar

Exploração madeireira

Observables