Winston: टाइमस्टैम्प प्रारूप को कैसे अनुकूलित करें?

प्रारूप को अनुकूलित करने में स्वयं की सहायता के लिए आप स्रोत कोड पढ़ सकते हैं। मैं आपको अपना एक उदाहरण दे सकता हूं।

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' })
    ]
});

टाइमस्टैम्प (जो वैसे भी डिफ़ॉल्ट होना चाहिए) को प्रिंट करने की सबसे सरल आवश्यकता के लिए यह बहुत ही जटिल है: /

यहाँ मैं क्या करता हूँ...

// लकड़हारा.जेएस

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;

पुनश्च मैं केवल टाइमस्टैम्प सेट करता हूं: एक फ़ंक्शन के लिए क्योंकि मुझे डिफ़ॉल्ट प्रारूप पसंद नहीं है जो आपको टाइमस्टैम्प सेट करके मिलता है: सच, यानी 2017-12-05T08: 22: 09.179Z

@jimwhurr - मेरे लिए, आपका कोड (नोड v6.11.0) उत्पन्न करता है:

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)

यहां उदाहरण लेते हुए, मैंने एक सरल स्टैंडअलोन उदाहरण बनाया:

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')

आउटपुट:

{"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"}

नमस्ते, टाइमस्टैम्प के साथ लॉगिंग के लिए यहां एक और विकल्प है (3.0.0-आरसी0 पर परीक्षण किया गया):

कॉन्स्ट विंस्टन = आवश्यकता ('विंस्टन');
वर customFormat = winton.format.combine (
विंस्टन। प्रारूप (
फंक्शन डायनामिक कंटेंट (जानकारी, ऑप्ट्स) {
जानकारी स्तर = 'जानकारी';
अगर (जानकारी समय) {
वर डीटी = नई तिथि (),
date_now = dt.getDate() <10? '0'+ dt.getDate() : dt.getDate(),
Month_now = (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 (),
मिलीसेक_नाउ = dt.getMilliseconds ();
info.time = ' '+date_now+'-'+month_now+'-'+year_now+' '+hrs_now+':'+mins_now+':'+secs_now+':'+millisec_now+' ';
}
वापसी की जानकारी;
}
) (),
विंस्टन.फॉर्मैट.सिंपल () // प्रारूप आउटपुट, भी सकारात्मक उपयोग: .json () (.simple के बजाय)
);

कॉन्स्ट लॉगर = विंस्टन। क्रिएटलॉगर ({
स्तर: 'जानकारी',
प्रारूप: कस्टमफॉर्मेट,
परिवहन: [
न्यू विंस्टन.ट्रांसपोर्ट्स.फाइल ({फ़ाइल नाम: 'लॉग्स.लॉग'})
]
});
मॉड्यूल.एक्सपोर्ट्स = लकड़हारा; `

और लॉग के लिए:

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

हो सकता है यह मददगार होगा।

आप टाइमस्टैम्प को प्रारूप स्ट्रिंग के साथ अनुकूलित कर सकते हैं:

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: ...
});

यह डॉक्स पर होना चाहिए। @felipemullen धन्यवाद!

@felipemullen उस नमूना को प्रदान करने के लिए धन्यवाद। @ricardoaat से सहमत यह दस्तावेज़ों में होना चाहिए, इसलिए ... अब यह है: उदाहरण/कस्टम-टाइमस्टैम्प.जेएस

@youngkylejan ओह ओह ..... यह अच्छी मदद है ...
लेकिन मुझे एक समस्या है...लॉग के अंत में {} क्या है?

[2018-05-14 04:39:52] [सूचना] एपीआई लोकलहोस्ट पर चल रहा है: 3000 {}

मैं विंस्टन के लिए नया हूं और कहना होगा, दस्तावेज़ों का पालन करना आश्चर्यजनक रूप से कठिन है :(

किसी तरह, मैं निम्नलिखित स्पष्ट रूप से सरल समाधान के साथ समाप्त हुआ:

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

@hosseinGanjyar
परिवर्तन
info[MESSAGE] = info.message + ' ' + JSON.stringify(...);
करने के लिए बस
info[MESSAGE] = info.message;

यह मेरे लिए काम किया।

सेट अप:

• JSON लॉग
• मुहर
• लॉग रोटेशन
• फ़ाइल और कंसोल लॉगिंग

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;

यह सब विंस्टन 3.0.0 और @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}`;

यह एक टाइमस्टैम्प देता है जो वर्तमान टाइमज़ोन में बस समय है।
फ़ाइलफॉर्मेट के लिए मैं उपयोग करता हूं

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

फिर

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

शायद दो बार स्तर की जरूरत नहीं है। लेकिन मैं वर्तमान में इसका उपयोग कर रहा हूं।

आप टाइमस्टैम्प को प्रारूप स्ट्रिंग के साथ अनुकूलित कर सकते हैं:

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: ...
});

जीवन रक्षक। बहुत धन्यवाद!!!

उन लोगों के लिए जो YYYY-MM-DD HH:mm:ss के अलावा प्रारूप स्ट्रिंग को अनुकूलित करने का तरीका जानने के लिए यहां हैं: विंस्टन हुड के नीचे फेचा का उपयोग करता है , इसलिए आप फेचा दस्तावेज़ीकरण का उल्लेख कर सकते हैं।

वे सभी उदाहरण लॉग में बाकी मापदंडों को हटा देते हैं। यदि आप format.simple() का उपयोग करना चाहते हैं और शुरुआत में केवल टाइमस्टैम्प जोड़ें और बाकी से हटा दें, तो यह आपके लिए काम कर सकता है:

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(),
  ),
}))