Winston: [3.0.0]エラーオブジェクトが解析または出力されない

これについてはテストカバレッジがありますが、明らかにもっと必要です。 裏で何が起こっているのか：

1. ErrorインスタンスはobjectModeストリームパイプチェーンに沿って渡されます
2. Loggerのデフォルトの形式はjson （ logform json形式コードをlogform ）
3. messageとstackのプロパティError原因である非可算JSON.stringify 1には期待していないことを出力に何か。

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

設計の観点から、 winston@3は、パフォーマンスを向上させるために、まさにこの種の問題に対してformatsを導入しました。 パフォーマンスについて言えば、興味深いことに、 pinoはここで何か面白いことをします。 おそらく、解決策は、デフォルトのjson形式でasJsonに似たものを実装することです。

誰かが簡単な回避策を探しているなら、今のところロガーのフォーマットにenumerateErrorFormatを含めることができます。 来週の3.0.0前（または3.0.1直後）にこれを修正できることを願っています。

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 、私はあなたの回避策に従おうとしましたが、それは機能していません。 なぜなのかご存知ですか？

フォーマッター：
`` ` javascript const level = settings.debug ? 'debug' : 'info'; const printFormat = winston.format.printf(info => $ {info.timestamp}-$ {info.level}：$ {info.message}`）;
const enumerateErrorFormat = winston.format（info => {
if（info.message instanceof Error）{
info.message = Object.assign（{
メッセージ：info.message.message、
スタック：info.message.stack、
}、info.message）;
}
if（info instanceof Error）{
Object.assign（{を返す
メッセージ：info.message、
スタック：info.stack、
}、情報）;
}
情報を返す;
}）;

const consoleLogger = winston.createLogger（{
レベル、
フォーマット：winston.format.timestamp（）、
トランスポート：[
new winston.transports.Console（{
フォーマット：winston.format.combine（
winston.format.colorize（）、
enumerateErrorFormat（）、
printFormat、
）、
}）、
]、
}）;
Code: javascript
{を試してください
//コードスローエラー
} catch（err）{
logger.error（err）;
}
Output:
2018-06-28T21：17：25.140Z-エラー：未定義
Info object: javascript
{レベル： '\ u001b [31merror \ u001b [39m'、タイムスタンプ： '2018-06-28T21：17：25.140Z'、[記号（レベル）]： 'エラー'}
「」
エラーログのメッセージ属性はどこにありますか？

@sandrocsimasロガーを機能させるには、ロガーのデフォルトのフォーマッターにenumerateErrorFormat関数を指定する必要があることに気づきました。

フォーマッター

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

なぜなのかまだわからない

@sandrocsimasと同じバグが発生していると思います。

これが私のロガー設定です：

logger.js

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

このコードブロックでテストすると、次のようになります。

テストA

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

new Error()メッセージ値が含まれていない場合、次の出力が得られます。

出力A

** 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]はまさに私が期待したものです

ただし、このコードブロックでテストすると、次のようになります。

テストB

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

new Error()メッセージ値が含まれている場合、次の出力が得られます。

出力B

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

ご覧のとおり、 @ sandrocsimasと同じerror: undefinedを取得します。 error: [object Object]を手に入れると思っていました

このコードブロックを試してみると、次のことに注意してください。

テストC

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

logger.log代わりにlogger.errorを使用すると、上記の出力Aと同じ出力が得られます。

私は同じ問題を抱えています。 私はウィンストンが初めてです。 @indexzeroソリューションを試し

@ nvtuan305 、 ましたか、それとも少し編集しましたか？ もしそうなら、サンプルコードを提供できますか？ 彼のコードは、 logger.log({level: ____, message: err});を使用している場合は機能するはずです。 logger.info 、 logger.error 、またはその他のlogger.<level>ている場合は機能しません。 。 これは上記で指定したバグであり、今後のリリースで修正されるはずです。

私は何かが足りないのでしょうか、それともconsole.log / error / warnから簡単に得られるのと同じ出力を得るのは完全な頭痛の種（または不可能でさえありますか？）ですか？

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

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

