Winston: ロギング関数に複数のパラメータを渡すと、期待どおりに動作しません

私は今日同じ問題に遭遇しました。 アップグレードドキュメントにもそのような例があるので、これはバグだと思います：

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

現在、これを回避するために、winstonに渡される前に引数を解析する関数を作成できます。

@ mulligan121わかりましたが、コードベース内のすべてのログステートメントを置き換えたくありません...

@indexzeroこれはあなたのレーダーの下にありますか？ これは大きな変化だと思います。 すべてのログエントリを変更する必要があるため、実際には2.xから3.xに移動できません。

一時的な回避策：

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

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

これは私たちにとって大きな変革です。 意図的なものである場合は、 https：//github.com/winstonjs/winston/blob/master/UPGRADE-3.0.mdで詳しく説明する必要があり

したがって、さらに調査した結果、複数の引数を出力するには、スプラットフォーマッタが必要であることがわかりました。 これは引数の補間（つまり、％sなどが含まれているもの）のためだけだと思いましたが、 logger.info("something", value)を実行するためだけに必要なようです。

しかし、これは私にとってはまだ少し奇妙です-JSON形式を使用していなくても、出力に「メタ」キーを持つJSONのようなものが表示されます。

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

生産：

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

例の例でさえ、それが言うことを生み出しません：

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

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

私はこれらの線に沿った何かを使用してそれを解決しました：

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

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

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

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

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

複数のパラメータを許可するための一般的な回避策は次のとおりです。
https://github.com/rooseveltframework/roosevelt/blob/master/lib/tools/logger.js#L29

関連：
https://github.com/winstonjs/winston/issues/1377

同じように機能しないものが多すぎます。

こんにちは、ここに更新はありますか？ ありがとう。

また、ウィンストンでconsole.log(...args)をエミュレートする適切な方法を待っています...

私たちは、周りのエッジ/コーナーケースの数を固定splatとmetaで3.2.0が、これはまだ問題（参照で表示されます。https://github.com / winstonjs / winston / pull / 1576（ CHANGELOG.md ）。

これが3.3.0処理されることを確認します。 あなたの忍耐の人々に感謝します。

これは私にとっての回避策でした：

'use strict';

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

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

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

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

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

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

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

  return result;
});

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

引数を使用してログに記録しようとすると、奇妙な出力が得られます
var s = "Hello" log.info("asdasda", s)

出力を取得する

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

通常のクイックスタートコードを使用しました

私が気づいたことの1つはこれです：

• 2つのトランスポート（コンソールと回転ファイル）を備えたロガーを取得しました
• どちらもスプラット形式を使用します
• 最初のトランスポートのsplatの変換関数を呼び出すと、SPLATシンボルの下の情報に格納されている配列がクリアされます。
• 2番目のトランスポートのsplatの変換関数を呼び出すと、SPLAT配列が空になるため、余分な引数がログに記録されなくなります。

これが修正できる/修正されることを願っています

注：Winstonの最新リリースバージョンでこれをテストしました。コードをざっと見てみると、マスターではまだこのようになっているようです（他の修正があるようです）

@luisloboのソリューションに対するいくつかの改善👏

• スプラットスタイルの場合、つまりlogger.info(`hello %s`,'world')ようなメッセージに%s %d or %jが含まれている場合は、メッセージを無視します
• フォーマッタを並べ替えて色付けを最初に行うhttps://github.com/winstonjs/winston#colorizing-standard-logging-levels
• printf twiseformateObjectを削除しました
• ルーガーに追加の引数が指定されていない場合はtrimEnd

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

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

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

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

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

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

私が行方不明になっているかもしれないこれへのさらなる更新はありますか？ この機能を再度追加することはかなり強力にサポートされているようですが、これに対する最後の取り組みはほぼ6か月前でした。

こんにちは、巨大なバンパーとショーストッパーが3.Xに移行しようとすると、おそらくしばらくの間2.xを維持します。

