winston 🚀 - [३.०.०] त्रुटि वस्तु पार्स या मुद्रित नहीं है

इसके लिए हमारे पास कुछ परीक्षण कवरेज हैं , लेकिन स्पष्ट रूप से हमें और अधिक की आवश्यकता है। कवर के तहत क्या हो रहा है:

आपका Error उदाहरण objectMode स्ट्रीम पाइप-चेन के साथ पारित किया गया है
Logger लिए डिफ़ॉल्ट प्रारूप json (देखें: json प्रारूप कोड logform )
message और stack गुण Error पर गैर-गणना योग्य हैं जो JSON.stringify को कुछ ऐसा आउटपुट करने का कारण बनता है जिसकी कोई उम्मीद नहीं करता है।

console.log(JSON.stringify(new Error('lol nothing here')));
// '{}'

एक डिजाइन दृष्टिकोण से winston@3 शुरू की formats वृद्धि प्रदर्शन करने के लिए समस्या का वास्तव में इस तरह के। प्रदर्शन की बात करें तो, दिलचस्प रूप से पर्याप्त pino यहां कुछ दिलचस्प करता है । शायद समाधान डिफ़ॉल्ट json प्रारूप में asJson समान कुछ लागू कर रहा है।

indexzero 30 मई 2018

यदि कोई त्वरित समाधान की तलाश में है तो आप अभी के लिए अपने लकड़हारे के प्रारूप में enumerateErrorFormat शामिल कर सकते हैं। हम उम्मीद करते हैं कि अगले सप्ताह (या इसके तुरंत बाद 3.0.1 ) से पहले 3.0.0 से पहले इसे ठीक कर लेंगे।

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

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

const logger = createLogger({
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new transports.Console()
  ]
});

// Error as message
console.log('Run FIRST test...');
logger.log({ level: 'error', message: new Error('FIRST test error') });

// Error as info (one argument)
console.log('\nRun SECOND test...');
const err = new Error('SECOND test error');
err.level = 'info';
logger.info(err);

// Error as info (two arguments);
console.log('\nRun THIRD test...');
logger.log('info', new Error('THIRD test error'));

indexzero 30 मई 2018

👍14 👎11

@indexzero , मैंने आपके कामकाज का पालन करने की कोशिश की, लेकिन यह काम नहीं कर रहा है। जानते हो क्यों?

फ़ॉर्मेटर:
``` javascript const level = settings.debug ? 'debug' : 'info'; const printFormat = winston.format.printf(info => ${info.timestamp} - ${info.level}: ${info.message}`);
const enumerateErrorFormat = विंस्टन। प्रारूप (जानकारी => {
अगर (info.message उदाहरण त्रुटि) {
info.message = ऑब्जेक्ट.असाइन ({
संदेश: info.message.message,
स्टैक: info.message.stack,
}, info.message);
}
अगर (सूचना उदाहरण त्रुटि) {
वापसी वस्तु.असाइन ({
संदेश: info.message,
स्टैक: info.stack,
}, जानकारी);
}
वापसी की जानकारी;
});

कॉन्स्ट कंसोललॉगर = विंस्टन। क्रिएटलॉगर ({
स्तर,
प्रारूप: विंस्टन। प्रारूप। टाइमस्टैम्प (),
परिवहन: [
न्यू विंस्टन.ट्रांसपोर्ट्स.कंसोल ({
प्रारूप: विंस्टन.format.combine(
विंस्टन.format.colorize (),
गणना त्रुटिफॉर्मेट (),
प्रिंटफॉर्मेट,
),
}),
],
});
Code: जावास्क्रिप्ट
प्रयत्न {
// कुछ कोड फेंकने में त्रुटि
} पकड़ो (गलती) {
लकड़हारा.त्रुटि (त्रुटि);
}
Output:
2018-06-28T21:17:25.140Z - त्रुटि: अपरिभाषित
Info object: जावास्क्रिप्ट
{स्तर: '\u001b[31merror\u001b[39m', टाइमस्टैम्प: '2018-06-28T21:17:25.140Z', [प्रतीक(स्तर)]: 'त्रुटि'}
````
त्रुटि लॉग में संदेश विशेषता कहाँ है?

sandrocsimas 28 जून 2018

👍1

@sandrocsimas मैंने देखा है कि इसे काम करने के लिए आपको लॉगर के डिफ़ॉल्ट

फ़ॉर्मेटर

const consoleLogger = winston.createLogger({
  level,
  format: winston.format.combine(
    winston.format.timestamp(),
    enumerateErrorFormat()
  ),
  transports: [
    new winston.transports.Console({
      format: winston.format.combine(
        winston.format.colorize(),
        printFormat,
      ),
    }),
  ],
});

मुझे अभी भी समझ में नहीं आता कि क्यों

Crusnak 29 जून 2018

👍1

मुझे लगता है कि मैं @sandrocsimas के समान बग का अनुभव कर रहा हूं।

यहाँ मेरी लकड़हारा विन्यास है:

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

const winston = require('winston');
const {configure, format} = winston;
const {combine, colorize, timestamp, printf} = format;

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

const myConsoleFormat = printf(info => {
  console.log('** Info Object: **');
  console.log(info);
  console.log('** Winston Output: **');
  return `${info.level}: ${info.message}`;
});

winston.configure({
  transports: [
    new winston.transports.Console({
      format: combine(
        colorize(),
        enumerateErrorFormat(),
        myConsoleFormat
      ),
    })
  ]
});

अगर मैं कोड के इस ब्लॉक के साथ इसका परीक्षण करता हूं:

टेस्ट ए

const logger = require('winston');
try {
  throw(new Error());
} catch (err) {
  logger.error(err);
}

जहां new Error() में कोई संदेश मान नहीं है, मुझे यह आउटपुट मिलता है:

आउटपुट ए

** Info Object: **
{ message: 
   { message: '',
     stack: 'Error\n    at Object.<anonymous> (app.js:21:9)\n    at Module._compile (module.js:652:30)\n    at Object.Module._extensions..js (module.js:663:10)\n    at Module.load (module.js:565:32)\n    at tryModuleLoad (module.js:505:12)\n    at Function.Module._load (module.js:497:3)\n    at Module.require (module.js:596:17)\n    at require (internal/module.js:11:18)\n    at Object.<anonymous> (server.js:11:13)\n    at Module._compile (module.js:652:30)' },
  level: '\u001b[31merror\u001b[39m',
  [Symbol(level)]: 'error',
  [Symbol(message)]: '{"message":{},"level":"error"}' }
** Winston Output: **
error: [object Object]

जहां error: [object Object] वही है जिसकी मुझे उम्मीद थी

हालांकि, अगर मैं कोड के इस ब्लॉक के साथ इसका परीक्षण करता हूं:

टेस्ट बी

const logger = require('winston');
try {
  throw(new Error('This causes error: undefined'));
} catch (err) {
  logger.error(err);
}

जहां new Error() में एक संदेश मान होता है, मुझे यह आउटपुट मिलता है:

आउटपुट बी

** Info Object: **
{ level: '\u001b[31merror\u001b[39m',
  [Symbol(level)]: 'error',
  [Symbol(message)]: '{"level":"error"}' }
** Winston Output: **
error: undefined

जैसा कि आप देख सकते हैं मुझे वही error: undefined जो @sandrocsimas को मिलता है। मुझे error: [object Object] मिलने की उम्मीद

नोट, अगर मैं कोड के इस ब्लॉक को आजमाता हूं:

टेस्ट सी

const logger = require('winston');
try {
  throw(new Error('This should work'));
} catch (err) {
  logger.log({level: 'error', message: err});
}

जहां मैं logger.log बजाय logger.error हूं, मुझे उपरोक्त आउटपुट ए के समान आउटपुट मिलता है

SamuelMaddox 29 जून 2018

👍2

मेरी भी यही समस्या है। मैं विंस्टन में नया हूँ। मैंने @indexzero समाधान की कोशिश की लेकिन काम नहीं कर रहा। क्या आपके पास कोई उपाय है?

nvtuan305 7 जुल॰ 2018

@ nvtuan305 , क्या आपने @indexzero के समाधान का बिल्कुल प्रयास किया या आपने इसे थोड़ा संपादित किया? यदि हां, तो क्या आप नमूना कोड प्रदान कर सकते हैं? आप उपयोग कर रहे हैं उनके कोड काम करना चाहिए logger.log({level: ____, message: err}); यह आप कर रहे हैं काम नहीं होगा logger.info , logger.error , या किसी अन्य का स्वाद logger.<level> . मैं लगभग निश्चित हूं कि यह एक बग है जैसा कि मैंने ऊपर निर्दिष्ट किया है और इसे बाद के रिलीज में ठीक किया जाना चाहिए।

SamuelMaddox 7 जुल॰ 2018

👍3

क्या मुझे कुछ याद आ रहा है, या यह एक ही आउटपुट प्राप्त करने के लिए एक पूर्ण सिरदर्द (या असंभव भी है?)