console.log()とは異なり、ウィンストンのlogger.<level>(message)はメッセージと呼ばれるパラメータを1つだけ取るため、これは機能しません。 そのメッセージパラメータはオブジェクトまたは文字列のいずれかです（私が間違っている場合は誰かが私を修正しますが、それは私の理解です）。

logger.log({level: <level>, message: <message>})も使用できることに注意してください。 これらの2つの関数の詳細については、ドキュメントのこの部分を読むことをお勧めします：ログレベルのWinstonDocs 。 ロギングレベルの使用を必ずお読みください

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

なぜこれがスタックを出力しないのかを明確に言うことはできませんが、これがウィンストンの問題ではないことは知っています。 console.log(`Caught error: ${e}`)を試してみると、スタックも含まれていません。 私はテンプレートリテラルをあまり使用していないので、テンプレートリテラルがオブジェクトでうまく機能しないか、javascriptのconsole.logがオブジェクトをエラーオブジェクトとして認識し、メッセージプロパティのみを出力します。 それが私の一番の推測です。

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

これは、このバグスレッドの核心になります。 まず、JavaScriptに関する技術的な詳細を理解する必要があります。 console.log(`Caught error: ${JSON.stringify(e)}`)を試してみると、同じ出力Caught error: {}も得られることに注意してください。 @indexzeroが説明したように：

messageとstack特性にError原因となる非列挙されているJSON.stringify出力に1が期待していないことを何かを。

基本的に、 messageプロパティとstackプロパティは列挙できないため、 JSON.stringifyはこれらのプロパティをスキップし、空のオブジェクト{}ます。 列挙可能性をよりよく理解するには、この列挙可能性とプロパティの所有権を読むことをお勧めし

幸いなことに、winston 3.0の設計方法（winstonチームへの小道具）により、@ 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;
});

ドキュメントStreams、objectMode、およびinfoオブジェクトから、infoオブジェクトにはinfo.levelとinfo.message 2つのプロパティがあります。 その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を作成する必要がない場合は便利です。 私が理解しているように、winstonチームは、後のバージョンでリリースされる修正に取り組んでいます。

いくつかの最後のメモ。 これは、メッセージがエラーオブジェクトであるlogger.log({level: <level>, message: <message>})を使用する場合にのみ機能します。 例：

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

上記の他の投稿で説明したように、winstonにはこのコードが機能しない別のバグがあります。

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

logger.error(err)を使用すると、何らかの理由でinfo.messageプロパティが定義されません。 うまくいけば、 @ indexzeroはこれを

@ SamuelMaddox17 @indexzeroありがとうございます！ logger.log({level: 'error', message: err});を使ってみましたが、うまくいきました

これはlogger.errorなどで修正できますか？

logger.logを使用するのは面倒で冗長です。特に、 logger.errorを使用すると、複数の引数を簡単に追加できるためです。

ねえ、私はこれを調べています。 @indexzero ：それでも、enumerateErrorFormat機能をjsonフォーマッターに追加するのが最善のアイデアだと思いますか？ 私たちは別に気にする必要がありますかについての場合はmetaあるErrorだけではなく、 object （私たちはまた、そのような場合に対処していない場合、人々は文句を言うだろう推測しています？） ？ また、私はmasterを使用していますが、上記の@indexzero / @ SamuelMaddox17によるソリューションでは、 logger.error機能しているようです。

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

さらに調査したところ、上記で説明した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をjson形式に追加する必要があることに同意します。 そして、あなたはおそらくmetaについても正しいでしょう。

最後に、 @ DABHで指定されたコード例により、スタックが「きれいに印刷」されないことに注意してください。 少なくともmacOSHighSierraを実行している私のマシンでは。 これは私にとってそれがどのように見えるかです：

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

ご覧のとおり、to JSON関数を使用してエラーを出力する場合、改行文字\nは実際の新しい行を作成しません。 これは、オブジェクトを取得してJSONに変換するときに予想される動作ですが、少なくともコンソールにログを記録するときは、ロガーに実際に必要な動作ではない可能性があります。

