web-dev-qa-db-fra.com

Comment ajouter de l'horodatage aux journaux à l'aide de la bibliothèque Winston de Node.js?

Je veux ajouter un horodatage aux journaux. Quel est le meilleur moyen d'y parvenir?

node.jsloggingwinston
82
kolrie

Je traitais le même problème moi-même. J'ai pu faire cela de deux manières.

Lorsque vous incluez Winston, il ajoute généralement un transport de console par défaut. Pour que les horodatages fonctionnent dans ce cas par défaut, je devais soit:

  1. Supprimez le transport de la console et ajoutez-le à nouveau avec l'option d'horodatage.
  2. Créez votre propre objet Logger avec l'option timestamp définie sur true.

La première:

var winston = require('winston');
winston.remove(winston.transports.Console);
winston.add(winston.transports.Console, {'timestamp':true});

La seconde option, plus propre:

var winston = require('winston');
var logger = new (winston.Logger)({
    transports: [
      new (winston.transports.Console)({'timestamp':true})
    ]
});

Certaines des autres options pour le transport de console peuvent être trouvées ici :

  • level: Niveau de messages que ce transport doit consigner (par défaut, 'debug').
  • silent: Indicateur booléen indiquant s'il faut supprimer la sortie (false par défaut).
  • colorize: indicateur booléen indiquant si nous devons coloriser la sortie (par défaut, false).
  • timestamp: Indicateur booléen indiquant s'il faut ajouter la sortie avec un horodatage (false par défaut) Si function est spécifié, sa valeur de retour sera utilisée à la place de l'horodatage.
107
imagreenplant

Les réponses ci-dessus n'ont pas fonctionné pour moi. Si vous essayez d’ajouter de l’horodatage à vos journaux en utilisant la dernière version de Winston - 3.0.0-rc1, cela fonctionnera à merveille:

    const {transports, createLogger, format} = require('winston');

    const logger = createLogger({
        format: format.combine(
            format.timestamp(),
            format.json()
        ),
        transports: [
            new transports.Console(),
            new transports.File({filename: 'logs/error/error.log', level: 'error'}),
            new transports.File({filename: 'logs/activity/activity.log', level:'info'})
        ]
    });

J'ai utilisé 'format.combine ()'. Comme j'avais besoin d'un horodatage sur tous mes transports, j'ai ajouté l'option de formatage dans createLogger, plutôt que dans chaque transport. Mes sorties sur console et sur fichier (activity.log) sont les suivantes:

{"message":"Connected to mongodb","level":"info","timestamp":"2018-02-01T22:35:27.758Z"}
{"message":"Connected to mongodb","level":"info","timestamp":"2018-02-01T22:35:27.758Z"}

Nous pouvons ajouter un formatage à cet horodatage dans 'format.combine ()' comme d'habitude en utilisant:

format.timestamp({format:'MM-YY-DD'})
41
Siva Kiran

Vous pouvez utiliser les méthodes til et forever intégrées pour réaliser la journalisation avec timestap pour votre serveur nodejs. Lorsque vous démarrez un serveur, ajoutez une sortie de journal dans le paramètre:

forever start -ao log/out.log server.js

Et puis vous pouvez écrire util dans votre server.js

server.js 

var util = require('util');
util.log("something with timestamp");

La sortie ressemblera à ceci dans le fichier out.log:

out.log 

15 Mar 15:09:28 - something with timestamp
9
KTU

Nous pouvons faire comme ça aussi

var winston = require('winston');
    const { createLogger, format, transports } = require('winston')
    var config = require('../configurations/envconfig.js');

    var loggerLevel = process.env.LOGGERLEVEL ||  config.get('LOGGERLEVEL');

    var logger = winston.createLogger({ format: format.combine(
            format.timestamp({
                format: 'YYYY-MM-DD HH:mm:ss'
            }),
            format.printf(info => `${info.timestamp} ${info.level}: ${info.message}`+(info.splat!==undefined?`${info.splat}`:" "))
        ), 
        transports: [
            new (winston.transports.Console)({ level: loggerLevel }),
           ]
    });
    module.exports = logger;
7
Biswadev

Bien que je ne sois pas au courant de Winston, ceci est une suggestion. J'utilise log4js pour la journalisation et mes journaux par défaut ressemblent à ceci

[2012-04-23 16:36:02.965] [INFO] Development - Node Application is running on port 8090
[2012-04-23 16:36:02.966] [FATAL] Development - Connection Terminated to  '127.0.0.1' '6379'

Le développement est l'environnement de mon processus de nœud et [INFO | FATAL] est au niveau du journal

La gestion de différents profils pour la journalisation est possible dans log4js. J'ai des profils de développement et de production. Il existe également des types d'enregistreur tels que roulement de fichier, console, etc. En tant que complément, vos fichiers de log seront colorés en fonction du niveau de journalisation [Trace, Info, Debug, Error, Fatal];)

log4js remplacera votre console.log C'est un paramètre configurable maintenant dans 0.5+

4
Tamil

nous pourrions utiliser console-stamp pour ajouter un horodatage et un niveau de journalisation à la console existante: require('console-stamp')(console, '[yyyy-mm-dd HH:MM:ss.l]')

Voir https://github.com/starak/node-console-stamp pour les détails

2
khoi nguyen

Parfois, le format d'horodatage par défaut peut ne pas vous convenir. Vous pouvez le remplacer par votre implémentation.

Au lieu de

var winston = require('winston');
var logger = new (winston.Logger)({
transports: [
  new (winston.transports.Console)({'timestamp':true})
]
});

tu peux écrire

var winston = require('winston');
var logger = new (winston.Logger)({
transports: [
  new (winston.transports.Console)({
     'timestamp': function() {
        return <write your custom formatted date here>;
     }
  })
]
});

Voir https://github.com/winstonjs/winston#custom-log-format pour les détails

2
walv

Une autre solution consiste à intégrer l'enregistreur dans un fichier qui exporte des fonctions telles que logger.info (), logger.error (), etc., puis vous ne faites que passer une clé supplémentaire à envoyer pour chaque journal de messages.

loggerService.js

const logger = winston.createLogger({ ... })

function handleLog(message, level) {
  const logData = {
    timestamp: Date.now(),
    message,
  }

  return logger[level](logData)
}

function info(message) {
  handleLog(message, 'info')
}

function error(message) {
  handleLog(message, 'error')
}

function warn(message) {
  handleLog(message, 'warn')
}

module.exports = {
  info,
  error,
  warn
}

quel que soit le fichier.js

const logger = require('./services/loggerService')

logger.info('Hello World!')

votre-log.log

{"timestamp":"2019-08-21 06:42:27","message":"Hello World!","level":"info"}
0
Renan Coelho