Winston: लॉगिंग फ़ंक्शंस में एकाधिक पैरामीटर पास करना अपेक्षित व्यवहार नहीं करता है

मैं आज उसी मुद्दे में भाग गया। मेरा मानना ​​​​है कि यह एक बग है क्योंकि अपग्रेड डॉक्यूमेंटेशन में भी ऐसा ही एक उदाहरण है :

logger.info('transaction ok', { creditCard: 123456789012345 });

वर्तमान में इसके आसपास जाने के लिए आप एक ऐसा फ़ंक्शन बना सकते हैं जो विंस्टन में पारित होने से पहले तर्कों को पार करता है

@ mulligan121 ठीक है, लेकिन मैं अपने कोडबेस में हर लॉग स्टेटमेंट को बदलना नहीं चाहता ...

@indexzero क्या यह आपके रडार के नीचे है? मुझे लगता है कि यह एक बड़ा ब्रेकिंग बदलाव है। यह वास्तव में 2.x से 3.x तक जाने से रोकता है क्योंकि इसके लिए हमें प्रत्येक लॉग प्रविष्टि को बदलने की आवश्यकता होती है

अस्थायी उपाय:

const wrapper = ( original ) => {
    return (...args) => original(args.join(" "));
};

winstonLogger.error = wrapper(winstonLogger.error);
winstonLogger.warn = wrapper(winstonLogger.warn);
winstonLogger.info = wrapper(winstonLogger.info);
winstonLogger.verbose = wrapper(winstonLogger.verbose);
winstonLogger.debug = wrapper(winstonLogger.debug);
winstonLogger.silly = wrapper(winstonLogger.silly);

यह हमारे लिए एक बहुत बड़ा ब्रेकिंग बदलाव है। यदि यह जानबूझकर किया गया है, तो इसे https://github.com/winstonjs/winston/blob/master/UPGRADE-3.0.md में विस्तृत किया जाना चाहिए।

तो कुछ और जांच के बाद, मैंने पाया कि कई तर्कों को मुद्रित करने के लिए आपको स्प्लैट फॉर्मेटर की आवश्यकता है। मैंने सोचा था कि यह सिर्फ तर्क प्रक्षेप के लिए था (यानी इसमें %s आदि के साथ सामान), लेकिन ऐसा लगता है कि आपको इसे केवल logger.info("something", value) ।

लेकिन यह अभी भी मेरे लिए थोड़ा अजीब है - मुझे कुछ ऐसा मिल रहा है जो JSON की तरह एक कुंजी "मेटा" के साथ आउटपुट में दिखता है, भले ही मैं JSON प्रारूप का उपयोग नहीं कर रहा हूं:

logger.info('Test: %s', 1, 2, 3, 4);

उत्पादन करता है:

info: Test: 1 {"meta":[2,3,4]}

यहां तक ​​​​कि उदाहरणों में उदाहरण भी वह नहीं देता जो वह कहता है:

https://github.com/winstonjs/winston/blob/master/examples/interpolation.js#L20 -L21

info: test message first, second {"meta":{"number":123}}

मैंने इसे इन पंक्तियों के साथ कुछ का उपयोग करके हल किया है:

const { version } = require('../package');

const { createLogger, format, transports } = require('winston');
const { combine, timestamp, colorize, label, printf, align } = format;
const { SPLAT } = require('triple-beam');
const { isObject } = require('lodash');

function formatObject(param) {
  if (isObject(param)) {
    return JSON.stringify(param);
  }
  return param;
}

// Ignore log messages if they have { private: true }
const all = format((info) => {
  const splat = info[SPLAT] || [];
  const message = formatObject(info.message);
  const rest = splat.map(formatObject).join(' ');
  info.message = `${message} ${rest}`;
  return info;
});

const customLogger = createLogger({
  format: combine(
    all(),
    label({ label: version }),
    timestamp(),
    colorize(),
    align(),
    printf(info => `${info.timestamp} [${info.label}] ${info.level}: ${formatObject(info.message)}`)
  ),
  transports: [new transports.Console()]
});

एकाधिक पैरामीटर की अनुमति देने के लिए यहां एक सामान्य समाधान दिया गया है:
https://github.com/rooseveltframework/roosevelt/blob/master/lib/tools/logger.js#L29

से संबंधित:
https://github.com/winstonjs/winston/issues/1377

ऐसी बहुत सी चीजें हैं जो समान रूप से काम नहीं करती हैं।

नमस्ते, यहाँ कोई अपडेट? धन्यवाद।

विंस्टन में console.log(...args) का अनुकरण करने के लिए उचित तरीके की प्रतीक्षा कर रहा है ...