この@DABHを詳しく調べていただきありがとうございます

参考までに、これは私がこれで少し遊んだ後に得たところです：

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;

この問題の原因は次のとおりです： https ：

私たちは間違いなくこのフォームをwinston2.xで問題なく使用しました。 winston.err('some message', err);とwinston.error(err)上記のenumerateErrorFormat winston.error(err)修正しますが、2番目のパラメーターとしてerrを使用するユースケースは修正しません。

@ SamuelMaddox17

logger.log（{レベル：____、メッセージ：エラー}）;

それはthxで動作します

さて、私は何かを発見しました。 9月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問題が発生します。 各トランスポートのレベルと形式を指定しても問題ないと思います。 これはWinston2.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'));

うまくいけば、これが問題の根本に到達するのに役立ちます。

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

考え？

問題はこの行にあると思います
const info =（msg && !(msg instanceof Error) && msg.message && msg）|| {{
メッセージ：msg
};
@crowleymが指摘しているように、instanceofErrorのチェックを追加すると問題が解決するようです

まだこれを扱っている人のために、これは私が思いついた回避策のフォーマッターです（私のlogger.jsモジュールのスニペット）：

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でErrorオブジェクトを取得した場合にのみ機能します。

トランスポートごとにフォーマッタを定義する場合は、 logger.log({level: "error", message: new Error("FAILED")})を使用し、 infoではなくinfo.messageを介してErrorオブジェクトを処理してErrorオブジェクトにアクセスする必要があります。

トランスポートオプションでフォーマットフィールドを設定するときにバグがあると思いますか？

これらは私の2セントであり、私にとってはうまくいきました。私はWinstonを初めて使用し、JavaScriptに慣れていないので、何も引用しないでください。

私のアプローチは根本的な原因を修正する試みでした。 しかし、リポジトリの所有者からはあまり注目されていません...

ええ、私はそれを理解しています。 私はウィンストンに不慣れで、おそらくそれを誤って利用したか、その背後にある概念をまだ十分に理解していないのではないかと思ったので、文字通りこれを理解た。

しかし、幸運なことに、私は別の方法で私を示したいくつかのスレッド（これを含む）に出くわしました。 うまくいけば、彼らはこれを修正するので、回避策を使い続ける必要はありません。

これはwintson-transportが原因である可能性があります。問題についてはhttps://github.com/winstonjs/winston-transport/issues/31を、 ください。 PRの場合は

エラーオブジェクトの直接ロギングは、それらの列挙できないプロパティのために常に混乱します。 個人的にはこれは悪い習慣だと思いますが、コミュニティの十分な人々がそれをサポートしなければならない要件としてそれについて固執しています。

このような動作をサポートする形式としてhttps://github.com/winstonjs/logform/pull/59を採用することを検討してい.splat()と同様）

@indexzero同意する傾向がありますが、複数のErrorタイプを異なる方法で表示する必要があり、Winston 2.xが箱から出して許可されたので、この慣行と戦ってください。

したがって、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を使用する場合は、ほぼ便利です。 2番目のパラメータがエラーであると想定し、それをinfoオブジェクトにinfo.errorとして配置し、逆の方法でログを記録すると、インターフェイスは{ level: "error", error: YOUR ERROR OBJECT}

私は本当にここで唾を吐きますが、新しいインターフェースは間違いなく少しイライラしています（すべての情報）。

私が言っていたポイントを詳しく説明するために、 logger.error( e )と仮定します。ここで、eは型エラーです。

次に、コードでwinstonを次のように構成します。

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

タイムスタンプがエラーオブジェクトに押し込まれています😱。 それは本当に意味がありますか？ 考えてみてください。送信したエラーオブジェクトは、新しいプロペラを動的に取得しています。タイムスタンプ。

この問題の全体的な最善の解決策は、次の構文をサポートすることだと思います

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

次に、内部的に、エラーフィールドを検索するエラーフォーマッタを作成できます。

この人々の最新情報：

• winstonを使用してlogform形式のhttps ：
• それは元のPRのAPIが正しくなかったことを示していたので、私はそれを正しい方向にハッキングし始めました： https ：

これを縫い上げて、数日以内に出荷することを望んでいます。 [email protected]トラッカーの最後から2番目の号です

ハウディの皆さん–https ：//github.com/winstonjs/winston/pull/1562をチェックして3.2.0リリースチェックリストの最後の項目だったので、PRが縫い付けられたら、リリースできるようになります。

修正が公開されるまで、次の回避策を使用します。

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

私は最新のウィンストン（3.2.1）を使用していますが、 logger.errorエラーを渡すと、まだundefined受け取ります。

@ezzeには優れたソリューションがありましたが、スタックトレースは新しい行に強制されます。 これは少し変更されたバージョンで、1行にまとめられています（ログファイルの単純な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までお知らせください。 私はライブラリを初めて使用し、ドキュメントをフォローしていました

あなたがPRに投稿したリンクを見たところです。 これは、エラーを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このスレッドが話している2つの問題が発生しました。 最初は元のポスターが提起したものであり、2番目は私が提起した問題であり、あなたの問題と同じです。 彼らは元のポスターの問題を修正しただけだと思います。 私はさらにチェックして確認し、その場合は新しい問題を開くことを意味してきました。 残念ながら、深く潜る時間がありませんでした。 それまでの間、 logger.log({level: 'error', message: err});を使用する場合（ errはエラーオブジェクト）、それは機能します。

まだこの問題があり、これを理解するために多くの時間を失いました。@ the-vampiireの解決策はうまく機能します。

なぜこのチケットは閉まっているのですか？

logger.errorをオーバーライドすることは、error（）に単一の引数として渡されるErrorオブジェクトにタイムスタンププロパティを追加しないため、これまでのところ最善の解決策です。 ほとんどの人は、Errorオブジェクトが不変であることを期待している可能性があります。 logger.infoやその他すべてのレベル関連のメソッドもオーバーライドしないと、期待どおりに機能しないのは驚きです。 繰り返しますが、オブジェクトを変更する必要がない限り、そのタイプに関係なく、Winstonロガーメソッドに直接送信しないでください。

この機能は[email protected]以降サポートされてい

使用例：

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

私もまだ問題にぶつかっています。
logger.error(error);ようなエラーを呼び出すと、 undefinedしか表示されません。
logger.error('Something went wrong', error)ように呼び出す場合にのみ、完全なエラーが発生し、解析できます。

私もまだ問題にぶつかっています。
logger.error(error);ようなエラーを呼び出すと、 undefinedしか表示されません。
logger.error('Something went wrong', error)ように呼び出す場合にのみ、完全なエラーが発生し、解析できます。
これを追加しましたか？

format.errors({ stack: true })

はい、それでも同じ問題です。 要旨で再現してみます。

@ OBrown92今日も同じ問題に直面しています。 format.errors({ stack: true })がトランスポートではなくロガーに適用されれば、機能することを確認できます。 この場合、 logger.error(error);とlogger.error('Something went wrong', error)両方を使用できます。 ただし、選択したトランスポートにformat.errors({ stack: true })を適用しようとすると、問題が発生します。 この場合、 logger.error(error);に対してundefinedを取得しますが、 logger.error('Something went wrong', error)は正しく機能します。

予期された動作なのかバグなのかはわかりませんが、原因を見つけるのに多くの時間を費やしたので、修正するか、ドキュメントのどこかにそのことを記載してください。 それは本当に役に立ちます。

とにかく、この素晴らしいプロジェクトでのあなたの仕事にとても感謝しています。

私は同じ問題に直面していたので、このパッケージutils-deep-cloneを作成しました。 見てみな。

format.errors is not a function ...まあそれは驚きです。

@holmberd
winstonパッケージからフォーマットをインポートしましたか？
使用例：
const { format } = require('winston')
または
const winston = require('winston'); const { format } = winston;

@aybhalala yepp、エラースタックがそれなしでprintf渡されることは問題ではありませんが。

更新：これにはまだ問題があるので、私はしばらくの間次のことをしていて、それはうまく機能しています

// 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 } );

^^それは予想される使用法です。 単なる人間はこれを理解することは決してないので、それを文書化する必要があります。

単なる人間はこれを理解することは決してないので、それは文書化されるべきです

😂その仲間に+1

私はサードパーティのトランスポート（ @google-cloud/logging-winston ）で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.>

winstonはmeta.messageを元のメッセージに連結するため、奇妙なandsomethingと重複したメッセージがスタックに出力されます。 これは＃1660で説明されています。

＃1664がこれを修正しようとしているようです。 その間に、私はその連結を「元に戻す」フォーマッターを作成しました： https ：

@dandv

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

console.log()とは異なり、ウィンストンのlogger.<level>(message)はメッセージと呼ばれるパラメータを1つだけ取るため、これは機能しません。 そのメッセージパラメータはオブジェクトまたは文字列のいずれかです（私が間違っている場合は誰かが私を修正しますが、それは私の理解です）。

logger.log({level: <level>, message: <message>})も使用できることに注意してください。 これらの2つの関数の詳細については、ドキュメントのこの部分を読むことをお勧めします：ログレベルのWinstonDocs 。 ロギングレベルの使用を必ずお読みください

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

なぜこれがスタックを出力しないのかを明確に言うことはできませんが、これがウィンストンの問題ではないことは知っています。 console.log(`Caught error: ${e}`)を試してみると、スタックも含まれていません。 私はテンプレートリテラルをあまり使用していないので、テンプレートリテラルがオブジェクトでうまく機能しないか、javascriptのconsole.logがオブジェクトをエラーオブジェクトとして認識し、メッセージプロパティのみを出力します。 それが私の一番の推測です。

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

これは、このバグスレッドの核心になります。 まず、JavaScriptに関する技術的な詳細を理解する必要があります。 console.log(`Caught error: ${JSON.stringify(e)}`)を試してみると、同じ出力Caught error: {}も得られることに注意してください。 @indexzeroが説明したように：

messageとstack特性にError原因となる非列挙されているJSON.stringify出力に1が期待していないことを何かを。

基本的に、 messageおよびstackプロパティは列挙できないため、 JSON.stringifyはこれらのプロパティをスキップし、空のオブジェクト{}ます。 列挙可能性をよりよく理解するには、この列挙可能性とプロパティの所有権を読むことをお勧めし

幸いなことに、winston 3.0の設計方法（winstonチームへの小道具）により、@ 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;
});

