MongoDB enregistre toutes les requêtes

Question

La question est aussi basique qu'elle est simple... Comment enregistrer toutes les requêtes dans un fichier journal "tail" dans mongodb ?

J'ai essayé :

• définir le niveau de profilage
• paramétrage du démarrage du paramètre slow ms
• mongod avec l'option -vv

Le fichier /var/log/mongodb/mongodb.log continue d'afficher uniquement le nombre actuel de connexions actives...

Answer 1

db.setProfilingLevel(2,-1)

Cela a fonctionné ! Toutes les informations sur les requêtes ont été enregistrées dans le fichier journal de mongod.

Answer 2

Je recommande de vérifier mongosniff. Cet outil peut faire tout ce que vous voulez et plus encore. Il peut notamment aider à diagnostiquer les problèmes des systèmes mongo à grande échelle et à déterminer comment les requêtes sont acheminées et d'où elles proviennent, puisqu'il fonctionne en écoutant votre interface réseau pour toutes les communications liées à mongo.

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

Answer 3

J'ai écrit un script qui va imprimer le journal system.profile en temps réel au fur et à mesure que les requêtes arrivent. Vous devez d'abord activer la journalisation comme indiqué dans d'autres réponses. J'avais besoin de cela parce que j'utilise Windows Subsystem pour Linux, pour lequel tail ne fonctionne toujours pas.

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

Answer 4

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

Puis

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

Answer 5

Cette question a été posée il y a longtemps, mais elle peut encore aider quelqu'un :

MongoDB profiler enregistre toutes les requêtes dans la collection plafonnée. profil.système . Voir ça : profileur de base de données

1. Démarrer l'instance mongod avec --profile=2 option qui permet de consigner toutes les requêtes O si mongod instances est déjà en cours d'exécution, à partir de mongoshell, exécutez db.setProfilingLevel(2) après avoir sélectionné la base de données. (il peut être vérifié par db.getProfilingLevel() qui devrait donner 2 )
2. Après cela, j'ai créé un script qui utilise l'interface de mongodb. curseur disponible pour suivre cette collection system.profile et écrire les entrées dans un fichier. Pour afficher les journaux, il suffit de les suivre : tail -f ../logs/mongologs.txt . Ce script peut être lancé en arrière plan et il enregistrera toutes les opérations sur la db dans le fichier.

Mon code pour le curseur disponible pour la collection system.profile est en nodejs ; il enregistre toutes les opérations ainsi que les requêtes qui se produisent dans chaque collection 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'))
    })

});

}

Pour un curseur disponible en python utilisant pymongo, référez-vous au code suivant qui filtre pour MyCollection et seulement l'opération d'insertion :

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)

Remarque : Le curseur disponible ne fonctionne qu'avec les collections plafonnées. Il ne peut pas être utilisé pour enregistrer directement les opérations sur une collection, utilisez plutôt le filtre : 'ns': 'MyDb.MyCollection'

Note : Je comprends que le code nodejs et python ci-dessus peut ne pas être d'une grande aide pour certains. J'ai simplement fourni les codes à titre de référence.

Utilisez ce lien pour trouver la documentation sur le curseur disponible dans la langue et le pilote de votre choix. Pilotes Mongodb

Une autre fonctionnalité que j'ai ajoutée après ceci logrotate .