try {
   // ...
  throw new Error('foo');
} catch (e) {
  console.error('Caught error:', e);  // convenient, informative
  logger.error('Caught error:', e);  // nope, the second parameter is something else (couldn't find docs)
  logger.error(`Caught error: ${e}`);  // stack lost
  logger.error(`Caught error: ${JSON.stringify(e)}`);  // Caught error: {}
}

समान आउटपुट प्राप्त करने के लिए समतुल्य विंस्टन कोड क्या है
console.error('Caught error:', error); ?

और लॉगर ऑब्जेक्ट पर सुविधा विधियों द्वारा लिए गए पैरामीटर के लिए दस्तावेज़ीकरण कहां है?

dandv 8 जुल॰ 2018

👍48 😄1

@dandv

logger.error('Caught error:', e);

यह काम नहीं करता क्योंकि, console.log() विपरीत, विंस्टन का logger.<level>(message) केवल एक पैरामीटर लेता है जिसे संदेश कहा जाता है। वह संदेश पैरामीटर या तो एक वस्तु या एक स्ट्रिंग है (अगर मैं गलत हूं तो कोई मुझे सही करेगा लेकिन यह मेरी समझ है)।

ध्यान दें कि आप logger.log({level: <level>, message: <message>}) भी उपयोग कर सकते हैं। इन दो कार्यों के बारे में अधिक जानने के लिए मैं डॉक्स के इस भाग को पढ़ने की सिफारिश करूंगा: विंस्टन डॉक्स ऑन लॉग लेवल । लॉगिंग स्तर का उपयोग करके पढ़ना सुनिश्चित करें

logger.error(`Caught error: ${e}`);

मैं निश्चित रूप से यह नहीं कह सकता कि यह स्टैक को आउटपुट क्यों नहीं करता है, लेकिन मुझे पता है कि यह विंस्टन के साथ कोई समस्या नहीं है। यदि आप console.log(`Caught error: ${e}`) करते हैं तो इसमें स्टैक भी शामिल नहीं होता है। मैंने टेम्प्लेट लिटरल्स के साथ बहुत अधिक काम नहीं किया है, इसलिए या तो टेम्प्लेट लिटरल्स ऑब्जेक्ट्स के साथ अच्छी तरह से काम नहीं करते हैं, या जावास्क्रिप्ट का कंसोल.लॉग ऑब्जेक्ट को एक एरर ऑब्जेक्ट के रूप में पहचानता है और इस प्रकार केवल मैसेज प्रॉपर्टी को आउटपुट करता है। यह मेरा सबसे अच्छा अनुमान है।

logger.error(`Caught error: ${JSON.stringify(e)}`)

यह बग थ्रेड किस बारे में है, इसके दिल में उतर जाता है। सबसे पहले आपको जावास्क्रिप्ट के बारे में कुछ तकनीकी विवरणों को समझना होगा। ध्यान दें कि यदि आप console.log(`Caught error: ${JSON.stringify(e)}`) प्रयास करते हैं तो आपको वही आउटपुट Caught error: {} भी मिलता है। जैसा कि @indexzero ने समझाया:

message और stack पर Error stack गुण गैर-गणना योग्य हैं जो JSON.stringify को कुछ ऐसा आउटपुट करने का कारण बनता है जिसकी कोई उम्मीद नहीं करता है।

मूल रूप से, क्योंकि message और stack गुण गैर-गणना योग्य हैं, JSON.stringify उन गुणों पर छोड़ देता है जो इस तरह से आप एक खाली वस्तु के साथ समाप्त होते हैं {} । एन्यूमरेबिलिटी को बेहतर ढंग से समझने के लिए मैं इस एन्यूमरेबिलिटी और प्रॉपर्टी के स्वामित्व को पढ़ने की सलाह देता हूं।

सौभाग्य से, जिस तरह से विंस्टन 3.0 को डिजाइन किया गया था (विंस्टन टीम के लिए सहारा) हमारे पास इसके लिए एक वर्कअराउंड है जो @indexzero ने दिया था। मैं इसे समझाने में मदद करूंगा। सबसे पहले आप यह फ़ंक्शन बनाएं:

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

डॉक्स स्ट्रीम, ऑब्जेक्टमोड, और जानकारी ऑब्जेक्ट से जानकारी ऑब्जेक्ट में दो गुण हैं, info.level , और info.message । यही कारण है कि info.message संपत्ति त्रुटि उद्देश्य यह है कि अगर आप सभी में पारित कर दिया है। तो हम एक नई वस्तु बनाने जहां message.stack और message.message (के रूप में समझें Error.stack और Error.message ) अब गणना योग्य हैं, और हम उन अन्य गुणों को शामिल करते हैं जो उस त्रुटि ऑब्जेक्ट से भी संलग्न हो सकते हैं।

आगे आप इस लकड़हारे को बनाएंगे जो ऊपर दिए गए enumerateErrorFormat() फ़ंक्शन का उपयोग करता है:

const logger = createLogger({
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new transports.Console()
  ]
});

इसमें जो कुछ भी message आप पास करेंगे और जांच लेंगे कि यह एक त्रुटि वस्तु है या नहीं। अगर ऐसा है तो यह गणना की समस्या को ठीक कर देगा। फिर यह format.json संदेश भेजता है जो किसी ऑब्जेक्ट (त्रुटि या नहीं) को स्ट्रिंग करेगा। यदि यह कोई वस्तु नहीं है तो यह एक स्ट्रिंग है और format.json इफेक्टिवली कुछ भी नहीं करता है, और आप घर से मुक्त हैं!

फिर भी, यह अच्छा होगा यदि हमें वह enumerateErrorFormat नहीं बनाना पड़े क्योंकि त्रुटि ऑब्जेक्ट आमतौर पर लॉग होते हैं। जैसा कि मैं समझता हूं कि विंस्टन टीम एक फिक्स पर काम कर रही है जिसे बाद के संस्करण में जारी किया जाएगा।

कुछ अंतिम नोट। यह केवल तभी काम करता है जब आप logger.log({level: <level>, message: <message>}) जहां संदेश त्रुटि वस्तु है। उदाहरण:

try {
  throw(new Error('This should work'));
} catch (err) {
  logger.log({level: 'error', message: err});
}

विंस्टन में एक और बग है जहां यह कोड काम नहीं करता है, जैसा कि मैंने उपरोक्त मेरी अन्य पोस्ट में बताया है:

try {
  throw(new Error('This will not work'));
} catch (err) {
  logger.error(err);
}

जब हम logger.error(err) उपयोग करते हैं तो किसी कारण से info.message संपत्ति अपरिभाषित होती है। उम्मीद है कि @indexzero इसका पता

SamuelMaddox 8 जुल॰ 2018

🎉14 ❤10 👍4 🚀2

@SamuelMaddox17 @indexzero धन्यवाद! मैंने logger.log({level: 'error', message: err}); का उपयोग करने की कोशिश की और यह काम करता है

nvtuan305 9 जुल॰ 2018

👍2

क्या यह कृपया logger.error, आदि के लिए ठीक हो सकता है?

logger.log का उपयोग करना बोझिल और क्रियात्मक है, खासकर जब से logger.error आप आसानी से कई तर्क जोड़ सकते हैं।

inderpreet99 19 जुल॰ 2018

👍27

हे सब, मैं इस पर गौर कर रहा हूँ। @indexzero : अभी भी लगता है कि सबसे अच्छा विचार अनिवार्य रूप से enumerateErrorFormat कार्यक्षमता को डिफ़ॉल्ट रूप से json फॉर्मेटर में जोड़ना है? क्या हमें इस बारे में अलग से चिंता करने की ज़रूरत है कि क्या meta एक Error न कि केवल object (मुझे लगता है कि अगर हम उस मामले को भी नहीं संभालेंगे तो लोग शिकायत करेंगे?) ? साथ ही, मैं master का उपयोग कर रहा हूं, लेकिन ऐसा लगता है कि logger.error मेरे लिए उपरोक्त @indexzero / @ सैमुअलमैडॉक्स 17 द्वारा समाधान के साथ काम करता है:

const winston = require('winston');
const format = winston.format;

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

const logger = winston.createLogger({
  level: 'debug',
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new winston.transports.Console(),
  ],
});

logger.error(new Error('whatever'));

DABH 3 सित॰ 2018

आगे की जांच करने पर ऐसा लगता है कि ऊपर बताई गई logger.error समस्या केवल डिफ़ॉल्ट लॉगर का उपयोग करते समय एक समस्या है। @DABH , मैंने आपका कोड आज़माया और यह मेरे लिए काम करता है, लेकिन जब मैं इसे डिफ़ॉल्ट

const winston = require('winston');
const format = winston.format;

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

winston.configure({
  transports: [
    new winston.transports.Console({
      level: 'debug',
      format: format.combine(
        enumerateErrorFormat(),
        format.json()
      ),
    })
  ]
});

winston.error(new Error('whatever'));

दूसरा, मैं सहमत हूं कि enumerateErrorFormat को जोंस प्रारूप में जोड़ा जाना चाहिए; और आप शायद meta में भी सही हैं।

