MongoDB registra todas las consultas

La pregunta es tan básica como simple ... ¿Cómo se registran todas las consultas en un archivo de registro capaz de "cola" en mongodb?

Yo he tratado:

• establecer el nivel de perfil
• configurar el inicio lento del parámetro ms
• mongod con la opción -vv

El /var/log/mongodb/mongodb.log sigue mostrando solo el número actual de conexiones activas ...

Puede registrar todas las consultas:

$ mongo
MongoDB shell version: 2.4.9
connecting to: test
> use myDb
switched to db myDb
> db.getProfilingLevel()
0
> db.setProfilingLevel(2)
{ "was" : 0, "slowms" : 1, "ok" : 1 }
> db.getProfilingLevel()
2
> db.system.profile.find().pretty()

Fuente: http://docs.mongodb.org/manual/reference/method/db.setProfilingLevel/

db.setProfilingLevel(2) significa "registrar todas las operaciones".

Terminé resolviendo esto comenzando mongod de esta manera (martillado y feo, sí ... pero funciona para el entorno de desarrollo):

mongod --profile=1 --slowms=1 &

Esto permite la creación de perfiles y establece el umbral para "consultas lentas" como 1 ms, lo que hace que todas las consultas se registren como "consultas lentas" en el archivo:

/var/log/mongodb/mongodb.log

Ahora obtengo salidas de registro continuas usando el comando:

tail -f /var/log/mongodb/mongodb.log

Un ejemplo de registro:

Mon Mar  4 15:02:55 [conn1] query dendro.quads query: { graph: "u:http://example.org/people" } ntoreturn:0 ntoskip:0 nscanned:6 keyUpdates:0 locks(micros) r:73163 nreturned:6 reslen:9884 88ms

Porque es Google primera respuesta ...
Para la versión 3

$ mongo
MongoDB shell version: 3.0.2
connecting to: test
> use myDb
switched to db
> db.setLogLevel(1)

http://docs.mongodb.org/manual/reference/method/db.setLogLevel/

MongoDBtiene una característica sofisticada de perfilado. El registro ocurre en la system.profilecolección. Los registros se pueden ver desde:

db.system.profile.find()

Hay 3 niveles de registro ( fuente ):

• Nivel 0 : el generador de perfiles está apagado, no recopila ningún dato. mongod siempre escribe operaciones más largas que el umbral slowOpThresholdMs en su registro. Este es el nivel de perfil predeterminado.
• Nivel 1 : recopila datos de perfiles solo para operaciones lentas. Por defecto, las operaciones lentas son aquellas más lentas que 100 milisegundos. Puede modificar el umbral para operaciones "lentas" con la opción de tiempo de ejecución slowOpThresholdMs o el comando setParameter. Consulte la sección Especificar el umbral para operaciones lentas para obtener más información.
• Nivel 2 : recopila datos de perfiles para todas las operaciones de la base de datos.

Para ver en qué nivel de perfil se está ejecutando la base de datos, use

db.getProfilingLevel()

y para ver el estado

db.getProfilingStatus()

Para cambiar el estado del perfil, use el comando

db.setProfilingLevel(level, milliseconds)

Donde se levelrefiere al nivel de creación de perfiles y millisecondses el tiempo de duración de las consultas que deben registrarse. Para desactivar el registro, use

db.setProfilingLevel(0)

La consulta para buscar en la colección de perfiles del sistema todas las consultas que tomaron más de un segundo, ordenadas por marca de tiempo descendente, será

db.system.profile.find( { millis : { $gt:1000 } } ).sort( { ts : -1 } )

Hice una herramienta de línea de comandos para activar la actividad del generador de perfiles y ver los registros de una manera capaz de "cola" : "mongotail" .

Pero la característica más interesante (también me gusta tail) es ver los cambios en "tiempo real" con la -fopción, y ocasionalmente filtrar el resultado greppara encontrar una operación en particular.

Consulte la documentación y las instrucciones de instalación en: https://github.com/mrsarm/mongotail

Una vez perfilado nivel se ajusta utilizando db.setProfilingLevel(2).

El siguiente comando imprimirá la última consulta ejecutada.
También puede cambiar el límite (5) para ver menos / más consultas.
$ nin: filtrará las consultas de perfil e índices
Además, use la proyección de consulta {'query': 1} para ver solo el campo de consulta

db.system.profile.find(
{ 
    ns: { 
        $nin : ['meteor.system.profile','meteor.system.indexes']
    }
} 
).limit(5).sort( { ts : -1 } ).pretty()

Registros con solo proyección de consulta

db.system.profile.find(
{ 
    ns: { 
        $nin : ['meteor.system.profile','meteor.system.indexes']
    }
},
{'query':1}
).limit(5).sort( { ts : -1 } ).pretty()

si desea que las consultas se registren en el archivo de registro mongodb, debe establecer tanto el nivel de registro como el perfil, como por ejemplo:

db.setLogLevel(1)
db.setProfilingLevel(2)

