Monitoramento

Eventos de comando

Um evento de comando é um evento relacionado a um comando do banco de dados MongoDB. Alguns exemplos de comandos do banco de dados que produzem eventos de comando são find, insert, delete e count.

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

Para obter mais informações sobre comandos do banco de dados MongoDB, consulte a entrada manual do MongoDB em comandos do banco de dados.

class CommandCounter : CommandListener {
    private val commands = mutableMapOf<String, Int>()
    @Synchronized
    override fun commandSucceeded(event: CommandSucceededEvent) {
        val commandName = event.commandName
        val count = commands[commandName] ?: 0
        commands[commandName] = count + 1
        println(commands.toString())
    }
    override fun commandFailed(event: CommandFailedEvent) {
        println("Failed execution of command '${event.commandName}' with id ${event.requestId}")
    }
}

val commandCounter = CommandCounter()
val settings = MongoClientSettings.builder()
    .applyConnectionString(URI)
    .addCommandListener(commandCounter)
    .build()
val mongoClient = MongoClient.create(settings)
val database = mongoClient.getDatabase(DATABASE)
val collection = database.getCollection<Document>(COLLECTION)
// Run some commands to test the counter
collection.find().firstOrNull()
collection.find().firstOrNull()

{find=1}
{find=2}
{find=2, endSessions=1}

Eventos de descoberta e monitoramento de servidores

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ê conectou o driver.

O driver define nove eventos SDAM. O driver divide esses nove eventos entre três interfaces de ouvinte separadas, cada uma ouvindo três dos nove eventos. Aqui estão as três interfaces e os eventos que elas escutam:

• ClusterListener: eventos relacionados à topologia

• ServerListener: eventos relacionados a processos mongod ou mongos

• ServerMonitorListener: eventos relacionados ao batimento cardíaco

Para monitorar um tipo de evento SDAM, escreva uma classe que implemente uma das três interfaces anteriores e registre uma instância dessa classe com sua instância MongoClient.

Para obter uma descrição detalhada de cada evento SDAM, consulte Especificação de eventos de monitoramento SDAM do MongoDB.

class IsWriteable : ClusterListener {
    private var isWritable = false
    @Synchronized
    override fun clusterDescriptionChanged(event: ClusterDescriptionChangedEvent) {
        if (!isWritable) {
            if (event.newDescription.hasWritableServer()) {
                isWritable = true
                println("Able to write to cluster")
            }
        } else {
            if (!event.newDescription.hasWritableServer()) {
                isWritable = false
                println("Unable to write to cluster")
            }
        }
    }
}

val clusterListener = IsWriteable()
val settings = MongoClientSettings.builder()
    .applyConnectionString(URI)
    .applyToClusterSettings { builder ->
        builder.addClusterListener(clusterListener)
    }
    .build()
val mongoClient = MongoClient.create(settings)
val database = mongoClient.getDatabase(DATABASE)
val collection = database.getCollection<Document>(COLLECTION)
// Run a command to trigger a ClusterDescriptionChangedEvent event
collection.find().firstOrNull()

Able to write to server

Eventos do pool de conexões

Um evento de pool de conexões é um evento relacionado a um pool de conexões mantido pelo driver. Um pool de conexões é um conjunto de conexões TCP abertas que seu driver mantém com uma instância MongoDB. Os pools de conexão ajudam a reduzir o número de handshakes de rede que seu aplicativo precisa realizar com uma instância do MongoDB e podem ajudar seu aplicativo a ser executado mais rapidamente.

Para monitorar eventos do pool de conexões, escreva uma classe que implemente a interface ConnectionPoolListener e registre uma instância dessa classe com sua instância MongoClient.

class ConnectionPoolLibrarian : ConnectionPoolListener {
    override fun connectionCheckedOut(event: ConnectionCheckedOutEvent) {
        println("Let me get you the connection with id ${event.connectionId.localValue}...")
    }
    override fun connectionCheckOutFailed(event: ConnectionCheckOutFailedEvent) {
        println("Something went wrong! Failed to checkout connection.")
    }
}

val cpListener = ConnectionPoolLibrarian()
val settings = MongoClientSettings.builder()
    .applyConnectionString(URI)
    .applyToConnectionPoolSettings { builder ->
        builder.addConnectionPoolListener(cpListener)
    }
    .build()
val mongoClient = MongoClient.create(settings)
val database = mongoClient.getDatabase(DATABASE)
val collection = database.getCollection<Document>(COLLECTION)
// Run a command to trigger connection pool events
collection.find().firstOrNull()

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

Suporte a JMX

Para habilitar o monitoramento do pool de conexões JMX, adicione uma instância da classe JMXConnectionPoolListener ao seu objeto MongoClient.

A classe JMXConnectionPoolListener executa as seguintes ações:

1. Cria instâncias de MXBean para cada processo do mongod ou mongos com o qual o driver mantém um pool de conexão.

2. Registra estas instâncias MXBean com o servidor MBean da plataforma.

Os MXBeans registrados no servidor MBean da plataforma têm as seguintes propriedades:

Todas as instâncias MXBean criadas pelo driver estão sob o domínio "org.mongodb.driver".

Para obter mais informações sobre os tópicos discutidos nesta subseção, consulte os seguintes recursos da Oracle:

• Documentação de Referência do Servidor MBean da Plataforma

• Documentação de MXBean

• Documentação do MBean

Exemplo de JMX e JConsole

Este exemplo mostra como você pode monitorar os pools de conexão do driver usando JMX e JConsole. JConsole é uma ferramenta de monitoramento de GUI compatível com JMX que vem com a Java Platform.

O seguinte trecho de código adiciona um JMXConnectionPoolListener a uma instância do MongoClient. O código então pausa a execução para que você possa navegar até o JConsole e inspecionar seus pools de conexão.

val connectionPoolListener = JMXConnectionPoolListener()
val settings = MongoClientSettings.builder()
    .applyConnectionString(uri)
    .applyToConnectionPoolSettings {
        it.addConnectionPoolListener(connectionPoolListener)
    }
    .build()
val mongoClient: MongoClient = MongoClient.create(settings)
try {
    println("Navigate to JConsole to see your connection pools...")
    Thread.sleep(Long.MAX_VALUE)
} catch (e: Exception) {
    e.printStackTrace()
}

Navigate to JConsole to see your connection pools...

Após iniciar seu servidor, abra o JConsole em seu terminal utilizando o seguinte comando:

jconsole

Quando o JConsole estiver aberto, realize as seguintes ações na interface do usuário:

1. Selecione o processo que executa o código de exemplo anterior.

2. Pressione Insecure Connection na caixa de diálogo de aviso.

3. Clique na aba MBeans.

4. Inspecione os eventos do pool de conexões no domínio "org.mongodb.driver".

Quando você não quiser mais inspecionar seus pools de conexão no JConsole, faça o seguinte:

• Sair do JConsole fechando a janela do JConsole

• Pare o programa executando o trecho de código anterior

Para obter mais informações sobre JMX e JConsole, consulte os seguintes recursos da Oracle:

• Documentação do JConsole.

• Guia de monitoramento e gerenciamento

Para mais informações sobre a classe JMXConnectionPoolListener, consulte a documentação da API para JMXConnectionPoolListener.