अंत में, मैं यह नोट करना चाहूंगा कि @DABH द्वारा दिए गए कोड उदाहरण के कारण यदि आप चाहें तो स्टैक को "सुंदर प्रिंट" न करें; कम से कम मेरी मशीन पर macOS हाई सिएरा चल रहा है। यह मेरे लिए कैसा दिखता है:

{"message":"whatever","stack":"Error: whatever\n    at Object.<anonymous> (/Users/samuelmaddox/Desktop/winston-test/index.js:33:14)\n    at Module._compile (internal/modules/cjs/loader.js:689:30)\n    at Object.Module._extensions..js (internal/modules/cjs/loader.js:700:10)\n    at Module.load (internal/modules/cjs/loader.js:599:32)\n    at tryModuleLoad (internal/modules/cjs/loader.js:538:12)\n    at Function.Module._load (internal/modules/cjs/loader.js:530:3)\n    at Function.Module.runMain (internal/modules/cjs/loader.js:742:12)\n    at startup (internal/bootstrap/node.js:266:19)\n    at bootstrapNodeJSCore (internal/bootstrap/node.js:596:3)","level":"error"}

जैसा कि आप देख सकते हैं, JSON फ़ंक्शन के साथ त्रुटि को आउटपुट करते समय न्यूलाइन वर्ण \n वास्तविक नई लाइनें नहीं बनाते हैं। ऑब्जेक्ट लेते समय और इसे JSON में कनवर्ट करते समय यह अपेक्षित व्यवहार होता है, लेकिन संभवत: वह व्यवहार नहीं है जो हम वास्तव में लॉगर से चाहते हैं, कम से कम कंसोल पर लॉगिंग करते समय।

इसमें और अधिक देखने के लिए धन्यवाद @DABH

SamuelMaddox 3 सित॰ 2018

👍1

एफवाईआई यह वह जगह है जहां मुझे इसके साथ थोड़ा सा खेलने के बाद मिल गया है:

import winston from 'winston';
const format = winston.format;

const printNice = format.printf(info => {
    const {level, message} = info;
    return `Logging Level: ${level} - Logging Message: ${message}`;
});

const enumerateErrorFormat = format(info => {
    if (info.message instanceof Error) {
        info.message = Object.assign({
            message: `${info.message.message}\n============\n${info.message.stack}`
        }, info.message);
    }

    if (info instanceof Error) {
        return Object.assign({
            message: `${info.message}\n============\n${info.stack}`
        }, info);
    }

    return info;
});

const logger = winston.createLogger({
    format: format.combine(
        enumerateErrorFormat(),
        format.json()
    ),
    transports: [
        new winston.transports.Console({
            format: format.combine(
                format.colorize(),
                printNice,
            ),
        })
    ]
});

export default logger;

petrogad 5 सित॰ 2018

👍1

समस्या इस बग के कारण है: https://github.com/winstonjs/winston-transport/issues/31

Asing1001 19 सित॰ 2018

👍2

हमने बिना किसी समस्या के विंस्टन2.x में निश्चित रूप से इस फॉर्म का इस्तेमाल किया। winston.err('some message', err); के साथ winston.error(err) उपरोक्त enumerateErrorFormat winston.error(err) ठीक करता है लेकिन दूसरे पैरामीटर के रूप में गलती के साथ उपयोग के मामले को नहीं।

barisusakli 18 अक्तू॰ 2018

👍8

@सैमुअलमैडॉक्स17

लकड़हारा.लॉग ({स्तर: ____, संदेश: त्रुटि});

यह काम करता है thx

ddemydenko 19 अक्तू॰ 2018

ठीक है, मैंने कुछ खोजा। 3 सितंबर की मेरी टिप्पणी गलत है। यह डिफ़ॉल्ट लकड़हारा के साथ कोई समस्या नहीं है। यह एक समस्या है जहां आप level और/या format को परिभाषित करते हैं। @DABH आपका पुराना कोड है:

const winston = require('winston');
const format = winston.format;

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

const logger = winston.createLogger({
  level: 'debug',
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new winston.transports.Console(),
  ],
});

logger.error(new Error('whatever'));

यदि आप इसे हटाते हैं:

const logger = winston.createLogger({
  level: 'debug',
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new winston.transports.Console(),
  ],
});

और इसे इसके साथ बदलें:

const logger = winston.createLogger({
  transports: [
    new winston.transports.Console({
      level: 'debug',
      format: format.combine(
        enumerateErrorFormat(),
        format.json()
      ),
    }),
  ],
});

फिर info.message === undefined समस्या दिखाई देती है। मेरा मानना है कि प्रत्येक परिवहन के लिए स्तर और प्रारूप निर्दिष्ट करना ठीक होना चाहिए; और मैं लगभग निश्चित हूं कि विंस्टन 2.0 में इसकी अनुमति थी।

मेरे कोड परिवर्तन के साथ आपका कोड नमूना यहां दिया गया है ताकि आप आसानी से चला सकें और परीक्षण कर सकें:

const winston = require('winston');
const format = winston.format;

const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});

const logger = winston.createLogger({
  transports: [
    new winston.transports.Console({
      level: 'debug',
      format: format.combine(
        enumerateErrorFormat(),
        format.json()
      ),
    }),
  ],
});

logger.error(new Error('whatever'));

उम्मीद है कि इससे समस्या की जड़ तक पहुंचने में मदद मिलेगी।

SamuelMaddox 31 अक्तू॰ 2018

🎉3 👍1

मैंने बनाया https://github.com/winstonjs/winston/pull/1527

इसमें सभी विकल्प शामिल हैं। हालाँकि कुछ परीक्षण विफल हो जाते हैं इसलिए मैंने इसे अभी के लिए बंद कर दिया है। विफलताओं को ठीक करने की उम्मीद है, लेकिन मुझे विश्वास नहीं है कि मैं परीक्षणों में संशोधन/हटाने के लिए कॉल करने की स्थिति में हूं।

असफल निर्माण यहाँ है https://travis-ci.org/winstonjs/winston/jobs/453012141 और यह स्पष्ट है कि जब आप परीक्षण कोड पढ़ते हैं तो परीक्षण अब विफल क्यों होते हैं:
https://github.com/winstonjs/winston/blob/c42ab7fdc51b88db180a7dd90c52ce04ddd4e054/test/logger.test.js#L668

विचार?

crowleym 8 नव॰ 2018

👍1

मुझे लगता है कि समस्या इस लाइन में है
const जानकारी = (संदेश && !(msg instanceof Error) && msg.message && msg) || {
संदेश: संदेश
};
उदाहरण के एक चेक को जोड़ने से त्रुटि @crowleym बिंदु के रूप में समस्या को हल करने लगती है

giang12 14 नव॰ 2018

किसी के लिए भी जो अभी भी इससे निपट रहा है, यह वर्कअराउंड फॉर्मेटर है जिसके साथ मैं आने में कामयाब रहा हूं (मेरे लॉगर.जेएस मॉड्यूल का स्निपेट):

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

function devFormat() {
    const formatMessage = info => `${info.level}: ${info.timestamp} ${info.message}`;
    const formatError   = info => `${info.level}: ${info.timestamp}\n\n${info.stack}\n`;
    const format        = info => info instanceof Error ? formatError(info) : formatMessage(info);

    return combine(timestamp(), printf(format));
}

किसी कारण से logger.error(new Error("hello")) केवल तभी काम करता है जब आप winston.createLogger 🤔 में फ़ॉर्मेटर को विश्व स्तर पर परिभाषित करते हैं और फिर आपको फ़ॉर्मेटर में info में त्रुटि ऑब्जेक्ट मिलता है।

यदि आप प्रति ट्रांसपोर्ट एक फॉर्मेटर को परिभाषित करते हैं तो आपको logger.log({level: "error", message: new Error("FAILED")}) info का उपयोग करना होगा और एरर ऑब्जेक्ट को एक्सेस करने के लिए info.message माध्यम से एरर ऑब्जेक्ट को हैंडल करना होगा।

मुझे लगता है कि परिवहन विकल्पों में प्रारूप फ़ील्ड सेट करते समय एक बग है?

वे सिर्फ मेरे 2 सेंट हैं और मेरे लिए क्या काम किया है, मैं विंस्टन के लिए नया हूं और जावास्क्रिप्ट में अनुभवी नहीं हूं इसलिए मुझे किसी भी चीज़ पर उद्धृत न करें।

danielvaijk 20 नव॰ 2018

👍3

मेरा दृष्टिकोण मूल कारण को ठीक करने का प्रयास था। लेकिन इसे रेपो मालिकों से ज्यादा कर्षण नहीं मिल रहा है ...

crowleym 20 नव॰ 2018

हाँ, मैं इसे समझता हूँ। मैंने सचमुच इसका पता लगाने में बहुत समय बिताया क्योंकि मैं विंस्टन के लिए नया हूं और मुझे लगा कि शायद मैं इसे गलत तरीके से इस्तेमाल कर रहा हूं या इसके पीछे की अवधारणाओं को अभी तक ठीक से समझ नहीं पाया हूं।

