Winston: Comment personnaliser le format d'horodatage ?

vous pouvez lire le code source pour vous aider à personnaliser le format. je peux vous donner un exemple du mien.

const winston = require('winston');
const moment = require('moment');
const util = require('util');
const MESSAGE = Symbol.for('message');

const logger = winston.createLogger({
    level: 'info',
    format: winston.format.combine(
        winston.format(function(info, opts) {
            prefix = util.format('[%s] [%s]', moment().format('YYYY-MM-DD hh:mm:ss').trim(), info.level.toUpperCase());
            if (info.splat) {
                info.message = util.format('%s %s', prefix, util.format(info.message, ...info.splat));
            } else {
                info.message = util.format('%s %s', prefix, info.message);
            }
            return info;
        })(),
        winston.format(function(info) {
            info[MESSAGE] = info.message + ' ' + JSON.stringify(
                Object.assign({}, info, {
                    level: undefined,
                    message: undefined,
                    splat: undefined
                })
            );
            return info;
        })()
    ),
    transports: [
        new winston.transports.Console(),
        new winston.transports.File({ filename: './logs/bitcoin.log' })
    ]
});

C'est tellement compliqué pour l'exigence la plus simple d'imprimer simplement un horodatage (qui devrait être par défaut de toute façon) :/

Voici ce que je fais...

//logger.js

const winston = require('winston');
const moment = require('moment');

// create formatter for dates used as timestamps
//const tsFormat = () => (new Date()).toLocaleTimeString();
const tsFormat = () => moment().format('YYYY-MM-DD hh:mm:ss').trim();

// define a logger with 2 transports - console and a file
const logger = new (winston.Logger)({
  transports: [
    // colorize the output to the console
    new (winston.transports.Console)({
        timestamp: tsFormat,
        colorize: true
    }),
    new winston.transports.File({
        filename: './logs/ttracker.log',
        timestamp: tsFormat,            // makes timestamp 'pretty'
        json: false                 // makes log format just like console output
    })
  ]
});

// set logging level one of { error: 0, warn: 1, info: 2, verbose: 3, debug: 4, silly: 5 }
logger.level = 'debug';

module.exports = logger;

PS Je n'ai défini que timestamp: sur une fonction car je n'aime pas le format par défaut que vous obtenez en définissant timestamp: true, c'est-à-dire 2017-12-05T08:22:09.179Z

@jimwhurr - pour moi, votre code (nœud v6.11.0) produit :

Error: winston.Logger was moved in [email protected].
Use a winston.createLogger instead.
    at new <anonymous> (/Users/adrian/Documents/winston_test/node_modules/winston/lib/winston/common.js:162:15)
    at Object.<anonymous> (/Users/adrian/Documents/winston_test/index.js:7:16)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:389:7)
    at startup (bootstrap_node.js:149:9)

En prenant les exemples ici, j'ai créé un exemple autonome plus simple :

https://gist.github.com/ah/d02bd4ff238e5923fcf5369233e51401

const winston = require('winston');
const MESSAGE = Symbol.for('message');

const jsonFormatter = (logEntry) => {
  const base = { timestamp: new Date() };
  const json = Object.assign(base, logEntry)
  logEntry[MESSAGE] = JSON.stringify(json);
  return logEntry;
}

const logger = winston.createLogger({
  level: 'info',
  format: winston.format(jsonFormatter)(),
  transports: new winston.transports.Console(),
});

logger.info('message content', { "context": "index.js", "metric": 1 })
logger.info('message content 2')

Sortir:

{"timestamp":"2017-12-07T16:07:10.518Z","context":"index.js","metric":1,"level":"info","message":"message content"}
{"timestamp":"2017-12-07T16:07:10.520Z","message":"message content 2","level":"info"}

Salut, voici une autre option pour la journalisation avec horodatage (testé sur 3.0.0-rc0):

const winston = exige('winston');
var customFormat = winston.format.combine(
winston.format(
function DynamicContent(info, opts) {
info.level = 'info';
si(info.heure) {
var dt = nouvelle Date(),
date_now = dt.getDate() < 10 ? '0'+ dt.getDate() : dt.getDate(),
mois_maintenant = (dt.getMonth() + 1) < 10 ? '0'+ (dt.getMonth() + 1) : (dt.getMonth() + 1),
year_now = dt.getFullYear(),
hrs_now = dt.getHours(),
mins_now = dt.getMinutes(),
secs_now = dt.getSeconds(),
millisec_now = dt.getMilliseconds();
info.time = ' '+date_now+'-'+month_now+'-'+year_now+' '+hrs_now+':'+mins_now+':'+secs_now+':'+millisec_now+' ' ;
}
retour d'informations ;
}
)(),
winston.format.simple() //format de sortie, utilisation également possible : .json() (au lieu de .simple)
);