ドキュメントStreams、objectMode、およびinfoオブジェクトから、infoオブジェクトにはinfo.levelとinfo.message 2つのプロパティがあります。 その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を作成する必要がない場合は便利です。 私が理解しているように、winstonチームは、後のバージョンでリリースされる修正に取り組んでいます。

いくつかの最後のメモ。 これは、メッセージがエラーオブジェクトであるlogger.log({level: <level>, message: <message>})を使用する場合にのみ機能します。 例：

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

上記の他の投稿で説明したように、winstonにはこのコードが機能しない別のバグがあります。

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

logger.error(err)を使用すると、何らかの理由でinfo.messageプロパティが定義されません。 うまくいけば、 @ indexzeroはこれを

非常に良い説明ですが、 logger.error(追加したいと思います。エラーが発生しました：$ {e} );文字列リテラルがjavascriptで機能する方法が原因で、スタックが失われます`${e}`はe.toString() `${e}`とまったく同じであるため、エラーメッセージのみを出力することが期待される動作です。

これはまだ問題ですか？ 私はまだこれに問題があります：

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
}

これはまだ問題ですか？ 私はまだこれに問題があります：

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 {
（メッセージ：文字列、コールバック：LogCallback）：ロガー;
（メッセージ：文字列、メタ：任意、コールバック：LogCallback）：ロガー;
（メッセージ：文字列、...メタ：任意[]）：ロガー;
（infoObject：オブジェクト）：ロガー;
}