लेकिन सौभाग्य से मैं कुछ धागों (इसमें शामिल) पर ठोकर खाई, जो मुझे अन्यथा दिखाती थी। उम्मीद है कि वे इसे ठीक कर लेंगे, इसलिए मुझे वर्कअराउंड का उपयोग करते रहने की आवश्यकता नहीं है।

danielvaijk 20 नव॰ 2018

यह wintson-transport कारण हो सकता है, समस्या के लिए https://github.com/winstonjs/winston-transport/issues/31 देखें और https://github.com/winstonjs/winston-transport/pull/ एक जनसंपर्क के लिए

rgoupil 3 दिस॰ 2018

👍1

त्रुटि वस्तुओं की प्रत्यक्ष लॉगिंग उनके गैर-गणना योग्य गुणों के कारण हमेशा एक गड़बड़ होती है। व्यक्तिगत रूप से मैं इसे एक बुरी प्रथा मानता हूं, लेकिन समुदाय में पर्याप्त लोग इसे एक आवश्यकता के रूप में मानते हैं कि हमें इसका समर्थन करना चाहिए।

इस तरह के व्यवहारों का समर्थन करने के लिए https://github.com/winstonjs/logform/pull/59 को एक प्रारूप के रूप में अपनाने पर विचार करना। प्लस तरफ यह सभी किनारे के मामलों को समाहित करता है जो लॉग संदेशों के रूप में त्रुटियों का इलाज करते समय बहुत आम हैं। नीचे की तरफ यह एक और प्रारूप होगा जिसे लोगों को ऑप्ट-इन करना होगा (इसी तरह .splat() )

indexzero 7 दिस॰ 2018

@indexzero मैं सहमत हूं लेकिन कस्टम लॉगिंग प्रारूप/ Error प्रकारों को अलग-अलग प्रदर्शित करने की आवश्यकता है, और मुझे विंस्टन 2.x याद नहीं है इस अभ्यास से लड़ें क्योंकि इसे बॉक्स से बाहर करने की अनुमति थी।

rgoupil 8 दिस॰ 2018

तो enumerateErrorFormat के लिए प्रस्तावित समाधान काम करता है लेकिन logger.error('some message', err) प्रारूप का समर्थन नहीं करता है। क्योंकि न तो info.message या info instanceof Error । इसके अलावा मैं इस समाधान के साथ एक और मुद्दे की ओर इशारा करना चाहता हूं। मैं वर्तमान में एक त्रुटि लॉग कर रहा हूं जो superagent से लौटाई गई है

    try {
      const response = await request
        .get('https://some/endpoint')
        .set('Authorization', bearerToken);
      logger.info('successfully received response');
      return response.body;
    } catch (e) {
      logger.error('An error was caught while getting programs');
      logger.error(e); // <<< THE ERROR LOG  
    }

अगर हम केवल Object.assign का उपयोग करते हैं तो स्टैक को ठंडा करें और संदेश सेट हो जाएगा! लेकिन, कोई अन्य जानकारी जो त्रुटि का हिस्सा थी, वह भी लॉग हो जाएगी। यह उन मामलों में बहुत खतरनाक हो सकता है जहां त्रुटियों में संवेदनशील डेटा होता है जैसे Authorization Headers (जो इस मामले में त्रुटि वस्तु के हिस्से के रूप में शामिल हो जाता है)।

लेकिन तब आप कह सकते हैं। यह विंस्टन की गलती नहीं है, यह विंस्टन की गलती नहीं है कि सुपरएजेंट इस डेटा को त्रुटि में जोड़ता है। मैं सहमत हूं! हालाँकि, क्योंकि सब कुछ info ऑब्जेक्ट पर समान रूप से संग्रहीत है, पुरानी जानकारी को रखना और बाकी को ओवरराइड नहीं करना बहुत मुश्किल हो जाता है।

यह लगभग अच्छा होगा यदि, logger.error का उपयोग करते समय। यह मान लिया गया कि दूसरा परम था और त्रुटि थी और इसे info ऑब्जेक्ट पर info.error और फिर दूसरी तरफ लॉगिंग करते हुए, इंटरफ़ेस { level: "error", error: YOUR ERROR OBJECT}

मैं वास्तव में यहां सिर्फ स्पिटबॉल कर रहा हूं लेकिन नया इंटरफ़ेस निश्चित रूप से थोड़ा निराशाजनक रहा है (जानकारी पर सब कुछ)।

joepuzzo 12 दिस॰ 2018

बस उस बिंदु को विस्तृत करने के लिए जो मैं बना रहा था, मान लीजिए कि आप logger.error( e ) जहां ई प्रकार की त्रुटि है।

फिर आपके कोड में आपने विंस्टन को निम्नानुसार कॉन्फ़िगर किया है:

winston.configure({
    format: combine(
      timestamp(),
      enumerateErrorFormat(),
      ...
    ),
  });

टाइमस्टैम्प त्रुटि वस्तु object पर हिलाया जा रहा है। क्या यह वास्तव में समझ में आता है? इसके बारे में सोचें .. आपके द्वारा भेजी गई त्रुटि वस्तु को गतिशील रूप से एक नया प्रोप मिल रहा है .. टाइमस्टैम्प।

मुझे लगता है कि इस समस्या का सबसे अच्छा समाधान निम्नलिखित सिंटैक्स का समर्थन करना होगा:

logger.error('An error occurred when doing something important', { error: e } );

और फिर आंतरिक रूप से आप एक त्रुटि फ़ॉर्मेटर बना सकते हैं जो त्रुटि फ़ील्ड की तलाश करता है!

joepuzzo 12 दिस॰ 2018

इस पर अपडेट करें लोग:

विंस्टन के साथ logform में https://github.com/winstonjs/winston/compare/gh-1338
इससे पता चला कि मूल पीआर में एपीआई सही नहीं था, इसलिए मैंने हैकिंग शुरू कर दी है कि शुद्धता की ओर: https://github.com/winstonjs/logform/compare/winston-1338

उम्मीद है कि अगले दो दिनों में इसे सीवन कर भेज दिया जाएगा। यह हमारे [email protected] ट्रैकर में अगला से अंतिम अंक है

indexzero 5 जन॰ 2019

🎉6

हाउडी लोग - कृपया https://github.com/winstonjs/winston/pull/1562 देखें। यह हमारी 3.2.0 रिलीज चेक लिस्ट पर आखिरी आइटम था ताकि एक बार पीआर को सीवन करने के बाद हम रिलीज करने में सक्षम होंगे।

indexzero 7 जन॰ 2019

जब तक कोई समाधान प्रकाशित नहीं हो जाता, मैं निम्नलिखित समाधान का उपयोग करता हूं:

logger.error = item => {
  logger.log({ level: 'error', message: item instanceof Error ? item.stack : item });
};

ezze 14 जन॰ 2019

👍7 👀4

मैं नवीनतम विंस्टन (3.2.1) पर हूं और अभी भी undefined प्राप्त कर रहा हूं जब logger.error त्रुटि हो रही है

@ezze का एक अच्छा समाधान था लेकिन स्टैक ट्रेस को एक नई लाइन पर मजबूर होना पड़ा। यहाँ थोड़ा संशोधित संस्करण है जो इसे एक पंक्ति में रखता है (इसलिए इसे लॉग फ़ाइलों के साधारण grep द्वारा पकड़ा गया है)

logger.error = item => {
  const message = item instanceof Error
    ? item.stack.replace('\n', '').replace('    ', ' - trace: ')
    : item;
  logger.log({ level: 'error', message });
};

आउटपुट के साथ <Error message> - trace: <stack trace>

अगर नवीनतम विंस्टन के साथ ऐसा करने का कोई आसान तरीका है तो कृपया मुझे @indexzero बताएं। मैं पुस्तकालय में नया हूँ और डॉक्स का पालन कर रहा था

the-vampiire 20 मार्च 2019

👍1

मैंने अभी आपके द्वारा पीआर को पोस्ट किया गया लिंक देखा है। क्या इसका मतलब यह है कि किसी त्रुटि को logger.error लिए एक संदेश स्ट्रिंग की आवश्यकता है, फिर त्रुटि?

try {
  someThing();
} catch(error) {
  logger.error(error); // what I would like to do
  logger.error('special message', error); // what I believe is required?
}

the-vampiire 20 मार्च 2019

@ the-vampiire इस धागे के बारे में बात करने वाली 2 समस्याएं समाप्त हो गईं। पहला जो मूल पोस्टर लाया गया था, और दूसरा वह समस्या जो मैंने लाई थी जो आपकी समस्या के समान है। मुझे लगता है कि उन्होंने केवल मूल पोस्टर समस्या को ठीक किया। मेरा मतलब है कि यह सुनिश्चित करने के लिए आगे की जाँच करें और यदि ऐसा है तो एक नया मुद्दा खोलें। दुर्भाग्य से मेरे पास गहरा गोता लगाने का समय नहीं है। इस बीच, यदि आप logger.log({level: 'error', message: err}); जहां err एक त्रुटि वस्तु है तो यह काम करेगा।