const logger = winston.createLogger({
niveau : 'infos',
format : format personnalisé,
les transports: [
nouveau winston.transports.File({ nom du fichier : 'logs.log' })
]
});
module.exports = enregistreur;`

Et pour le log :

logger.log({ time: true, level: 'info', message: 'message for logging' });

Peut-être que cela sera utile.

vous pouvez personnaliser l'horodatage avec une chaîne de format :

winston.createLogger({
    level: ...
    format: winston.format.combine(
        winston.format.label({ label: '[my-label]' }),
        winston.format.timestamp({
            format: 'YYYY-MM-DD HH:mm:ss'
        }),
        winston.format.simple()
    ),
    transports: ...
});

winston.createLogger({
    level: ...
    format: winston.format.combine(
        winston.format.label({ label: '[my-label]' }),
        winston.format.timestamp({
            format: 'YYYY-MM-DD HH:mm:ss'
        }),
        winston.format.simple()
    ),
    transports: ...
});

Cela devrait être sur les docs. @felipemullen Merci !

@felipemullen merci d'avoir fourni cet échantillon. D'accord avec @ricardoaat, cela devrait être dans la documentation, donc ... maintenant c'est : examples/custom-timestamp.js

@youngkylejan oh oh ..... C'est une bonne aide ...
Mais j'ai un problème... qu'est-ce qu'il y a {} à la fin du journal ?

[2018-05-14 04:39:52] [INFO] API exécutée sur localhost : 3000 {}

Je suis nouveau sur Winston et, je dois dire, les docs sont étonnamment difficiles à suivre :(

D'une manière ou d'une autre, je me suis retrouvé avec la solution apparemment plus simple suivante:

winston.createLogger({
    level: ...
    format: winston.format.printf(info => `${new Date().toISOString()} ${info.message}`),
    transports: ...
});

@hosseinGanjyar
Changer
info[MESSAGE] = info.message + ' ' + JSON.stringify(...);
pour juste
info[MESSAGE] = info.message;

Cela a fonctionné pour moi.

Installer:

• Journaux JSON
• Horodatages
• Rotation des journaux
• Journalisation des fichiers et de la console

import winston from 'winston';
import DailyRotateFile from 'winston-daily-rotate-file';
import fs from 'fs';
import path from 'path';

const LOG_DIR = path.normalize(`${process.cwd()}/logs`);

if (!fs.existsSync(LOG_DIR)) {
  fs.mkdirSync(LOG_DIR);
}

const logger = winston.createLogger({
  exitOnError: false,
  silent: process.env.SUPPRESS_LOGS,
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp({
      format: 'YYYY-MM-DD HH:mm:ss',
    }),
    winston.format.json(),
  ),
  transports: [
    new winston.transports.Console(),
    new DailyRotateFile({
      dirname: LOG_DIR,
      filename: '%DATE%.log',
      datePattern: 'YYYY-MM-DD-HH',
      zippedArchive: false,
      maxSize: '1m',
      maxFiles: '14d',
    }),
  ],
});

export default logger;

C'est tout pour winston 3.0.0 et @types/winston 2.3.9

const consoleFormat = winston.format.printf(info => {
    const d = new Date();
    const timestamp = d.toLocaleTimeString();
    return `${timestamp} ${info.level}: ${info.message}`;

cela renvoie un horodatage qui est juste l'heure dans le fuseau horaire actuel.
pour fileFormat j'utilise

const timestamp = `${d.toISOString()} (${d.toLocalTimeString()})`;

ensuite

const logger = winston.createLogger({
    level: "debug",
    format: fileFormat,
    transports: [ new winston.transports.File({ filename: "yourname.log", level: "debug"}) ]
});

n'a probablement pas besoin de niveau deux fois. mais c'est ce que j'utilise actuellement.

vous pouvez personnaliser l'horodatage avec une chaîne de format :

winston.createLogger({
    level: ...
    format: winston.format.combine(
        winston.format.label({ label: '[my-label]' }),
        winston.format.timestamp({
            format: 'YYYY-MM-DD HH:mm:ss'
        }),
        winston.format.simple()
    ),
    transports: ...
});

Sauveur de vie. Merci beaucoup!!!

Pour ceux qui sont ici pour savoir comment personnaliser la chaîne de format en plus YYYY-MM-DD HH:mm:ss : winston utilise fecha sous le capot , vous pouvez donc vous référer à la documentation de fecha .

Tous ces exemples suppriment les paramètres de repos dans les journaux. Si vous souhaitez utiliser format.simple() et ajouter uniquement l'horodatage au début et le supprimer du reste, cela pourrait fonctionner pour vous :

const simpleFormat = format.simple()
const MESSAGE = Symbol.for('message')
const simpleTimestamp = format(info => {
  const { timestamp, ...rest } = info
  const simpled = simpleFormat.transform(rest)
  if (typeof simpled !== 'boolean') {
    // @ts-ignore
    simpled[MESSAGE] = `${timestamp} ${simpled[MESSAGE]}`
  }
  return simpled
})

logger.add(new transports.Console({
  format: format.combine(
      format.timestamp(),
      format.colorize(),
      simpleTimestamp(),
  ),
}))