(ver https://docs.mongodb.com/manual/reference/method/db.setLogLevel )

Establecer solo el perfil no tendría las consultas registradas en el archivo, por lo que solo puede obtenerlo de

db.system.profile.find().pretty()

Los datos del generador de perfiles se escriben en una colección en su base de datos, no en un archivo. Ver http://docs.mongodb.org/manual/tutorial/manage-the-database-profiler/

Recomendaría usar el servicio MMS de 10gen y alimentar los datos del generador de perfiles de desarrollo allí, donde puede filtrarlos y ordenarlos en la interfaz de usuario.

Creo que aunque no es elegante, el blog podría usarse parcialmente para este propósito: registra todas las escrituras, pero no las lecturas ...

Tienes que habilitar replicatoon, si tengo razón. La información proviene de esta respuesta de esta pregunta: ¿Cómo escuchar los cambios en una colección MongoDB?

Establecer profilinglevel en 2 es otra opción para registrar todas las consultas.

Recomiendo visitar mongosniff. Esta herramienta puede hacer todo lo que quieras y más. Especialmente puede ayudar a diagnosticar problemas con sistemas mongo de mayor escala y cómo se enrutan las consultas y de dónde provienen, ya que funciona al escuchar su interfaz de red para todas las comunicaciones relacionadas con mongo.

http://docs.mongodb.org/v2.2/reference/mongosniff/

Escribí un script que imprimirá el registro del perfil del sistema en tiempo real a medida que entren las consultas. Primero debe habilitar el registro como se indica en otras respuestas. Necesitaba esto porque estoy usando el Subsistema de Windows para Linux, para el cual la cola todavía no funciona.

https://github.com/dtruel/mongo-live-logger

db.adminCommand( { getLog: "*" } )

Luego

db.adminCommand( { getLog : "global" } )

Esto se preguntó hace mucho tiempo, pero aún puede ayudar a alguien:

El generador de perfiles MongoDB registra todas las consultas en el sistema de recopilación con tope.perfil . Ver esto: perfil de base de datos

1. Inicie la instancia mongod con la --profile=2opción que permite registrar todas las consultas O si las instancias mongod ya se están ejecutando, desde mongoshell, ejecute db.setProfilingLevel(2)después de seleccionar la base de datos. (se puede verificar por db.getProfilingLevel(), que debería volver 2)
2. Después de esto, he creado un script que utiliza el cursor de Taong de mongodb para ajustar esta colección system.profile y escribir las entradas en un archivo. Para ver los registros que sólo tiene que la cola es: tail -f ../logs/mongologs.txt. Este script se puede iniciar en segundo plano y registrará todas las operaciones en la base de datos del archivo.

Mi código para el cursor disponible para la colección system.profile está en nodejs; registra todas las operaciones junto con las consultas que ocurren en cada colección de MyDb:

const MongoClient = require('mongodb').MongoClient;
const assert = require('assert');
const fs = require('fs');
const file = '../logs/mongologs'
// Connection URL
const url = 'mongodb://localhost:27017';

// Database Name
const dbName = 'MyDb';
//Mongodb connection

MongoClient.connect(url, function (err, client) {
   assert.equal(null, err);
   const db = client.db(dbName);
   listen(db, {})
});

function listen(db, conditions) {
var filter = { ns: { $ne: 'MyDb.system.profile' } }; //filter for query
//e.g. if we need to log only insert queries, use {op:'insert'}
//e.g. if we need to log operation on only 'MyCollection' collection, use {ns: 'MyDb.MyCollection'}
//we can give a lot of filters, print and check the 'document' variable below

// set MongoDB cursor options
var cursorOptions = {
    tailable: true,
    awaitdata: true,
    numberOfRetries: -1
};

// create stream and listen
var stream = db.collection('system.profile').find(filter, cursorOptions).stream();

// call the callback
stream.on('data', function (document) {
    //this will run on every operation/query done on our database
    //print 'document' to check the keys based on which we can filter
    //delete data which we dont need in our log file

    delete document.execStats;
    delete document.keysExamined;
    //-----
    //-----

    //append the log generated in our log file which can be tailed from command line
    fs.appendFile(file, JSON.stringify(document) + '\n', function (err) {
        if (err) (console.log('err'))
    })

});

}

Para el cursor disponible en python usando pymongo, consulte el siguiente código que filtra para MyCollection y solo inserta la operación:

import pymongo
import time
client = pymongo.MongoClient()
oplog = client.MyDb.system.profile
first = oplog.find().sort('$natural', pymongo.ASCENDING).limit(-1).next()

ts = first['ts']
while True:
    cursor = oplog.find({'ts': {'$gt': ts}, 'ns': 'MyDb.MyCollection', 'op': 'insert'},
                        cursor_type=pymongo.CursorType.TAILABLE_AWAIT)
    while cursor.alive:
        for doc in cursor:
            ts = doc['ts']
            print(doc)
            print('\n')
        time.sleep(1)

Nota: El cursor disponible solo funciona con colecciones con límite. No se puede usar para registrar operaciones en una colección directamente, en su lugar use filter:'ns': 'MyDb.MyCollection'

Nota: Entiendo que los nodos anteriores y el código de Python pueden no ser de mucha ayuda para algunos. Acabo de proporcionar los códigos de referencia.

Utilice este enlace para buscar documentación para el cursor disponible en su idioma / controlador . Controladores Mongodb

Otra característica que he agregado después de este logrotate .

Pruebe este paquete para seguir todas las consultas (sin operaciones de oplog): https://www.npmjs.com/package/mongo-tail-queries

(Descargo de responsabilidad: escribí este paquete exactamente para esta necesidad)