Objet de journalisation Winston

Vous essayez d'insérer un objet JSON directement dans la chaîne, il imprimera donc [Object Object] sans JSON.stringify .

Ce problème ne peut pas être résolu en configurant Winston, car ce problème se produit pendant la génération de la chaîne (avant que la fonction logger.debug ne la lise réellement), donc un appel console.log la même chose.

Le premier paramètre des fonctions logger.* Est le message (chaîne), vous pouvez ensuite passer un objet de métadonnées (JSON).

Pour utiliser les métadonnées dans votre fonction logFormat , mettez à jour votre instanciation Logger comme suit:

{
  message: 'Register Daniel Duuch with email daniel.duuch@greatmail.com',
  level: 'debug',
  timestamp: '2019-05-11 17:05:45',
  label: 'index.js',
  metadata: {
    name: 'Daniel Duuch',
    email: 'daniel.duuch@greatmail.com',
    password: 'myGreatPassword'
  }
}

Usage:

2019-05-11 17:05:45 debug [index.js]: Register Daniel Duuch with email daniel.duuch@greatmail.com

Sortie de la console:

const req = {
  body: {
    name: 'Daniel Duuch',
    email: 'daniel.duuch@greatmail.com',
    password: 'myGreatPassword'
  }
}

logger.debug(`Register ${req.body.name} with email ${req.body.email}`, { ...req.body, action: 'register' })

Sortie du fichier journal (joliment à la main, voir commentaire dans le format du fichier de transport):

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

const logFormat = format.printf(info => `${info.timestamp} ${info.level} [${info.label}]: ${info.message}`)

const logger = winston.createLogger({
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
  format: format.combine(
    format.label({ label: path.basename(process.mainModule.filename) }),
    format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
    // Format the metadata object
    format.metadata({ fillExcept: ['message', 'level', 'timestamp', 'label'] })
  ),
  transports: [
    new transports.Console({
      format: format.combine(
        format.colorize(),
        logFormat
      )
    }),
    new transports.File({
      filename: 'logs/combined.log',
      format: format.combine(
        // Render in one line in your log file.
        // If you use prettyPrint() here it will be really
        // difficult to exploit your logs files afterwards.
        format.json()
      )
    })
  ],
  exitOnError: false
})

J'espère que cela résout votre problème.

Code pour cette réponse

Vous pouvez utiliser format.splat() dans la configuration de votre enregistreur:

let myObj = { /* ... */ };
logger.info('This message will include a complete object: %O', myObj);

... et objet journal utilisant l'interpolation de chaîne:

const logger = createLogger({
    format: combine(
        ...
        format.splat(), // <--
        ...
    ),
    ...
});

J'ai dû combiner la solution fournie par @SherloxFR et @Anton.

logger.info('Content: %o', {...myObj});

Vous pouvez voir que j'ai ajouté à la fois format.splat() et format.json() à la configuration des options dans le code ci-dessus.

let myObj = {
   name: "StackOverflow",
};

logger.info('Content: %o', myObj);

C'est ainsi que j'ai utilisé l'objet de configuration d'options. Vous pouvez en fait écrire le code de format dans le tableau des transports mais je n'aime pas ça de cette façon. C'est ton choix de toute façon.

Après la configuration comme ça, voici comment je l'ai utilisé dans mon code

const logger = new Winston.createLogger({
    transports: [
        new Winston.transports.File(options.file),
        new Winston.transports.Console(options.console)
    ],
    exitOnError: false // do not exit on handled exceptions
});

Vous pouvez également le diffuser comme ça si vous le souhaitez

const Winston = require('winston');
const { format } = Winston;

const options = {
    file: {
        ....
        format: format.combine(
            format.splat(), 
            format.json()
        ),
        ...
    },
    console: {
        ...
        format: format.combine(
            format.splat(),
            format.json()
        ),
        ...
    }
};

C'est tout. Winston devrait enregistrer votre objet avec cette configuration.

Ou vous utilisez simplement le

printf

fonction en conjonction avec JSON.stringify

new winston.transports.Console({
  format: winston.format.combine(
    winston.format.colorize(),
    winston.format.simple(),
    winston.format.printf(context => {
      const msgstr = JSON.stringify(context.message, null, '\t')
      return `[${context.level}]${msgstr}`
    }),
  ),
})

Ma solution était d'utiliser ce type de formateur:

logger.info('plain text')
logger.info('plain text with object %o', { a:1, b: 2} )
logger.info({ a:1, b: 2 })

maintenant toutes ces options fonctionnent comme prévu:

const { format } = winston
const consoleFormat = format.combine(
  format.prettyPrint(),
  format.splat(),
  format.printf((info) => {
    if (typeof info.message === 'object') {
      info.message = JSON.stringify(info.message, null, 3)
    }

    return info.message
  })
)