SamuelMaddox 20 मार्च 2019

अभी भी यह समस्या है, यह पता लगाने के लिए समय का गुच्छा खो गया है, @ the-vampiire का समाधान अच्छी तरह से काम करता है।

यह टिकट क्यों बंद है?

HRK44 22 मार्च 2019

👍5

logger.error को ओवरराइड करना अब तक का सबसे अच्छा समाधान है क्योंकि यह एरर ऑब्जेक्ट में टाइमस्टैम्प प्रॉपर्टी नहीं जोड़ता है जिसे एरर () के लिए सिंगल तर्क के रूप में पास किया जाता है। ज्यादातर लोग उम्मीद करते हैं कि त्रुटि वस्तुएं अपरिवर्तनीय हैं। यदि आप logger.info और अन्य सभी स्तरों से संबंधित विधियों को भी ओवरराइड नहीं करते हैं, तो यह आश्चर्य की बात है कि चीजें अपेक्षा के अनुरूप काम नहीं करती हैं। दोबारा, जब तक आप अपनी वस्तु को संशोधित नहीं करना चाहते, चाहे उसका प्रकार कोई भी हो, इसे सीधे विंस्टन लॉगर विधि पर न भेजें।

terrisgit 23 मार्च 2019

यह सुविधा विंस्टन@3.2.0 . के बाद से समर्थित

उदाहरण उपयोग:

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

const print = format.printf((info) => {
  const log = `${info.level}: ${info.message}`;

  return info.stack
    ? `${log}\n${info.stack}`
    : log;
});

const logger = winston.createLogger({
  level: 'debug',
  format: format.combine(
    format.errors({ stack: true }),
    print,
  ),
  transports: [new transports.Console()],
});

const error = new Error('Ooops');

logger.error(error);
logger.error('An error occurred:', error);

cc @HRK44 @the-vampiire

artemjackson 13 अप्रैल 2019

👍20 🎉7 👎4

मैं अभी भी इस मुद्दे पर चल रहा हूं।
जब मैं logger.error(error); जैसी त्रुटि को कॉल करता हूं तो मुझे केवल undefined ।
केवल अगर मैं इसे logger.error('Something went wrong', error) तरह कॉल करता हूं तो मुझे पूरी त्रुटि मिलती है और इसे पार्स कर सकता है।

OBrown92 16 अप्रैल 2019

👍5

मैं अभी भी इस मुद्दे पर चल रहा हूं।
जब मैं logger.error(error); जैसी त्रुटि को कॉल करता हूं तो मुझे केवल undefined ।
केवल अगर मैं इसे logger.error('Something went wrong', error) तरह कॉल करता हूं तो मुझे पूरी त्रुटि मिलती है और इसे पार्स कर सकता है।
क्या आपने इसे जोड़ा?

format.errors({ stack: true })

victor-develop 26 अप्रैल 2019

हाँ, अभी भी वही मुद्दा। मैं इसे संक्षेप में पुन: पेश करने की कोशिश करता हूं।

OBrown92 26 अप्रैल 2019

@ OBrown92 मुझे आज भी इसी मुद्दे का सामना करना पड़ा है। मैं पुष्टि कर सकता हूं कि यह काम करता है, अगर format.errors({ stack: true }) , लॉगर पर लागू होता है, परिवहन के लिए नहीं। इस मामले में logger.error(error); और logger.error('Something went wrong', error) दोनों का उपयोग करना संभव है। हालांकि, एक समस्या है, जब मैं चुने हुए परिवहन के लिए format.errors({ stack: true }) लागू करने का प्रयास करता हूं। इस मामले में मुझे undefined लिए logger.error(error); , लेकिन logger.error('Something went wrong', error) ठीक से काम करता है।

मुझे यकीन नहीं है कि यह अपेक्षित व्यवहार है या यह एक बग है, लेकिन मैंने इसका कारण खोजने में बहुत समय बिताया है, इसलिए कृपया इसे ठीक करें या अपने दस्तावेज़ में कहीं इसका उल्लेख करें। यह वास्तव में मददगार होगा।

वैसे भी, मैं इस महान परियोजना पर आपके काम के लिए बहुत आभारी हूं।

marcin1990ns 10 मई 2019

👍13

मैं उसी मुद्दे का सामना कर रहा था इसलिए मैंने यह पैकेज लिखा, utils-deep-clone । इसकी जांच - पड़ताल करें।

Atishay96 14 मई 2019

format.errors is not a function ... ठीक है, यह आश्चर्य की बात है।

holmberd 24 मई 2019

👍1

@ होल्म्बरड
क्या आपने विंस्टन पैकेज से प्रारूप आयात किए हैं?
उदाहरण उपयोग:
const { format } = require('winston')
या
const winston = require('winston'); const { format } = winston;

aybhalala 24 मई 2019

@aybhalala yepp, हालांकि इससे कोई फर्क नहीं पड़ता कि त्रुटि स्टैक को इसके बिना printf कर दिया गया है।

holmberd 25 मई 2019

अद्यतन: क्योंकि इसके साथ अभी भी समस्याएं हैं, मैं थोड़ी देर के लिए निम्नलिखित कर रहा हूं और यह बहुत अच्छा काम कर रहा है

// Grab the default winston logger
const winston = require('winston');

const { format } = winston;
const { combine, timestamp } = format;

// Custom format function that will look for an error object and log out the stack and if 
// its not production, the error itself
const myFormat = format.printf((info) => {
  const { timestamp: tmsmp, level, message, error, ...rest } = info;
  let log = `${tmsmp} - ${level}:\t${message}`;
  // Only if there is an error
  if ( error ) {
    if ( error.stack) log = `${log}\n${error.stack}`;
    if (process.env.NODE_ENV !== 'production') log = `${log}\n${JSON.stringify(error, null, 2)}`;
  }
  // Check if rest is object
  if ( !( Object.keys(rest).length === 0 && rest.constructor === Object ) ) {
    log = `${log}\n${JSON.stringify(rest, null, 2)}`;
  }
  return log;
});

 winston.configure({
    transports: [
      new winston.transports.Console({
        level: 'debug',
        timestamp: true,
        handleExceptions: true
    }),
  ];
    format: combine(
      trace(),
      timestamp(),
      myFormat
    ),
  });


// Finally you log like this
logger.error('An error occurred!!!', { error } );

joepuzzo 27 जून 2019

👍8 ❤5 🚀3

^^ वह अपेक्षित उपयोग है। चूंकि केवल नश्वर लोग इसका पता नहीं लगा पाएंगे, इसलिए इसे प्रलेखित किया जाना चाहिए।

terrisgit 27 जून 2019

😄4

चूंकि केवल नश्वर लोग इसका पता नहीं लगा पाएंगे, इसलिए इसे प्रलेखित किया जाना चाहिए

😂 उस साथी को +1

the-vampiire 29 जून 2019

मैं तीसरे पक्ष के परिवहन ( @google-cloud/logging-winston ) के साथ विंस्टन का उपयोग करता हूं, इसलिए मेरे पास वाक्यविन्यास पर थोड़ा कम नियंत्रण है। इसके अलावा मुझे यह और अधिक सहज ज्ञान युक्त लगता है:

const error = new Error('something bad happened');
logger.error('was doing this and', error);

कंसोल पर लॉग इन करते समय मैं संदेश पर स्टैक को जोड़ता हूं। लेकिन परिणाम कुछ इस तरह है:

ERROR was doing this andsomething bad happened Error: something bad happened <rest of the stack.>

चूंकि विंस्टन मूल संदेश पर meta.message को जोड़ता है, अजीब andsomething और डुप्लिकेट संदेश है जो स्टैक में भी मुद्रित होता है। यह #1660 में वर्णित है।

ऐसा लगता है कि #1664 इसे ठीक करने की कोशिश कर रहा है। इस बीच, मैंने एक फॉर्मेटर लिखा जो उस संयोजन को "पूर्ववत" करता है: https://github.com/winstonjs/winston/issues/1660#issuecomment -512226578

codyzu 17 जुल॰ 2019

👍5 🎉1

