MongoDB registra tutte le query

La domanda è tanto semplice quanto semplice ... Come si registrano tutte le query in un file di registro "tail" in mongodb?

Ho provato:

• impostazione del livello di profilazione
• impostazione dell'avvio lento del parametro ms
• mongod con l'opzione -vv

Il /var/log/mongodb/mongodb.log continua a mostrare solo il numero corrente di connessioni attive ...

Puoi registrare tutte le query:

$ 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()

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

db.setProfilingLevel(2) significa "registra tutte le operazioni".

Ho finito per risolvere questo avviando mongod in questo modo (martellato e brutto, sì ... ma funziona per l'ambiente di sviluppo):

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

Ciò consente la creazione di profili e imposta la soglia per le "query lente" su 1 ms, facendo sì che tutte le query vengano registrate come "query lente" nel file:

/var/log/mongodb/mongodb.log

Ora ottengo output di log continui usando il comando:

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

Un registro di esempio:

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

Perché è la prima risposta di Google ...
Per la versione 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/

MongoDBha una sofisticata funzione di profilazione. La registrazione avviene nella system.profileraccolta. I registri possono essere visualizzati da:

db.system.profile.find()

Esistono 3 livelli di registrazione ( sorgente ):

• Livello 0 - il profiler è spento, non raccoglie dati. mongod scrive sempre le operazioni più lunghe della soglia slowOpThresholdMs nel suo registro. Questo è il livello predefinito del profiler.
• Livello 1 : raccoglie i dati di profilazione solo per operazioni lente. Per impostazione predefinita, le operazioni lente sono più lente di 100 millisecondi. È possibile modificare la soglia per le operazioni "lente" con l'opzione di runtime slowOpThresholdMs o il comando setParameter. Vedere la sezione Specificare la soglia per operazioni lente per ulteriori informazioni.
• Livello 2 : raccoglie i dati di profilazione per tutte le operazioni del database.

Per vedere a quale livello di profiling è in esecuzione il database, utilizzare

db.getProfilingLevel()

e per vedere lo stato

db.getProfilingStatus()

Per modificare lo stato del profilo, utilizzare il comando

db.setProfilingLevel(level, milliseconds)

Dove si levelriferisce al livello di profilazione ed millisecondsè il ms di quale durata devono essere registrate le query. Per disattivare la registrazione, utilizzare

db.setProfilingLevel(0)

La query per cercare nella raccolta dei profili di sistema tutte le query che hanno richiesto più di un secondo, ordinate per data e ora decrescente saranno

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

Ho creato uno strumento da riga di comando per attivare l'attività del profiler e visualizzare i log in modo "tail" : "mongotail" .

Ma la caratteristica più interessante (anche simile tail) è vedere le modifiche in "tempo reale" con l' -fopzione e occasionalmente filtrare il risultato con grepper trovare una particolare operazione.

Consultare la documentazione e le istruzioni di installazione in: https://github.com/mrsarm/mongotail

Una volta impostato il livello di profilazione utilizzando db.setProfilingLevel(2) .

Il comando seguente stamperà l'ultima query eseguita.
È possibile modificare anche il limite (5) per visualizzare meno / più query.
$ nin - filtrerà le query di profilo e di indice
Inoltre, usa la proiezione di query {'query': 1} per visualizzare solo il campo di query

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

Registra solo con la proiezione di query

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

se si desidera che le query vengano registrate nel file di registro di mongodb, è necessario impostare sia il livello di registro sia la profilazione, come ad esempio:

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

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

L'impostazione della sola profilazione non avrebbe le query registrate su file, quindi è possibile ottenerle solo da

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

I dati del profiler vengono scritti in una raccolta nel tuo DB, non in un file. Vedi http://docs.mongodb.org/manual/tutorial/manage-the-database-profiler/

Consiglierei di utilizzare il servizio MMS di 10gen e fornire lì i dati del profiler di sviluppo, dove è possibile filtrarli e ordinarli nell'interfaccia utente.

Penso che sebbene non sia elegante, l' oplog potrebbe essere parzialmente utilizzato per questo scopo: registra tutte le scritture - ma non le letture ...

Devi abilitare il replicatoon, se ho ragione. Le informazioni provengono da questa risposta da questa domanda: come ascoltare le modifiche a una raccolta MongoDB?

L'impostazione del livello di profiling su 2 è un'altra opzione per registrare tutte le query.

Consiglio di dare un'occhiata a Mongosniff. Questo strumento può fare tutto ciò che vuoi e altro ancora. Soprattutto può aiutare a diagnosticare problemi con sistemi mongo su larga scala e come vengono instradate le query e da dove provengono poiché funziona ascoltando l'interfaccia di rete per tutte le comunicazioni relative a mongo.

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

Ho scritto uno script che stamperà il registro system.profile in tempo reale quando arrivano le query. Devi prima abilitare la registrazione come indicato in altre risposte. Ne avevo bisogno perché sto usando il sottosistema Windows per Linux, per il quale la coda non funziona ancora.

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

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

Poi

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

Questo è stato chiesto molto tempo fa, ma questo può ancora aiutare qualcuno:

Il profiler di MongoDB registra tutte le query nel sistema di raccolta con limiti.profilo . Vedi questo: database profiler

1. Avviare l'istanza mongod con l' --profile=2opzione che abilita la registrazione di tutte le query OPPURE se le istanze mongod sono già in esecuzione, da mongoshell, eseguire db.setProfilingLevel(2)dopo aver selezionato il database. (può essere verificato da db.getProfilingLevel(), che dovrebbe restituire 2)
2. Dopo questo, ho creato uno script che utilizza il cursore disponibile di mongodb per seguire questa raccolta system.profile e scrivere le voci in un file. Per visualizzare i registri Ho solo bisogno di coda esso: tail -f ../logs/mongologs.txt. Questo script può essere avviato in background e registrerà tutte le operazioni sul db nel file.

Il mio codice per il cursore disponibile per la raccolta system.profile è in nodejs; registra tutte le operazioni insieme alle query che si verificano in ogni raccolta di 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'))
    })

});

}

Per il cursore disponibile in Python usando pymongo, fare riferimento al codice seguente che filtra per MyCollection e inserisce solo l'operazione:

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: il cursore disponibile funziona solo con raccolte limitate. Non può essere utilizzato per registrare direttamente le operazioni su una raccolta, utilizzare invece il filtro:'ns': 'MyDb.MyCollection'

Nota: capisco che i precedenti nodejs e il codice python potrebbero non essere di grande aiuto per alcuni. Ho appena fornito i codici per riferimento.

Usa questo link per trovare la documentazione per il cursore disponibile nella tua lingua / driver scelto Mongodb di

Un'altra caratteristica che ho aggiunto dopo questo logrotate .

Prova questo pacchetto per adattare tutte le query (senza operazioni oplog): https://www.npmjs.com/package/mongo-tail-queries

(Dichiarazione di non responsabilità: ho scritto questo pacchetto esattamente per questa esigenza)