Menu Docs
Página inicial do Docs
/
Idiomas
/
Java
/
Driver de fluxos reativos do Java
/
Referência

Monitoramento JMX

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 motorista.

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 :

MongoClientSettings settings =
    MongoClientSettings.builder()
        .applyToConnectionPoolSettings(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 :

public class TestCommandListener implements CommandListener {
    @Override
    public void commandStarted(final CommandStartedEvent event) {
        System.out.println(String.format("Sent command '%s:%s' with id %s to database '%s' "
                                         + "on connection '%s' to server '%s'",
                                         event.getCommandName(),
                                         event.getCommand().get(event.getCommandName()),
                                         event.getRequestId(),
                                         event.getDatabaseName(),
                                         event.getConnectionDescription()
                                              .getConnectionId(),
                                         event.getConnectionDescription().getServerAddress()));
    }
    @Override
    public void commandSucceeded(final CommandSucceededEvent event) {
        System.out.println(String.format("Successfully executed command '%s' with id %s "
                                         + "on connection '%s' to server '%s'",
                                         event.getCommandName(),
                                         event.getRequestId(),
                                         event.getConnectionDescription()
                                              .getConnectionId(),
                                         event.getConnectionDescription().getServerAddress()));
    }
    @Override
    public void commandFailed(final CommandFailedEvent event) {
        System.out.println(String.format("Failed execution of command '%s' with id %s "
                                         + "on connection '%s' to server '%s' with exception '%s'",
                                         event.getCommandName(),
                                         event.getRequestId(),
                                         event.getConnectionDescription()
                                              .getConnectionId(),
                                         event.getConnectionDescription().getServerAddress(),
                                         event.getThrowable()));
    }
}

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

MongoClientSettings settings = MongoClientSettings.builder()
    .addCommandListener(new TestCommandListener())
    .build();
MongoClient client = MongoClients.create(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:

public class TestClusterListener implements ClusterListener {
    private final ReadPreference readPreference;
    private boolean isWritable;
    private boolean isReadable;
    public TestClusterListener(final ReadPreference readPreference) {
        this.readPreference = readPreference;
    }
    @Override
    public void clusterOpening(final ClusterOpeningEvent clusterOpeningEvent) {
        System.out.println(String.format("Cluster with unique client identifier %s opening",
                clusterOpeningEvent.getClusterId()));
    }
    @Override
    public void clusterClosed(final ClusterClosedEvent clusterClosedEvent) {
        System.out.println(String.format("Cluster with unique client identifier %s closed",
                clusterClosedEvent.getClusterId()));
    }
    @Override
    public void clusterDescriptionChanged(final ClusterDescriptionChangedEvent event) {
        if (!isWritable) {
            if (event.getNewDescription().hasWritableServer()) {
                isWritable = true;
                System.out.println("Writable server available!");
            }
        } else {
            if (!event.getNewDescription().hasWritableServer()) {
                isWritable = false;
                System.out.println("No writable server available!");
            }
        }
        if (!isReadable) {
            if (event.getNewDescription().hasReadableServer(readPreference)) {
                isReadable = true;
                System.out.println("Readable server available!");
            }
        } else {
            if (!event.getNewDescription().hasReadableServer(readPreference)) {
                isReadable = false;
                System.out.println("No readable server available!");
            }
        }
    }
}

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

List<ServerAddress> seedList = ...
MongoClientSettings settings = MongoClientSettings.builder()
    .applyToClusterSettings(builder ->
        builder.addClusterListener(new TestClusterListener(ReadPreference.secondary())))
    .build();
MongoClient client = MongoClients.create(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 :

public class TestConnectionPoolListener implements ConnectionPoolListener {
    @Override
    public void connectionPoolOpened(final ConnectionPoolOpenedEvent event) {
        System.out.println(event);
    }
    @Override
    public void connectionPoolClosed(final ConnectionPoolClosedEvent event) {
        System.out.println(event);
    }
    @Override
    public void connectionCheckedOut(final ConnectionCheckedOutEvent event) {
        System.out.println(event);
    }
    @Override
    public void connectionCheckedIn(final ConnectionCheckedInEvent event) {
        System.out.println(event);
    }
    @Override
    public void connectionAdded(final ConnectionAddedEvent event) {
        System.out.println(event);
    }
    @Override
    public void connectionRemoved(final ConnectionRemovedEvent event) {
        System.out.println(event);
    }
}

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

List<ServerAddress> seedList = ...
MongoClientSettings settings = MongoClientSettings.builder()
    .applyToConnectionPoolSettings(builder ->
        builder.addConnectionPoolListener(new TestConnectionPoolListener()))
    .build();
MongoClient client = MongoClients.create(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