@dandv
logger.error('Caught error:', e);
यह काम नहीं करता क्योंकि, console.log() विपरीत, विंस्टन का logger.<level>(message) केवल एक पैरामीटर लेता है जिसे संदेश कहा जाता है। वह संदेश पैरामीटर या तो एक वस्तु या एक स्ट्रिंग है (अगर मैं गलत हूं तो कोई मुझे सही करेगा लेकिन यह मेरी समझ है)।
ध्यान दें कि आप logger.log({level: <level>, message: <message>}) भी उपयोग कर सकते हैं। इन दो कार्यों के बारे में अधिक जानने के लिए मैं डॉक्स के इस भाग को पढ़ने की सिफारिश करूंगा: विंस्टन डॉक्स ऑन लॉग लेवल । लॉगिंग स्तर का उपयोग करके पढ़ना सुनिश्चित करें
logger.error(`Caught error: ${e}`);
मैं निश्चित रूप से यह नहीं कह सकता कि यह स्टैक को आउटपुट क्यों नहीं करता है, लेकिन मुझे पता है कि यह विंस्टन के साथ कोई समस्या नहीं है। यदि आप console.log(`Caught error: ${e}`) करते हैं तो इसमें स्टैक भी शामिल नहीं होता है। मैंने टेम्प्लेट लिटरल्स के साथ बहुत अधिक काम नहीं किया है, इसलिए या तो टेम्प्लेट लिटरल्स ऑब्जेक्ट्स के साथ अच्छी तरह से काम नहीं करते हैं, या जावास्क्रिप्ट का कंसोल.लॉग ऑब्जेक्ट को एक एरर ऑब्जेक्ट के रूप में पहचानता है और इस प्रकार केवल मैसेज प्रॉपर्टी को आउटपुट करता है। यह मेरा सबसे अच्छा अनुमान है।
logger.error(`Caught error: ${JSON.stringify(e)}`)
यह बग थ्रेड किस बारे में है, इसके दिल में उतर जाता है। सबसे पहले आपको जावास्क्रिप्ट के बारे में कुछ तकनीकी विवरणों को समझना होगा। ध्यान दें कि यदि आप console.log(`Caught error: ${JSON.stringify(e)}`) प्रयास करते हैं तो आपको वही आउटपुट Caught error: {} भी मिलता है। जैसा कि @indexzero ने समझाया:
message और stack पर Error stack गुण गैर-गणना योग्य हैं जो JSON.stringify को कुछ ऐसा आउटपुट करने का कारण बनता है जिसकी कोई उम्मीद नहीं करता है।
मूल रूप से, क्योंकि message और stack गुण गैर-गणना योग्य हैं, JSON.stringify उन गुणों पर छोड़ देता है जो इस तरह से आप एक खाली वस्तु के साथ समाप्त होते हैं {} । एन्यूमरेबिलिटी को बेहतर ढंग से समझने के लिए मैं इस एन्यूमरेबिलिटी और प्रॉपर्टी के स्वामित्व को पढ़ने की सलाह देता हूं।
सौभाग्य से, जिस तरह से विंस्टन 3.0 को डिजाइन किया गया था (विंस्टन टीम के लिए सहारा) हमारे पास इसके लिए एक वर्कअराउंड है जो @indexzero ने दिया था। मैं इसे समझाने में मदद करूंगा। सबसे पहले आप यह फ़ंक्शन बनाएं:
const enumerateErrorFormat = format(info => {
  if (info.message instanceof Error) {
    info.message = Object.assign({
      message: info.message.message,
      stack: info.message.stack
    }, info.message);
  }

  if (info instanceof Error) {
    return Object.assign({
      message: info.message,
      stack: info.stack
    }, info);
  }

  return info;
});
डॉक्स स्ट्रीम, ऑब्जेक्टमोड, और जानकारी ऑब्जेक्ट से जानकारी ऑब्जेक्ट में दो गुण हैं, info.level , और info.message । यही कारण है कि info.message संपत्ति त्रुटि उद्देश्य यह है कि अगर आप सभी में पारित कर दिया है। तो हम एक नई वस्तु बनाने जहां message.stack और message.message (के रूप में समझें Error.stack और Error.message ) अब गणना योग्य हैं, और हम उन अन्य गुणों को शामिल करते हैं जो उस त्रुटि ऑब्जेक्ट से भी संलग्न हो सकते हैं।
आगे आप इस लकड़हारे को बनाएंगे जो ऊपर दिए गए enumerateErrorFormat() फ़ंक्शन का उपयोग करता है:
const logger = createLogger({
  format: format.combine(
    enumerateErrorFormat(),
    format.json()
  ),
  transports: [
    new transports.Console()
  ]
});
इसमें जो कुछ भी message आप पास करेंगे और जांच लेंगे कि यह एक त्रुटि वस्तु है या नहीं। अगर ऐसा है तो यह गणना की समस्या को ठीक कर देगा। फिर यह format.json संदेश भेजता है जो किसी भी वस्तु (त्रुटि या नहीं) को स्ट्रिंग करेगा। यदि यह कोई वस्तु नहीं है तो यह एक स्ट्रिंग है और format.json effectivley कुछ भी नहीं करता है, और आप घर मुक्त हैं!
फिर भी, यह अच्छा होगा यदि हमें वह enumerateErrorFormat नहीं बनाना पड़े क्योंकि त्रुटि ऑब्जेक्ट आमतौर पर लॉग होते हैं। जैसा कि मैं समझता हूं कि विंस्टन टीम एक फिक्स पर काम कर रही है जिसे बाद के संस्करण में जारी किया जाएगा।
कुछ अंतिम नोट। यह केवल तभी काम करता है जब आप logger.log({level: <level>, message: <message>}) जहां संदेश त्रुटि वस्तु है। उदाहरण:
try {
  throw(new Error('This should work'));
} catch (err) {
  logger.log({level: 'error', message: err});
}
विंस्टन में एक और बग है जहां यह कोड काम नहीं करता है, जैसा कि मैंने उपरोक्त मेरी अन्य पोस्ट में बताया है:
try {
  throw(new Error('This will not work'));
} catch (err) {
  logger.error(err);
}
जब हम logger.error(err) उपयोग करते हैं तो किसी कारण से info.message संपत्ति अपरिभाषित होती है। उम्मीद है कि @indexzero इसका पता

बहुत अच्छी व्याख्या, मैं बस इसे logger.error( साथ जोड़ना चाहता हूं त्रुटि: ${e} ); जिस तरह से जावास्क्रिप्ट में स्ट्रिंग शाब्दिक काम करता है, `${e}` आप स्टैक खो देते हैं e.toString() जैसा ही है, इसलिए केवल त्रुटि संदेश प्रिंट करना अपेक्षित व्यवहार है।

akaahmedkamal 28 जुल॰ 2019

यह अभी भी एक मुद्दा है? मुझे अभी भी इससे समस्या हो रही है:

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

const { combine } = format

const errorFormatter = format((info) => {
  console.log(info)
  return info
})


const consoleTransport = new transports.Console({
  format: combine(errorFormatter()),
})

const logger = createLogger({
  transports: [
    consoleTransport,
  ],
})

try {
  throw new Error('Error message')
} catch(err) {
  logger.error(err) // info doesnt have the error object
  logger.error('', err) // info have the error object
}

tiagonapoli 13 सित॰ 2019

👍1

यह अभी भी एक मुद्दा है? मुझे अभी भी इससे समस्या हो रही है:

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

const { combine } = format

const errorFormatter = format((info) => {
  console.log(info)
  return info
})


const consoleTransport = new transports.Console({
  format: combine(errorFormatter()),
})

const logger = createLogger({
  transports: [
    consoleTransport,
  ],
})

try {
  throw new Error('Error message')
} catch(err) {
  logger.error(err) // info doesnt have the error object
  logger.error('', err) // info have the error object
}

वही समस्या है...

स्रोत कोड देखने के बाद, मैं देख सकता हूं कि यह कौन से पैरा स्वीकार करता है:

इंटरफ़ेस LeveledLogMethod {
(संदेश: स्ट्रिंग, कॉलबैक: लॉगकॉलबैक): लकड़हारा;
(संदेश: स्ट्रिंग, मेटा: कोई भी, कॉलबैक: लॉगकॉलबैक): लॉगर;
(संदेश: स्ट्रिंग, ...मेटा: कोई भी []): लकड़हारा;
(infoObject: वस्तु): लकड़हारा;
}

इसलिए यदि आप त्रुटि ऑब्जेक्ट को पहले परम के रूप में पास करते हैं, तो यह केवल त्रुटि का संदेश लेगा क्योंकि यह केवल स्ट्रिंग्स को समझता है, और यदि आप दूसरे पैरा में त्रुटि पास करते हैं तो आप info.stack में स्टैक ट्रेस तक पहुंच सकते हैं

बीटीडब्ल्यू मैं इसे दस्तावेज़ों में कहीं भी नहीं ढूंढ सका

Speedkore 17 सित॰ 2019

👍3

मुझे दो समाधान मिले, पहला है format.errors , जिसका उल्लेख पैरेंट लॉगर में लॉगफॉर्म पर किया गया है, फिर format.printf का उपयोग करके एक संदेशफॉर्मेटर बनाएं और सशर्त रूप से stack से निकाला गया फ़ील्ड जोड़ें info ( format.errors({ stack: true}) वह जोड़ देगा)।

दूसरा समाधान, जिसे मैंने पसंद किया था, विंस्टन स्तर के लॉगर्स में हैक किया गया था:

const addArgs = format((info) => {
  const args: any[] = info[Symbol.for('splat')]
  info.args = args ? [...args] : []
  return info
})

const messageFormatter = format.printf(info => {
  const { timestamp: timeString = '', message, args = [] } = info
  const formattedMsgWithArgs = util.formatWithOptions({ colors: true }, message, ...args)
  const msg = `${timeString} - ${info.level}: ${formattedMsgWithArgs}`
  return msg
})