हमने splat और meta में 3.2.0 आसपास कई किनारे/कोने के मामले तय CHANGELOG.md )।

यह सुनिश्चित करेगा कि इसे 3.3.0 में संभाला जाए। आपके धैर्य के लिए धन्यवाद दोस्तों।

यह मेरे लिए एक कामकाज था:

'use strict';

const { createLogger, format, transports } = require('winston');
const { SPLAT } = require('triple-beam');

const { combine, timestamp, label, printf, colorize } = format;

const formatObject = (param) => {
  if (typeof param === 'string') {
    return param;
  }

  if (param instanceof Error) {
    return param.stack ? param.stack : JSON.stringify(param, null, 2);
  }

  return JSON.stringify(param, null, 2);
};

const logFormat = printf((info) => {
  const { timestamp: ts, level, message } = info;
  const rest = info[SPLAT] || [];
  const msg = info.stack ? formatObject(info.stack) : formatObject(message);
  let result = `${ts} ${level}: ${msg}`;

  if (rest.length) {
    result += `\n${rest.map(formatObject).join('\n')}`;
  }

  return result;
});

const logger = createLogger({
  format: combine(
    label({ label: 'app' }),
    timestamp(),
    logFormat,
  ),
  transports: [
    new transports.Console({
      format: combine(colorize()),
      handleExceptions: true,
    }),
  ],
  exceptionHandlers: [
    new transports.File({ filename: 'exceptions.log' }),
  ],
});

जब मैं तर्कों के साथ लॉग इन करने का प्रयास करता हूं तो मुझे एक अजीब आउटपुट मिलता है
var s = "Hello" log.info("asdasda", s)

आउटपुट प्राप्त करना

{"0":"H","1":"e","2":"l","3":"l","4":"o","service":"XXXX","level":"info","message":"asdasda","timestamp":"2019-04-15 13:58:51"}

मैंने सामान्य त्वरित प्रारंभ कोड का उपयोग किया

एक बात जो मैंने नोटिस की वह यह है:

• 2 ट्रांसपोर्ट के साथ एक लकड़हारा मिला (कंसोल और रोटेटिंग फाइल)
• दोनों splat प्रारूप का उपयोग करते हैं
• पहले परिवहन के लिए स्प्लैट के ट्रांसफ़ॉर्म फ़ंक्शन को कॉल SPLAT प्रतीक के तहत जानकारी पर संग्रहीत सरणी को साफ़ करता है
• दूसरे परिवहन के लिए splat के परिवर्तन समारोह के लिए कॉल पर, SPLAT सरणी खाली है और इस प्रकार अतिरिक्त तर्क अब लॉग नहीं होते हैं

आशा है कि यह तय किया जा सकता है/

नोट: विंस्टन के नवीनतम रिलीज़ किए गए संस्करण के साथ इसका परीक्षण किया गया, कोड पर त्वरित रूप से देखने से लगता है कि यह अभी भी मास्टर में ऐसा ही है (जिसमें अन्य सुधार हैं जो ऐसा लगता है)

@luislobo के समाधान पर कुछ सुधार 👏

• संदेश पर ध्यान न दें यदि यह शैली को विभाजित करता है अर्थात इसमें %s %d or %j जैसे संदेशों के लिए logger.info(`hello %s`,'world')
• रंग बनाने के लिए पुन: व्यवस्थित करने वाले पहले आते हैं https://github.com/winstonjs/winston#colorizing -standard-logging-levels
• printf फ़ॉर्मेट ऑब्जेक्ट हटाया गया
• trimEnd अगर लॉगर में अतिरिक्त तर्क प्रदान नहीं किए जाते हैं

const { version } = require('../package');

const { createLogger, format, transports } = require('winston');
const { combine, timestamp, colorize, label, printf, align } = format;
const { SPLAT } = require('triple-beam');
const { isObject,trimEnd } = require('lodash');

function formatObject(param) {
  if (isObject(param)) {
    return JSON.stringify(param);
  }
  return param;
}

const all = format((info) => {
  const splat = info[SPLAT] || []

    const isSplatTypeMessage =
        typeof info.message === 'string' &&
        (info.message.includes('%s') || info.message.includes('%d') || info.message.includes('%j'))
    if (isSplatTypeMessage) {
        return info
    }
    const message = formatObject(info.message)
    const rest = splat
        .map(formatObject)
        .join(' ')
    info.message = trimEnd(`${message} ${rest}`)
    return info
});

const customLogger = createLogger({
  format: combine(
    colorize(),
    all(),
    label({ label: version }),
    timestamp(),
    align(),
    printf(info => `${info.timestamp} [${info.label}] ${info.level}: ${info.message}`)
  ),
  transports: [new transports.Console()]
});

