Monitoring

Eventos de comando

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

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

Para más información sobre comandos de base de datos de MongoDB, consulta la entrada del manual de MongoDB sobre comandos de base de datos.

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 Descubrimiento y Supervisión de Servidores

Un evento de descubrimiento y monitoreo de servidor (SDAM) es un evento relacionado con un cambio en el estado de la instancia o el clúster de MongoDB al que ha conectado el controlador.

El driver define nueve eventos SDAM. El controlador divide estos nueve eventos entre tres interfaces diferentes de escucha, cada una de las cuales escucha tres de los nueve eventos. Aquí están las tres Interfaces y los eventos a los que escuchan:

• ClusterListener: eventos relacionados con la topología

• ServerListenereventos relacionados con mongod o mongos procesos

• ServerMonitorListener: eventos relacionados con el latido cardíaco

Para supervisar un tipo de evento SDAM, guarda una clase que implemente una de las tres interfaces anteriores y registra una instancia de esa clase con tu instancia de MongoClient.

Para obtener una descripción detallada de cada evento SDAM, consulte la especificación de eventos de monitoreo SDAM de 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 del grupo de conexiones

Un evento de grupo de conexiones es un evento relacionado con un grupo de conexiones que el controlador mantiene. Un grupo de conexiones es un conjunto de conexiones TCP abiertas que el controlador mantiene con una instancia de MongoDB. Los grupos de conexiones ayudan a reducir el número de protocolos de enlace de red que la aplicación debe realizar con una instancia de MongoDB y pueden acelerar su ejecución. Para obtener más información sobre los grupos de conexiones, consulte la sección "Grupos de conexiones" de la guía "Conectarse a MongoDB".

Para supervisar los eventos del pool de conexiones, escribe una clase que implemente la interfaz ConnectionPoolListener y registra una instancia de esa clase con tu instancia 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...

Soporte JMX

Para habilitar la supervisión del pool de conexiones JMX, agrega una instancia de la clase JMXConnectionPoolListener a tu objeto MongoClient.

La clase JMXConnectionPoolListener realiza las siguientes acciones:

1. Crea instancias de MXBean para cada proceso mongod o mongos con el que el driver mantiene un pool de conexiones.

2. Registra estas instancias MXBean con el servidor MBean de la plataforma.

Los MXBeans registrados en el servidor MBean de la plataforma tienen las siguientes propiedades:

Todas las instancias de MXBean creadas por el driver están bajo el dominio "org.mongodb.driver".

Para obtener más información sobre los temas tratados en esta subsección, consulta los siguientes recursos de Oracle:

• Documentación de referencia del servidor de la plataforma MBean

• Documentación de MXBean

• Documentación de MBean

Ejemplo de JMX y JConsole

Este ejemplo muestra cómo supervisar los grupos de conexiones del controlador mediante JMX y JConsole. JConsole es una herramienta de monitorización de interfaz gráfica de usuario (GUI) compatible con JMX que se incluye en la plataforma Java.

El siguiente fragmento de código añade una instancia JMXConnectionPoolListener a una instancia MongoClient. El código pausa la ejecución para que puedas acceder a JConsole e inspeccionar tus grupos de conexiones.

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

Una vez que haya iniciado su servidor, abra JConsole en su terminal usando el siguiente comando:

jconsole

Una vez abierto JConsole, realice las siguientes acciones en la GUI:

1. Seleccione el proceso que ejecuta el código de ejemplo anterior.

2. Presiona Insecure Connection en el cuadro de diálogo de advertencia.

3. Haz clic en la pestaña MBeans.

4. Inspeccione los eventos de su grupo de conexiones bajo el dominio "org.mongodb.driver".

Cuando ya no desee inspeccionar sus grupos de conexiones en JConsole, haga lo siguiente:

• Salga de JConsole cerrando la ventana de JConsole

• Detener el programa que ejecuta el fragmento de código anterior

Para obtener más información sobre JMX y JConsole, consulta los siguientes recursos de Oracle:

• JConsole Documentación.

• Guía de Supervisión y Gestión

Para obtener más información sobre la clase JMXConnectionPoolListener, consulta la Documentación de la API de JMXConnectionPoolListener.