したがって、エラーオブジェクトを最初のパラメータとして渡すと、文字列しか理解しないため、エラーのメッセージのみが受け取られます。2番目のパラメータでエラーを渡すと、info.stackのスタックトレースにアクセスできます。

ところで、私はこれをドキュメントのどこにも見つけることができませんでした

私は2つの解決策を見つけました。最初の解決策は、親ロガーのログフォームに記載されているformat.errorsを使用し、次にformat.printfを使用してmessageFormatterを作成し、から抽出されたstackフィールドを条件付きで追加することです。 info （ format.errors({ stack: true})はそれを追加します）。

私が好んだもう1つの解決策は、ウィンストンレベルのロガーをハックすることでした。

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と同様のエラーログを取得できるようです。

format.errorsが_parent_ロガーにどのように配置されなければならないかについての@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オブジェクトの処理は正しく機能します。

ここでのバグは、動作に違いがないはずだということだと私には思えます。

それで、これは1年後もまだ修正されていませんか？ ウィンストンロガーコードをハックして機能させる必要がありますか？

ええ、これは私に十分な頭痛の種を与えたので、ウィンストンは私の比較的単純なユースケースの価値よりもはるかに厄介なように見え始めました...私は自分の小さなロガークラスを書くことになりました、そしてウィンストンでない限り他の人にも同じことをすることをお勧めします本当に必要なものを提供します。