इसके लिए कोई और अपडेट जो मुझे याद आ रहा है? ऐसा लगता है कि इस सुविधा को फिर से जोड़ने के लिए बहुत मजबूत समर्थन है, लेकिन इसके लिए अंतिम प्रतिबद्धता लगभग 6 महीने पहले थी।

नमस्ते, विशाल बम्पर और शो स्टॉपर, 3.X पर माइग्रेट करने की कोशिश कर रहा है, शायद 2.x को थोड़ी देर के लिए रखेगा।

थोड़ा निराश :(

इसी से मेरा काम बना है:

const { format, createLogger, transports } = require('winston');
const jsonStringify = require('fast-safe-stringify');

const logLikeFormat = {
  transform(info) {
    const { timestamp, label, message } = info;
    const level = info[Symbol.for('level')];
    const args = info[Symbol.for('splat')];
    const strArgs = args.map(jsonStringify).join(' ');
    info[Symbol.for('message')] = `${timestamp} [${label}] ${level}: ${message} ${strArgs}`;
    return info;
  }
};

const debugFormat = {
  transform(info) {
    console.log(info);
    return info;
  }
};

const logger = createLogger({
  format: format.combine(
    // debugFormat, // uncomment to see the internal log structure
    format.timestamp(),
    format.label({ label: 'myLabel' }),
    logLikeFormat,
    // debugFormat, // uncomment to see the internal log structure
  ),
  transports: [
    new transports.Console()
  ]
});


logger.info('foo', 'bar', 1, [2, 3], true, { name: 'John' });

जिसके परिणामस्वरूप: 2019-07-04T21:30:08.455Z [myLabel] info: foo "bar" 1 [2,3] true {"name":"John"}

मूल रूप से format.combine एक info ऑब्जेक्ट के लिए एक पाइपलाइन सेट करता है। प्रत्येक प्रारूप फ़ंक्शन के लिए, transform को कॉल किया जाता है और अंतिम लॉग संदेश info[Symbol.for('message')] लिखा जाना चाहिए
उम्मीद है की यह मदद करेगा

मैं एक समाधान चाहता था जो %d , %o आदि का समर्थन करता है, लेकिन फिर भी किसी भी बाकी तर्कों को शामिल करने में चूक करता है, ताकि logger.info('hello %d %j', 42, {a:3}, 'some', 'more', 'arguments') इस तरह प्रस्तुत किया जा सके:

hello 42 {"a": 3} some more arguments

इसके लिए मेरा समाधान splat प्रतीक का उपयोग करके समाप्त हुआ लेकिन मैन्युअल रूप से util.format() सीधे printf से आमंत्रित किया गया, जिसमें डिफ़ॉल्ट रूप से कोई भी बाकी तर्क शामिल है:

const {format} = require('util');
const winston = require('winston');
const {combine, timestamp, printf} = winston.format;
const SPLAT = Symbol.for('splat');

const transport = new winston.transports.Console({
    format: combine(
        timestamp(),
        printf(({timestamp, level, message, [SPLAT]: args = []}) =>
            `${timestamp} - ${level}: ${format(message, ...args)}`)
    )
})

यदि आप printf नहीं चाहते हैं, तो आप निश्चित रूप से इसके बजाय एक परिवर्तन जोड़ सकते हैं जो केवल तर्कों को info.message में विस्तारित करता है, और फिर अंतिम परिणाम को अपनी पसंद के अनुसार प्रारूपित करता है:

format: combine(
  {
    transform(info) {
      const {[SPLAT]: args = [], message} = info;

      info.message = format(message, ...args);

      return info;
    }
  },
  simple()
)  

format.splat() का उपयोग करने में समस्या यह है कि यह मेल खाने वाले तर्कों का उपभोग करता है लेकिन ऐसा लगता है कि बाकी को फेंक दिया गया है। स्वयं util.format() आह्वान करके मैं उस व्यवहार को ओवरराइड कर सकता हूं।

वही मुद्दा, इस बारे में कोई अपडेट? मैं विंस्टन से प्यार करता हूं, लेकिन यह मुझे पागल कर देता है जब मैं लकड़हारे को दिए गए सभी तर्कों को प्रिंट नहीं कर सकता, जो मैं console.log() साथ कर सकता हूं।

@ fr1sk क्या आपने ऊपर मेरे स्वरूपण की कोशिश की? यह console.log() जैसा व्यवहार देता है (नोड का console.log() कार्यान्वयन आंतरिक रूप से util.format() afaik का उपयोग करता है)।

यह निराशाजनक है कि यह समस्या अभी भी हल नहीं हुई है, और मेरी संबंधित समस्या को लॉक कर दिया गया है।
मैं कई अलग-अलग टीमों के साथ काम कर रहा हूं और वे सभी v3 में माइग्रेट करते समय पिछले डीएक्स को खोने की निराशा साझा करते हैं।

मैंने पूरा दिन चीजों को आजमाने में बिताया है।
उपरोक्त समाधान करीब थे लेकिन मुझे अतिरिक्त तर्कों का रंगीकरण और लाइन ब्रेकिंग याद आ रही थी।

आईएमओ, कंसोल में लॉगिंग आनंददायक होना चाहिए।
यहाँ इसे साकार करने का मेरा प्रयास है ...

तुलना के लिए v2 सेटअप

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

const logger = new winston.Logger({
  transports: [
    new winston.transports.Console({
      level: 'info',
      colorize: true,
      prettyPrint: true,
      timestamp: true
    })
  ]
});

logger.info({ one: 1, two: 2, three: 3 });
logger.info(chalk.blue('[TEST]:'), { one: 1, two: 2, three: 3 }, [4, 5, 6]);
logger.info(chalk.blue('[TEST]:'), null, undefined, 'one', 2, { 3: 3, 4: '4' });
logger.info(chalk.blue('[TEST]:'), chalk.yellow('Bombastic'), () => {}, /foo/);
logger.error(chalk.blue('[ERR]:'), new Error('Error number 1'));
logger.error(new Error('Error number 2'));

v3 सेटअप

const { createLogger, format, transports } = require('winston');
const { inspect } = require('util');
const chalk = require('chalk');
const hasAnsi = require('has-ansi');

function isPrimitive(val) {
  return val === null || (typeof val !== 'object' && typeof val !== 'function');
}
function formatWithInspect(val) {
  const prefix = isPrimitive(val) ? '' : '\n';
  const shouldFormat = typeof val !== 'string' || !hasAnsi(val);

  return prefix + (shouldFormat ? inspect(val, { depth: null, colors: true }) : val);
}

const logger = createLogger({
  level: 'info',
  format: format.combine(
    format.timestamp(),
    format.errors({ stack: true }),
    format.colorize(),
    format.printf(info => {
      const msg = formatWithInspect(info.message);
      const splatArgs = info[Symbol.for('splat')] || [];
      const rest = splatArgs.map(data => formatWithInspect(data)).join(' ');

      return `${info.timestamp} - ${info.level}: ${msg} ${rest}`;
    })
  ),
  transports: [new transports.Console()]
});

logger.info({ one: 1, two: 2, three: 3 });
logger.info(chalk.blue('[TEST]:'), { one: 1, two: 2, three: 3 }, [4, 5, 6]);
logger.info(chalk.blue('[TEST]:'), null, undefined, 'one', 2, { 3: 3, 4: '4' });
logger.info(chalk.blue('[TEST]:'), chalk.yellow('Bombastic'), () => {}, /foo/);
logger.error(chalk.blue('[ERR]:'), new Error('Error number 1'));
logger.error(new Error('Error number 2'));

संभालने के लिए बहुत सी चीज़ें हैं, जिनमें से कुछ

• पहले तर्क के रूप में एक वस्तु जैसा मान
• मिश्रित मूल्यों के कई तर्क
• एएनएसआई एस्केप कोड के साथ स्ट्रिंग्स, उदाहरण के लिए chalk
• गूढ़ मान जैसे Function और RegEx
• पहले तर्क के रूप में या उसके बाद कहीं भी त्रुटि
• अन्य स्वरूपकों के साथ अभी भी ठीक काम करना चाहिए

इस समाधान के साथ वर्तमान बग

• 1 तर्क के रूप में एक त्रुटि पास करना स्टैक ट्रेस को प्रिंट नहीं करता है
  
  
  
  • ऐसा इसलिए है क्योंकि info.message सिर्फ एक स्ट्रिंग है और स्टैक ट्रैक्ट stack संपत्ति में है
  
  
• किसी ऑब्जेक्ट को message संपत्ति के साथ पास करना पहले तर्क के रूप में केवल message प्रिंट करता है, किसी भी अन्य गुणों को छोड़कर
  
  
  
  • ऊपर वाले के समान कारण
  
  
• त्रुटि को दूसरे तर्क के रूप में पास करना किसी भी तरह info.message (जो आमतौर पर पहले तर्क का मान होता है) के शीर्ष पर त्रुटि संदेश को जोड़ता है, जिसके परिणामस्वरूप त्रुटि संदेश दो बार दिखाई देता है
  
  
  
  • https://github.com/winstonjs/winston/issues/1660 . में ट्रैक किया गया
  
  
  • यह वास्तव में README का हिस्सा है:
    
    > नोट: प्रदान की गई मेटा ऑब्जेक्ट में कोई भी {संदेश} संपत्ति स्वचालित रूप से पहले से प्रदान किए गए किसी भी संदेश से जुड़ जाएगी: उदाहरण के लिए नीचे 'दुनिया' को 'हैलो' पर जोड़ दिया जाएगा:
  
  

errors फॉर्मेटर के साथ खेलने से कोई फायदा नहीं हुआ।

सकारात्मक वृद्धि

• आदिम मूल्यों को लॉग करना अब सुंदर हो जाता है
• कई ऑब्जेक्ट-जैसे मानों को लॉग करना अब उनके बीच एक नई पंक्ति जोड़ता है
• सूचकांक कुंजियों के साथ एक वस्तु की तरह दिखने के बजाय एक ऐरे को लॉग करना अब सुंदर है

संपादित करें:

हम त्रुटियों के स्वरूपण को संभाल सकते हैं लेकिन यह हैकी है:

function formatWithInspect(val) {
+ if (val instanceof Error) {
+   return '';
+ }

  const prefix = isPrimitive(val) ? '' : '\n';
  const shouldFormat = typeof val !== 'string' || !hasAnsi(val);

  return prefix + (shouldFormat ? inspect(val, { depth: null, colors: true }) : val);
}

...
    format.printf((info) => {
      const msg = formatWithInspect(info.message);
      const splatArgs = info[Symbol.for('splat')] || [];
      const rest = splatArgs.map((data) => formatWithInspect(data)).join(' ');
+    const stackTrace = info.stack ? `\n${info.stack}` : '';

      return `${info.timestamp} - ${info.level}: ${msg} ${rest}${stackTrace}`;
    })
...

यह मेरे लिए info[Symbol.for('splat')] का उपयोग करके काम करता है

const logger = winston.createLogger({
    level: 'debug',
    transports: [
        ...
    ],
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.printf((info: any) => {
            const timestamp = info.timestamp.trim();
            const level = info.level;
            const message = (info.message || '').trim();
            const args = info[Symbol.for('splat')];
            const strArgs = (args || []).map((arg: any) => {
                return util.inspect(arg, {
                    colors: true
                });
            }).join(' ');
            return `[${timestamp}] ${level} ${message} ${strArgs}`;
        })
    )
});