const logger = createLogger({
  format: format.combine(
    addArgs(),
    format.timestamp({ format: 'HH:mm:ss.SSS' })
  ),

  transports: [
    new transports.Console({
      format: format.combine(format.colorize(), messageFormatter),
    }),
  ],
})

const levels = ['debug', 'info', 'error']
levels.forEach((level) => {
  logger[level] = (msg: any, ...remains: any) => {
    if(typeof msg != "string") {
      return logger.log(level, '', msg, ...remains)
    }

    logger.log(level, msg, ...remains)
  }  
})

ऐसा लगता है कि मुझे console.log समान त्रुटि लॉगिंग मिल सकती है

tiagonapoli 17 सित॰ 2019

👍4 🎉2

मैं सत्यापित कर सकता हूं कि _parent_ लकड़हारे पर format.errors कैसे होना चाहिए, इस बारे में @tiagonapoli की टिप्पणी सटीक है। जब मैं ऐसा कुछ करता हूं:

winston.loggers.add("default");
const log = winston.loggers.get("default");
/* get a `transportOptions` object and a `transportType` */
transportOptions.format = logform.format.combine(
  logform.format.errors({ stack: true }),
  logform.format.timestamp(),
  logform.format.printf(myFormatter)
);
log.add(new winston.transports[transportType](transportOptions);

Error ऑब्जेक्ट को संभालना ऐसा है जैसे वे एक स्ट्रिंग थे। हालांकि, अगर मैं ऐसा कुछ करता हूं:

winston.loggers.add("default");
const log = winston.loggers.get("default");
log.format = logform.format.errors({ stack: true });
/* get a `transportOptions` object and a `transportType` */
transportOptions.format = logform.format.combine(
  logform.format.timestamp(),
  logform.format.printf(myFormatter)
);
log.add(new winston.transports[transportType](transportOptions);

Error वस्तु की हैंडलिंग सही ढंग से काम करती है।

मुझे ऐसा लगता है कि यहाँ दोष यह है कि व्यवहार में कोई अंतर नहीं होना चाहिए।

cjbarth 2 अक्तू॰ 2019

🎉2

तो यह अभी भी 1 साल के बाद भी तय नहीं है? क्या मुझे इसे काम करने के लिए विंस्टन लकड़हारा कोड हैक करना होगा?

HRK44 24 अक्तू॰ 2019

👍8

हाँ, इसने मुझे पर्याप्त सिरदर्द दिया कि विंस्टन मेरे अपेक्षाकृत सरल उपयोग के मामले की तुलना में अधिक परेशानी की तरह लगने लगा ... मैंने अपना खुद का छोटा लॉगर क्लास लिखना समाप्त कर दिया, और मैं अनुशंसा करता हूं कि अन्य लोग भी ऐसा ही करें जब तक कि विंस्टन कुछ ऐसा प्रदान करता है जिसकी आपको वास्तव में आवश्यकता है।

lydianlights 29 अक्तू॰ 2019

👍10

दोस्तों, सच में? यह निराश करने वाला है...

TrejGun 30 नव॰ 2019

😕5

मैं एक कमिटर नहीं हूं, लेकिन मैं शायद यह कहना सही हूं कि यह "निश्चित" नहीं होने वाला है क्योंकि यह टूटा नहीं है। विंस्टन उपयोग करने लायक है। आपको बस इसे कॉन्फ़िगर करने की आवश्यकता है - मेरे लिए सबसे अच्छी सलाह ऊपर है https://github.com/winstonjs/winston/issues/1338#issuecomment -506354691

terrisgit 30 नव॰ 2019

👎9 👍1

अभी नहीं ?

kasvith 10 दिस॰ 2019

अद्यतन: क्योंकि इसके साथ अभी भी समस्याएं हैं, मैं थोड़ी देर के लिए निम्नलिखित कर रहा हूं और यह बहुत अच्छा काम कर रहा है

// Grab the default winston logger
const winston = require('winston');

const { format } = winston;
const { combine, timestamp } = format;

// Custom format function that will look for an error object and log out the stack and if 
// its not production, the error itself
const myFormat = format.printf((info) => {
  const { timestamp: tmsmp, level, message, error, ...rest } = info;
  let log = `${tmsmp} - ${level}:\t${message}`;
  // Only if there is an error
  if ( error ) {
    if ( error.stack) log = `${log}\n${error.stack}`;
    if (process.env.NODE_ENV !== 'production') log = `${log}\n${JSON.stringify(error, null, 2)}`;
  }
  // Check if rest is object
  if ( !( Object.keys(rest).length === 0 && rest.constructor === Object ) ) {
    log = `${log}\n${JSON.stringify(rest, null, 2)}`;
  }
  return log;
});

 winston.configure({
    transports: [
      new winston.transports.Console({
        level: 'debug',
        timestamp: true,
        handleExceptions: true
    }),
  ];
    format: combine(
      trace(),
      timestamp(),
      myFormat
    ),
  });


// Finally you log like this
logger.error('An error occurred!!!', { error } );

निशान कहाँ से आता है?

pkyeck 9 जन॰ 2020

👍1

नहीं वास्तव में, यह लॉगिंग लाइब्रेरी के लिए अस्वीकार्य है।
मेंटेनर को केवल डॉक्स पर एक अच्छी तरह से हाइलाइट किया गया उदाहरण रखना चाहिए जहां यह दिखाया गया है कि कैसे एक त्रुटि लॉग करना है, यहां तक कि कस्टम प्रिंटफ प्रारूप और गैर जेसन प्रारूप को परिभाषित करना और जहां आप लॉगर जैसे कुछ के साथ त्रुटि लॉग कर सकते हैं। त्रुटि (त्रुटि)
विंस्टन बहुत अच्छा लग रहा था लेकिन यह मुद्दा अविश्वसनीय रूप से अस्वीकार्य है

andretti1977 30 अप्रैल 2020

👍49

विंस्टन का उपयोग करके त्रुटियों को कैसे लॉग किया जाए, इस पर मेरा विचार है। यह अद्वितीय नहीं है, ऊपर की बहुत सारी झांकियों में समान अवधारणाओं के आधार पर काम करने वाले समाधान भी हैं।

पृष्ठभूमि
मैं मनमाने ढंग से ऑब्जेक्ट प्रकारों को कस्टम त्रुटियों में लपेटने के लिए @jsdevtools/ono का उपयोग कर रहा हूं, लेकिन परवाह किए बिना, यह समाधान अभी भी देशी नोड त्रुटियों (जैसे fs eperm त्रुटियों), और कस्टम त्रुटि वर्गों पर ठीक काम करता प्रतीत होता है।

व्याख्या
मूल रूप से, मैं format.errors({stack:true}) और format.metadata() पर निर्भर हूं। जैसा कि https://github.com/winstonjs/winston/issues/1338#issuecomment -532327143 द्वारा उल्लेख किया गया है, यह मूल फॉर्मेटर में होना चाहिए।

मेटाडेटा सभी त्रुटि ऑब्जेक्ट के कस्टम गुणों को info.metadata स्थानांतरित करने में मदद करता है।

मैं 3 प्रकार की जानकारी प्रिंट करना चाहता था: त्रुटि संदेश, स्टैकट्रेस, और त्रुटि ऑब्जेक्ट के गुण। त्रुटि संदेश पहले से ही सादा पाठ था। मैंने pretty-error मॉड्यूल का उपयोग करके स्टैक info.metadata.stack सुंदर-मुद्रित किया। त्रुटि ऑब्जेक्ट के गुणों के लिए, मैं नहीं चाहता था कि स्टैकट्रेस फिर से दिखाई दे, इसलिए मैंने ऑब्जेक्ट को क्लोन किया, और स्टैकट्रेस प्रॉपर्टी को हटा दिया। फिर मैंने fast-safe-stringify का उपयोग करके त्रुटि ऑब्जेक्ट को सुंदर-मुद्रित किया, जो वही स्ट्रिंग मॉड्यूल है जो विंस्टन पर निर्भर करता है।

    const lodash = require("lodash");
    const path = require("path");
    const winston = require("winston");
    const { default: stringify } = require("fast-safe-stringify");
    const logDir = "D:/temp/logs";

    // pretty formatting
    const PrettyError = require("pretty-error");
    const pe = new PrettyError();
    pe.withoutColors()
        .appendStyle({
            'pretty-error > trace':
            {
                display: 'inline'
            },
            'pretty-error > trace > item':
            {
                marginBottom: 0,
                bullet: '"*"'
            }
        })
        // @ts-ignore
        .alias(/.*[\\\/]CelebrityQuery/i, "<project>")
        .alias(/\[CelebrityQuery\][\\\/]?/i, "")
        .skip(/** <strong i="23">@type</strong> {(_:any) => boolean} */ (traceline => {
            if (traceline && traceline.dir) {
                return traceline.dir.toString().startsWith("internal");
            }
            return false;
        }))
        .skipNodeFiles();

    const consoleFormat = winston.format.combine(
        winston.format.colorize(),
        winston.format.timestamp({
            format: 'DD MMM HH:mm:ss'
        }),
        winston.format.printf(info => {
            if (!lodash.isEmpty(info.metadata) && info.metadata.hasOwnProperty("stack")) {
                let dup = lodash.clone(info.metadata);
                delete dup.stack;
                const errBody = stringify(dup, undefined, 4);
                const stack = pe.render({ stack: info.metadata.stack });
                return `${info.timestamp} ${info.level} ${info.message}${errBody}\n${stack}`;
            } else if (lodash.isString(info.message)) {
                return `${info.timestamp} ${info.level} ${info.message}`;
            } else {
                return `${info.timestamp} ${info.level} ${stringify(info.message, undefined, 4)}`;
            }
        })
    );
    const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.json());
    return winston.createLogger({
        level: 'debug',
        format: winston.format.combine(
            winston.format.errors({ stack: true }),
            winston.format.metadata()
        ),
        transports: [
            new winston.transports.Console({
                format: consoleFormat,
                level: 'info',
            }),
            new winston.transports.File({
                filename: path.join(logDir, "stdout.json"),
                format: logFormat,
                level: 'debug',
                maxsize: 1000000,
                tailable: true
            })
        ]
    });

Log Screenshot

पुनश्च: मुझे एक अच्छा विकल्प होने के लिए https://github.com/winstonjs/winston/issues/1338#issuecomment -506354691 में उल्लिखित समाधान भी मिलता है। यानी logger.warn("Oh no", { error: new Error() }) का उपयोग करके, फिर अपने कस्टम फॉर्मेटर में info.error का संदर्भ देना।

cardin 18 मई 2020

👀1 🎉1 👍1

@tiagonapoli माता-पिता format.errors का उपयोग करने के बारे में आपके समाधान ने मेरे लिए काम किया:

const logger = createLogger({
  transports: loggerTransports,
});

logger.format = format.errors({ stack: true });

इस लकड़हारे को कॉन्फ़िगर करना काफी दर्दनाक है... क्या यह केवल console.log आउट द बॉक्स जैसा व्यवहार नहीं कर सकता था?

will093 27 मई 2020

👍2

@ will093 वही यहाँ। उस मुद्दे पर फिर से गया और यह नहीं मिला कि मेरा console.log अच्छा और साफ क्यों है और विंस्टन प्रारूप बकवास है।

OBrown92 27 मई 2020

👍11

मेरा 2¢

// Enable console logging when not in production
if (process.env.NODE_ENV !== "production") {
    logger.add(new transports.Console({
        format: format.combine(
            format.colorize(),
            format.simple(),
            format.printf(info => {
                const { level, ...rest } = info;
                let rtn = "";
                // rtn += info.timestamp;
                rtn += "[" + info.level + "] ";
                if (rest.stack) {
                    rtn += rest.message.replace(rest.stack.split("\n")[0].substr(7),"");
                    rtn += "\n";
                    rtn += "[" + level + "] ";
                    rtn += rest.stack.replace(/\n/g, `\n[${level}]\t`);
                } else {
                    rtn += rest.message;
                }
                return rtn;
            }),
        ),
    }));
}

logger.error("Error during schema stitching", e); लिए उदाहरण

TeamDman 12 जून 2020

👍1

@tiagonapoli और @ will093 का उपयोग करके इसे केवल माता-पिता में जोड़ने का समाधान सीधे लॉगिंग त्रुटियों और अभी भी लॉगिंग संदेशों का समर्थन करने का सबसे आसान तरीका प्रतीत होता है - यहां न्यूनतम सेटअप w/टाइमस्टैम्प का एक पूर्ण उदाहरण है:

const createLogger = () => {
  const logFormatter = winston.format.printf(info => {
    let { timestamp, level, code, stack, message } = info;

    // print out http error code w/ a space if we have one
    code = code ? ` ${code}` : '';
    // print the stack if we have it, message otherwise.
    message = stack || message;

    return `${timestamp} ${level}${code}: ${message}`;
  });

  return winston.createLogger({
    level: 'info',
    // put the errors formatter in the parent for some reason, only needed there:
    format: winston.format.errors({ stack: true }),
    transports: new winston.transports.Console({
      format: winston.format.combine(
        winston.format.timestamp(),
        logFormatter
      ),
  });
};

एक त्रुटि के साथ कॉल किए जाने पर स्टैक के साथ काम करता है जैसे: logger.error(error) , एक स्ट्रिंग के साथ काम करता है जब इसे logger.error('a regular message') कहा जाता है, मेरे लॉग में ऐसा दिखता है:

2020-09-23T20:05:30.30Z info: Feathers application started on http://localhost:3030
2020-09-23T20:05:35.40Z info: job queue - redis ready, registering queues...
2020-09-23T20:05:40.25Z error 401: NotAuthenticated: invalid authorization header
    at new NotAuthenticated (/path/to/server/node_modules/@feathersjs/errors/lib/index.js:94:17)
    at Object.<anonymous> (/path/to/server/src/hooks/authentication.js:123:456)
    at /path/to/server/node_modules/@feathersjs/commons/lib/hooks.js:116:46

यह विंस्टन के logger.error('message here', error) -incompatibility w/ console.log को हल करने का प्रयास नहीं करता है , जो @tiagonapoli का अधिक सम्मिलित समाधान करता प्रतीत होता है।

साथ ही, अगर आपको जेसन लॉग पसंद हैं तो आप यहां logFormatter छोड़ सकते हैं और इसके स्थान पर winston.format.json() का उपयोग कर सकते हैं, जिसमें अभी भी स्टैक शामिल होगा - लेकिन यह सुंदर नहीं है।

wcarss 23 सित॰ 2020

👍2

अद्यतन: क्योंकि इसके साथ अभी भी समस्याएं हैं, मैं थोड़ी देर के लिए निम्नलिखित कर रहा हूं और यह बहुत अच्छा काम कर रहा है

// Grab the default winston logger
const winston = require('winston');

const { format } = winston;
const { combine, timestamp } = format;

// Custom format function that will look for an error object and log out the stack and if 
// its not production, the error itself
const myFormat = format.printf((info) => {
  const { timestamp: tmsmp, level, message, error, ...rest } = info;
  let log = `${tmsmp} - ${level}:\t${message}`;
  // Only if there is an error
  if ( error ) {
    if ( error.stack) log = `${log}\n${error.stack}`;
    if (process.env.NODE_ENV !== 'production') log = `${log}\n${JSON.stringify(error, null, 2)}`;
  }
  // Check if rest is object
  if ( !( Object.keys(rest).length === 0 && rest.constructor === Object ) ) {
    log = `${log}\n${JSON.stringify(rest, null, 2)}`;
  }
  return log;
});

 winston.configure({
    transports: [
      new winston.transports.Console({
        level: 'debug',
        timestamp: true,
        handleExceptions: true
    }),
  ];
    format: combine(
      trace(),
      timestamp(),
      myFormat
    ),
  });


// Finally you log like this
logger.error('An error occurred!!!', { error } );

ट्रेस () परिभाषा कहां है?

rathernetwork 5 जन॰ 2021

अद्यतन: क्योंकि इसके साथ अभी भी समस्याएं हैं, मैं थोड़ी देर के लिए निम्नलिखित कर रहा हूं और यह बहुत अच्छा काम कर रहा है

// Grab the default winston logger
const winston = require('winston');

const { format } = winston;
const { combine, timestamp } = format;

// Custom format function that will look for an error object and log out the stack and if 
// its not production, the error itself
const myFormat = format.printf((info) => {
  const { timestamp: tmsmp, level, message, error, ...rest } = info;
  let log = `${tmsmp} - ${level}:\t${message}`;
  // Only if there is an error
  if ( error ) {
    if ( error.stack) log = `${log}\n${error.stack}`;
    if (process.env.NODE_ENV !== 'production') log = `${log}\n${JSON.stringify(error, null, 2)}`;
  }
  // Check if rest is object
  if ( !( Object.keys(rest).length === 0 && rest.constructor === Object ) ) {
    log = `${log}\n${JSON.stringify(rest, null, 2)}`;
  }
  return log;
});

 winston.configure({
    transports: [
      new winston.transports.Console({
        level: 'debug',
        timestamp: true,
        handleExceptions: true
    }),
  ];
    format: combine(
      trace(),
      timestamp(),
      myFormat
    ),
  });


// Finally you log like this
logger.error('An error occurred!!!', { error } );

निशान कहाँ से आता है?

इस पर कोई जवाब?

rathernetwork 5 जन॰ 2021

Winston: [३.०.०] त्रुटि वस्तु पार्स या मुद्रित नहीं है

कृपया हमें अपने पर्यावरण के बारे में बताएं:

समस्या क्या है?

इसके बजाय आप क्या होने की उम्मीद करते हैं?

अन्य सूचना

सबसे उपयोगी टिप्पणी

सभी 68 टिप्पणियाँ

संबंधित मुद्दों