みんな、本当に？ これはイライラします...

私はコミッターではありませんが、壊れていないので「修正」されることはないと言うのはおそらく正しいでしょう。 ウィンストンは使用する価値があります。 あなたはそれを設定する必要があります-私にとっての最良のアドバイスはhttps://github.com/winstonjs/winston/issues/1338#issuecomment-506354691にあります

未だに ？

更新：これにはまだ問題があるので、私はしばらくの間次のことをしていて、それはうまく機能しています

// 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 } );

トレースはどこから来たのですか？

いいえ、これはロギングライブラリには受け入れられません。
メンテナは、カスタムのprintf形式と非json形式を定義し、logger.error（ "something"、err）やloggerなどを使用してエラーをログに記録できる、エラーをログに記録する方法が示されているドキュメントに、よく強調された例を配置するだけです。 .error（err）
ウィンストンは素晴らしいようでしたが、この問題は信じられないほど受け入れられません

これは、Winstonを使用してエラーをログに記録する方法についての私の見解です。 それはユニークではありません。上記の多くの覗き見には、同じ概念に基づいた実用的なソリューションもあります。

バックグラウンド
@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を使用してエラーオブジェクトをきれいに印刷しました。これは、winstonが依存しているのと同じ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
            })
        ]
    });

PS： https： //github.com/winstonjs/winston/issues/1338#issuecomment-506354691に記載されている解決策も良い代替手段だと思いlogger.warn("Oh no", { error: new Error() })を使用してから、カスタムフォーマッタでinfo.errorを

@tiagonapoli親ロガーでformat.errorsを使用することについてのあなたの解決策は私のために働きました：

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

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

このロガーを構成するのはかなり苦痛です...箱から出してconsole.logように振る舞うだけではないでしょうか？

@ will093ここでも同じです。 もう一度その問題に取り組んでいて、なぜ私のconsole.logが素晴らしくてきれいで、ウィンストン形式がたわごとであるのか理解できません。

私の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);

@tiagonapoliと@ will093のソリューションを使用して、それを親だけに追加することは、エラーを直接ログに記録し、メッセージをログに記録することをサポートする最も簡単な方法のようです-タイムスタンプ付きの最小限のセットアップの完全な例を次に示します。

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のより複雑なソリューションが行うようです。

また、jsonログが好きな場合は、ここにlogFormatterをドロップして、代わりにwinston.format.json()を使用できます。これには、スタックが含まれますが、きれいではありません。

更新：これにはまだ問題があるので、私はしばらくの間次のことをしていて、それはうまく機能しています

// 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 } );

trace（）の定義はどこにありますか？

更新：これにはまだ問題があるので、私はしばらくの間次のことをしていて、それはうまく機能しています

// 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 } );

トレースはどこから来たのですか？

これについて何か答えはありますか？