少しがっかり:(

これは私のために働いたものです：

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

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

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

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


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

結果は次のようになります： 2019-07-04T21:30:08.455Z [myLabel] info: foo "bar" 1 [2,3] true {"name":"John"}

基本的に、 format.combineはinfoオブジェクトのパイプラインを設定します。 フォーマット関数ごとに、 transformが呼び出され、最終的なログメッセージがinfo[Symbol.for('message')]書き込まれる必要があります。
お役に立てれば

%d 、 %oなどをサポートするソリューションが必要%d 、デフォルトでは残りの引数が含まれているため、 logger.info('hello %d %j', 42, {a:3}, 'some', 'more', 'arguments')は次のようにレンダリングされます。

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

これに対する私の解決策は、最終的にsplatシンボルを使用しましたが、 printfから直接util.format()手動で呼び出しました。これには、デフォルトで残りの引数が含まれています。

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

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

printf必要ない場合は、もちろん、代わりに引数をinfo.messageに展開する変換を追加して、最終結果を好きなようにフォーマットすることができます。

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

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

      return info;
    }
  },
  simple()
)  

format.splat()を使用する場合の問題は、一致する引数を消費しますが、残りを破棄するように見えることです。 util.format()自分で呼び出すことで、その動作をオーバーライドできます。

同じ問題、これに関する更新はありますか？ Winstonは大好きですが、ロガーに渡されたすべての引数を出力できないと、頭がおかしくなります。これは、 console.log()実行できます。

@ fr1sk上記のフォーマットを試しましたか？ console.log()ような動作を提供します（ノードのconsole.log()実装は内部的にutil.format() afaikを使用します）。

この問題がまだ解決されておらず、関連する問題がロックされているのは残念です。
私は多くの異なるチームと協力しており、v3に移行するときに以前のDXを失うことへのフラストレーションを共有しています。

私は一日中物事を試してみました。
上記の解決策は近いものでしたが、余分な引数の色付けと改行がありませんでした。

IMO、コンソールへのログ記録は楽しいはずです。
これがそれを実現するための私の試みです...

比較のためのv2セットアップ

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

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

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

v3セットアップ

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

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

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

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

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

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

処理するものはたくさんありますが、そのうちのいくつかは

• 最初の引数としてのオブジェクトのような値
• 混合値のいくつかの引数
• chalkを使用するなど、ANSIエスケープコードを含む文字列
• FunctionやRegExなどの難解な値
• 最初の引数またはその後の任意の場所でのエラー
• 他のフォーマッターと一緒に問題なく動作するはずです

このソリューションの現在のバグ

• 最初の引数としてエラーを渡しても、スタックトレースは出力されません
  
  
  
  • これは、 info.messageが単なる文字列であり、スタックトラクトがstackプロパティにあるためです。
  
  
• でオブジェクトを渡すmessage第一引数のみ印刷してプロパティmessage他のプロパティを破棄し、
  
  
  
  • 上記と同じ理由
  
  
• 2番目の引数としてエラーを渡すと、エラーメッセージがinfo.message （通常は1番目の引数の値）の上に連結され、エラーメッセージが2回表示されます。
  
  
  
  • https://github.com/winstonjs/winston/issues/1660で追跡
  
  
  • これは実際にはREADMEの一部です。
    
    >注：提供されたメタオブジェクトの{message}プロパティは、すでに提供されているメッセージに自動的に連結されます。たとえば、以下は「world」を「hello」に連結します。
  
  

errorsフォーマッターをいじってみても役に立ちませんでした。

ポジティブな機能強化

• プリミティブ値のロギングが適切になりました
• いくつかのオブジェクトのような値をログに記録すると、それらの間に改行が追加されるようになりました
• インデックスキーを持つオブジェクトのように見えるのではなく、配列のロギングが適切になりました

編集：

エラーのフォーマットは処理できますが、ハッキーです。

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

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

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

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

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

info[Symbol.for('splat')]を使用して動作します

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

メジャーバージョンでは重大な変更が導入されていることは理解していますが、私の良さは...

どのソリューションも、winstonv2と同じ動作をしませんでした。
@henhalと@yamadashyのソリューションには、どちらも同じ問題があります。メッセージ値が文字列として表示されます。
logger.debug(err)ログメッセージの作成：

debug:  Error: ETIMEDOUT

一方、 logger.debug('anystringhere', err)は以下を作成します。

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

2番目の問題は、情報レベルで使用すると追加の引数が抑制されることです。winstonv3は、フォーマットする前にそれを逆に処理するようです。