मैं समझता हूं कि प्रमुख संस्करण ब्रेकिंग परिवर्तन पेश करते हैं, लेकिन मेरी अच्छाई ...

किसी भी समाधान ने मुझे विंस्टन v2 के समान व्यवहार नहीं दिया।
@henhal और @yamadashy दोनों के समाधान में एक ही समस्या है: संदेश मान स्ट्रिंग के रूप में दिखाया गया है।
logger.debug(err) लॉग संदेश बनाएं:

debug:  Error: ETIMEDOUT

जबकि logger.debug('anystringhere', err) बनाता है:

debug:  anystringhereError: ETIMEDOUT { RequestError: Error: ETIMEDOUT
    at new RequestError (/path/to/node_modules/request-promise-core/lib/errors.js:14:15)
 <the rest of full error stack here>

दूसरा मुद्दा यह है कि सूचना स्तर के साथ उपयोग करते समय अतिरिक्त तर्कों को दबा दिया जाता है - विंस्टन v3 स्वरूपण से पहले इसे दूसरी तरह से संभालता है।

तीसरा मुद्दा 2 संदेशों के बीच अनुपलब्ध स्थान है (नोटिस "anystringhereError")।

मेरा वर्तमान v3 लकड़हारा विन्यास:

const { format } = require('util');
const winston = require("winston");

const logger = winston.createLogger({
  transports: [
    new winston.transports.Console({
      level: 'debug'
      format: winston.format.combine(
          winston.format.colorize(),
          winston.format.align(),
          winston.format.printf(
              ({level, message, [Symbol.for('splat')]: args = []}) => `${level}: ${format(message, ...args)}`
          )
      )
    }),
  ]
});
module.exports = logger;

मेरे पास इसके लिए पर्याप्त था और विंस्टन v2 पर वापस स्विच करने वाला था:

const Winston = require("winston");

const logger = new Winston.Logger({
  transports: [
    new Winston.transports.Console({
      level: 'debug',
      handleExceptions: true,
      json: false,
      colorize: true,
    })
  ],
});
module.exports = logger;

इस v2 कॉन्फ़िगरेशन में उपर्युक्त समस्याएँ नहीं हैं।

मैं अपना विंस्टन सेटअप साझा करना चाहता हूं:

const util = require('util');
const { createLogger, format, transports } = require('winston');
const { combine, colorize, timestamp, printf, padLevels} = format;

const myFormat = printf(({ level, message, label, timestamp, ...rest }) => {
    const splat = rest[Symbol.for('splat')];
    const strArgs = splat ? splat.map((s) => util.formatWithOptions({ colors: true, depth: 10 }, s)).join(' ') : '';
    return `${timestamp}  ${level}  ${util.formatWithOptions({ colors: true, depth: 10}, message)} ${strArgs}`;
});

const logger = createLogger({
    level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
    format: combine(
        colorize(),
        timestamp({
            format: 'YYYY-M-DD HH:mm:ss',
        }),
        padLevels(),
        myFormat
    ),
    transports: [new transports.Console()],
});

logger.info('test info');
logger.error('test error');
logger.debug('test debug');

एकाधिक पैरामीटर की अनुमति देने के लिए यहां एक सामान्य समाधान दिया गया है:
https://github.com/rooseveltframework/roosevelt/blob/master/lib/tools/logger.js#L29

यहाँ प्रस्तावित समाधान के लिए अद्यतन लिंक है
https://github.com/rooseveltframework/roosevelt/blob/0.13.0/lib/tools/logger.js

मेरा @alexilyaev महान सुझावों का एक रूपांतर है:

const { omit } = require('lodash');
const hasAnsi = require('has-ansi');

function isPrimitive(val) {
  return val === null || (typeof val !== 'object' && typeof val !== 'function');
}
function formatWithInspect(val) {
  if (val instanceof Error) {
    return '';
  }

  const shouldFormat = typeof val !== 'string' && !hasAnsi(val);
  const formattedVal = shouldFormat
    ? inspect(val, { depth: null, colors: true })
    : val;

  return isPrimitive(val) ? formattedVal : `\n${formattedVal}`;
}

// Handles all the different log formats for console
function getDomainWinstonLoggerFormat(format) {
  return format.combine(
    format.timestamp(),
    format.errors({ stack: true }),
    format.colorize(),
    format.printf((info) => {
      const stackTrace = info.stack ? `\n${info.stack}` : '';

      // handle single object
      if (!info.message) {
        const obj = omit(info, ['level', 'timestamp', Symbol.for('level')]);
        return `${info.timestamp} - ${info.level}: ${formatWithInspect(obj)}${stackTrace}`;
      }

      const splatArgs = info[Symbol.for('splat')] || [];
      const rest = splatArgs.map(data => formatWithInspect(data)).join('');
      const msg = formatWithInspect(info.message);

      return `${info.timestamp} - ${info.level}: ${msg}${rest}${stackTrace}`;
    }),
  );
}

जैसे लॉग के लिए:

logger.info({
    joe: 'blow',
  });
  logger.info('Single String');
  logger.info('With Func ', () => {}, /foo/);
  logger.info('String One ', 'String Two');
  logger.info('String One ', 'String Two ', 'String Three');
  logger.info('Single Object ', {
    test: 123,
  });
  logger.info(
    'Multiple Objects ',
    {
      test: 123,
    },
    {
      martin: 5555,
    },
  );
  logger.error('Error: ', new Error('Boom!'));

यह इस तरह से आउटपुट करता है - जो मेरे सभी परिदृश्यों के लिए अच्छा है:

अरे, मैं विंस्टन से शुरू कर रहा हूं, कभी भी v2 का उपयोग नहीं किया, इसलिए मैं v3.2.1 पर हूं

मैं बस करने की कोशिश कर रहा था:

import winston, { format } from 'winston';
winston.format(format.combine(format.splat(), format.simple()));

winston.info('buildFastify dataPath %s', opts.dataPath);

और उम्मीद है कि स्ट्रिंग इंटरपोलेशन काम करता है; लेकिन नहीं।

{"level":"info","message":"buildFastify dataPath %s"}

जब मैं उम्मीद कर रहा था

{"level":"info","message":"buildFastify dataPath /My/Data/Path"}

यह मुद्दा किसी तरह एक ही बात है? या मुझे इसके बजाय logger.log('info', .....) फ़ंक्शन का उपयोग करने के लिए मजबूर किया गया है?

संपादित करें

यह कोशिश करने वाली घटना काम नहीं करती है।

  winston.log('info', 'buildFastify dataPath %s', opts.dataPath);

आउटपुट:

{"level":"info","message":"buildFastify dataPath %s"}

ऊपर सुझावों को पोस्ट करने के लिए धन्यवाद।
धिक्कार है मैंने अपने प्रोजेक्ट पर विंस्टन 3 को एकीकृत करने के लिए सिर्फ एक दिन फेंक दिया है: /

इसने मुझे आज मारा - मुझे एहसास हुआ कि मेरा फैंसी नया लकड़हारा मेरे सभी ...rest तर्कों को उछाल रहा था। यह हर किसी या हर उपयोग के मामले के लिए काम नहीं कर सकता है, लेकिन मेरे मामले में मैंने एक सरणी के रूप में लॉग इन करने के लिए जो कुछ भी चाहता था उसे लपेटने के लिए स्वीकार्य पाया। यह सबसे सुंदर नहीं है, लेकिन यह कुछ [बहुत चालाक] कामकाज से हल्का है जिसके लिए अधिक कोड की आवश्यकता होती है। मनाइए कि यह किसी और के लिए सहायक हो!

logger.info(["Something happened!", foo, bar]);

वास्तव में परेशान है कि उन्होंने इतना बड़ा बदलाव करने का फैसला किया और अभी भी माइग्रेशन गाइड या दस्तावेज़ीकरण में इसका उल्लेख नहीं किया है।

भले ही मैं अपना समाधान साझा करना चाहता था जो मुझे काफी कॉम्पैक्ट लगा और इस प्रकार है कि नोड जेएस कंसोल को कैसे लागू करता है। util.format का उपयोग करके लॉग इन करें

const winstonLogger= createLogger(...);

const writeLogType = (logLevel) => {
    return function () {
        const args = Array.from(arguments);
        winstonLogger[logLevel](util.format(...args));
    };
};

const logger = {
    silly: writeLogType('silly'),
    debug: writeLogType('debug'),
    verbose: writeLogType('verbose'),
    info: writeLogType('info'),
    warn: writeLogType('warn'),
    error: writeLogType('error'),
};

मैं इसमें शामिल होना चाहता हूं और इस सुविधा को कोर विंस्टन में जोड़ने का अनुरोध करता हूं। वर्तमान में, मैं इस कार्यक्षमता को प्राप्त करने के लिए splat साथ कस्टम फॉर्मेटर का उपयोग कर रहा हूं, जो ईमानदारी से बहुत हैकी महसूस करता है। console.log मेल खाने वाली कार्यक्षमता होना अच्छा होगा

कोई सुधार?

v3 के लिए उपरोक्त व्यवहार के अलावा, मैं इसे भी जोड़ना चाहता हूं:

logger.info('param 1', { propInJson1: 'propInJson 1', propInJson2: 'propInJson 2' });

इसका उत्पादन करेंगे

{"propInJson1":"propInJson 1","propInJson2":"propInJson 2","level":"info","message":"param 1"}

मैं जिस संस्करण का उपयोग कर रहा हूं: (v3.2.1)
विन्यास:

winstonLogger.add(new winston.transports.Console());

मैं अभी भी समझ नहीं पा रहा हूं कि विंस्टन में एकाधिक मानों को कैसे आउटपुट किया जाए।

मैं बस console.log('Hello', var1, '!') को logger.log('Hello', var1, '!') से बदलना चाहता था।

ईमानदार होने के लिए, विंस्टन का उपयोग करने की कोशिश करने से हमेशा बहुत समय बर्बाद होता है और लॉगिंग के साथ आश्चर्यजनक समस्याएं होती हैं।

वास्तव में परेशान है कि उन्होंने इतना बड़ा बदलाव करने का फैसला किया और अभी भी माइग्रेशन गाइड या दस्तावेज़ीकरण में इसका उल्लेख नहीं किया है।

भले ही मैं अपना समाधान साझा करना चाहता था जो मुझे काफी कॉम्पैक्ट लगा और इस प्रकार है कि नोड जेएस कंसोल को कैसे लागू करता है। util.format का उपयोग करके लॉग इन करें

const winstonLogger= createLogger(...);

const writeLogType = (logLevel) => {
    return function () {
        const args = Array.from(arguments);
        winstonLogger[logLevel](util.format(...args));
    };
};

const logger = {
    silly: writeLogType('silly'),
    debug: writeLogType('debug'),
    verbose: writeLogType('verbose'),
    info: writeLogType('info'),
    warn: writeLogType('warn'),
    error: writeLogType('error'),
};

इसके अलावा, का उपयोग util.formatWithOptions({ colors: true }, ...args); नियमित के साथ की तरह प्रिंट आउटपुट रंग करने के लिए console.log

यह मेरे लिए काम करता है। combineMessageAndSplat जो util.format का उपयोग करके संदेश और विभाजन को जोड़ती है

const winston = require("winston");
const util    = require('util');

const combineMessageAndSplat = () => {
    return {transform: (info, opts) => {
      //combine message and args if any
      info.message =  util.format(info.message, ...info[Symbol.for('splat')]  ||  [] )
      return info;
    }
  }
}

const logger = winston.createLogger({
  format:
    winston.format.combine(
      combineMessageAndSplat(),
      winston.format.simple()
    )
});

logger.add(new winston.transports.Console({
    level: 'info'
  })
);

logger.info("string");          // info: string
logger.info({a:1,b:[{c:[1]}]}); // info: { a: 1, b: [ { c: [Array] } ] }
logger.info("1","2",{a:1});     // info: 1 2 { a: 1 }
logger.info([{},""]);           // info: [ {}, '' ]
logger.error(new Error());      // error: Error ...    at Object.<anonymous> 

मुझे कंसोल के अनुरूप होना था। * विधियां, उपरोक्त सभी पर उन्मुख, और ...

• क्रोम-देव-टूल्स के लिए डिफ़ॉल्ट कंसोल विधियां (वे डिफ़ॉल्ट रूप से रंगीन होती हैं)
• इलेक्ट्रॉन टर्मिनल कंसोल आउटपुट (डिफ़ॉल्ट रूप से रंगीन भी)
• एक फ़ाइल में लिखना

लेकिन: फ़ाइल आउटपुट को ऑब्जेक्ट विवरण दिखाना चाहिए।

तो मैं इसके साथ समाप्त हुआ:

// make File and FileList parseable // from: https://stackoverflow.com/a/51939522/1644202
File.prototype.toObject = function () {
    return Object({
        name: String(this.name),
        path: String(this.path),
        lastModified: parseInt(this.lastModified),
        lastModifiedDate: String(this.lastModifiedDate),
        size: parseInt(this.size),
        type: String(this.type)
    });
};

FileList.prototype.toArray = function () {
    return Array.from(this).map(function (file) {
        return file.toObject()
    });
};

// this fixes: winston console transport to use the original console functions and all the colorization/folding/etc that comes with it
const Transport = require('winston-transport');
class WebDeveloperConsole extends Transport {
    constructor(opts) {
        super(opts);
    }

    log(info, callback) {
        (window.console[info.level] || window.console.log).apply(window.console, [info.timestamp, ...info.message]);
        callback();
    }
};

// Electron app console output
class AppConsole extends Transport {
    constructor(opts) {
        super(opts);

        const { remote } = require('electron');
        this.electronConsole = remote.getGlobal('console');
    }

    log(info, callback) {
        (this.electronConsole[info.level] || this.electronConsole.log).apply(this.electronConsole, [info.timestamp, ...info.message]);
        callback();
    }
};

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

let logger = createLogger({
    level: 'trace',
    levels: {
        error: 0,
        warn: 1,
        info: 2,
        //http: 3,   no console.* methods
        //verbose: 4,
        debug: 3,
        trace: 4
    },

    format: format.combine(
        format.prettyPrint(),
        format.timestamp({
            format: 'DD-MM-YYYY hh:mm:ss A'
        }),

        {
            transform(info) {
                const { timestamp, message } = info;
                const level = info[Symbol.for('level')];
                const args = [message, ...(info[Symbol.for('splat')] || [])];  // join the args back into one arr
                info.message = args;  // for all custom transports (mainly the console ones)

                let msg = args.map(e => {
                    if (e.toString() == '[object FileList]')
                        return util.inspect(e.toArray(), true, 10);
                    else if (e.toString() == '[object File]')
                        return util.inspect(e.toObject(), true, 10);
                    else if (e.toString() == '[object Object]') {
                        return util.inspect(e, true, 5);
                    }
                    else if (e instanceof Error)
                        return e.stack
                    else
                        return e;
                }).join(' ');

                info[Symbol.for('message')] = `${timestamp} - ${level}: ${msg}`; // for inbuild transport / file-transport

                return info;
            }
        },
    ),
    transports: [
        //new transports.Console(),
        new WebDeveloperConsole(),
        new AppConsole(),
        ...
    ],
    ...
});

@indexzero सोच रहा था कि क्या आप अभी भी इसे किसी बिंदु पर संबोधित करने की योजना बना रहे हैं?

मैं अपनी परियोजना में उपयोग करने के लिए विंस्टन की खोज कर रहा हूं, अब सोच रहा हूं कि क्या यह जोखिम लेने लायक है क्योंकि यह मुद्दा 2 साल से अधिक समय से खुला है। मेरे लिए यह किसी भी लॉगिंग ढांचे के लिए एक बुनियादी कार्य की तरह लगता है