3番目の問題は、2つのメッセージの間にスペースがないことです（「anystringhereError」に注意してください）。

私の現在のv3ロガー構成：

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

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

私はそれを十分に持っていて、これだけでウィンストンv2に戻るつもりです：

const Winston = require("winston");

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

このv2構成には、上記の問題はありません。

ウィンストンの設定を共有したい：

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

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

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

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

複数のパラメータを許可するための一般的な回避策は次のとおりです。
https://github.com/rooseveltframework/roosevelt/blob/master/lib/tools/logger.js#L29

ここに提案されたソリューションへの更新されたリンクがあります
https://github.com/rooseveltframework/roosevelt/blob/0.13.0/lib/tools/logger.js

私のは@alexilyaevの素晴らしい提案のバリエーションです：

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

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

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

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

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

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

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

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

次のようなログの場合：

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

これは次のように出力されます-これは私のすべてのシナリオに適しています：

ねえ、私はWinstonから始めており、v2を使用したことがないので、v3.2.1を使用しています。

私は単純にやろうとしていました：

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

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

そして、文字列補間が機能することを期待しています。 しかし、違います。

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

期待していた時

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

この問題はどういうわけか同じことですか？ または、代わりにlogger.log('info', .....)関数を使用する必要がありますか？

編集

これを試行するイベントは機能しません。

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

出力：

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

上記の提案を投稿してくれた人に感謝します。
くそー私は私のプロジェクトにウィンストン3を統合するためだけにある日捨てました：/

これは今日私を襲った-私の派手な新しいロガーが私のすべての...rest引数を投げていることに気づいた。 これはすべてのユースケースまたはすべてのユースケースで機能するとは限りませんが、私の場合は、ログに記録したいものすべてを配列としてラップするだけで問題ないことがわかりました。 これは最も美しいわけではありませんが、より多くのコードを必要とする[非常に賢い]回避策のいくつかよりも軽量です。 これが他の誰かに役立つことを願っています！

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

彼らがこれほど大きな変更を加えることを決定したことに本当に腹を立て、

非常にコンパクトで、ノードjsがutil.formatを使用してconsole.logを実装する方法に従うソリューションを共有したかったのですが

const winstonLogger= createLogger(...);

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

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

チャイムを鳴らして、この機能をコアWinstonに追加するように要求したいと思います。 現在、私はこの機能を実現するためにsplatのカスタムフォーマッターを使用していますが、これは正直なところ非常にハッキーな感じがします。 console.log一致する機能があると便利です

更新はありますか？

上記のv3の動作に加えて、これも追加したいと思います。

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

これを生成します

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

私が使用しているバージョン：（v3.2.1）
構成：

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

Winstonで複数の値を出力する方法がまだわかりません。

console.log('Hello', var1, '!')をlogger.log('Hello', var1, '!')に置き換えたかっただけです。

正直なところ、Winstonを使用しようとすると、常に多くの時間が無駄になり、ロギングで驚くべき問題が発生します。

彼らがこれほど大きな変更を加えることを決定したことに本当に腹を立て、

非常にコンパクトで、ノードjsがutil.formatを使用してconsole.logを実装する方法に従うソリューションを共有したかったのですが

const winstonLogger= createLogger(...);

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

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

また、 util.formatWithOptions({ colors: true }, ...args);を使用して、通常のconsole.logようにカラー印刷出力を取得します

これは私のために働きます。 util.formatを使用してメッセージとスプラットを組み合わせるcombineMessageAndSplat

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

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

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

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

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

私はconsole。*メソッドに準拠する必要があり、上記のすべてを重視し、...

• chrome-dev-toolsのデフォルトのコンソールメソッド（デフォルトで色付けされます）
• 電子端末コンソール出力（デフォルトでも色付き）
• ファイルへの書き込み

ただし、ファイル出力にはオブジェクトの詳細が表示されます。

だから私は結局：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@indexzeroある時点でまだこれに対処することを計画していたかどうか疑問に思っていましたか？

私は自分のプロジェクトで使用するウィンストンを探していますが、この問題は2年以上続いているので、リスクを冒す価値があるのではないかと考えています。 私にとって、これはあらゆるロギングフレームワークの基本的な機能のようです