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

똑같이 작동하지 않는 것들이 너무 많습니다.

안녕하세요, 업데이트가 있습니까? 감사 해요.

또한 winston에서 console.log(...args) 를 에뮬레이트하는 적절한 방법을 기다리고 있습니다...

splat 및 meta in 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"}

일반 빠른 시작 코드를 사용했습니다.

내가 주목한 한 가지는 다음과 같습니다.

• 2개의 전송이 있는 로거를 얻었습니다(콘솔 및 회전 파일)
• 둘 다 splat 형식을 사용합니다.
• 첫 번째 전송에 대한 splat의 변환 함수에 대한 호출은 SPLAT 기호 아래의 정보에 저장된 배열을 지웁니다.
• 두 번째 전송에 대한 splat의 변환 함수 호출 시 SPLAT 배열이 비어 있으므로 추가 인수가 더 이상 기록되지 않습니다.

이 문제가 해결될 수 있기를 바랍니다.

참고: Winston의 최신 릴리스 버전으로 이것을 테스트했습니다. 코드를 간단히 살펴보면 마스터에서 여전히 이와 유사한 것으로 보입니다(다른 수정 사항이 있는 것 같습니다).

@luislobo 의 솔루션에 대한 몇 가지 개선 사항 👏

• logger.info(`hello %s`,'world') 와 같은 메시지에 대해 %s %d or %j 가 포함된 표시 스타일인 경우 메시지 무시
• colorise를 먼저 만들기 위해 재정렬된 포맷터 https://github.com/winstonjs/winston#colorizing -standard-logging-levels
• printf 에서 twise formateObject를 제거했습니다.
• trimEnd 루거에 추가 인수가 제공되지 않은 경우

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

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

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

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

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

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

누락된 추가 업데이트가 있습니까? 이 기능이 다시 추가될 것이라는 강력한 지원이 있는 것 같지만, 이에 대한 마지막 약속은 거의 6개월 전이었습니다.

안녕하세요, 거대한 범퍼와 쇼 스토퍼는 3.X로 마이그레이션하려고 시도하며 2.x를 한동안 유지할 것입니다.

조금 실망 :(

이것이 나를 위해 일한 것입니다.

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

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

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

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


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

결과: 2019-07-04T21:30:08.455Z [myLabel] info: foo "bar" 1 [2,3] true {"name":"John"}

기본적으로 format.combine 는 info 개체에 대한 파이프라인을 설정합니다. 각 형식 함수에 대해 transform 가 호출되고 최종 로그 메시지는 info[Symbol.for('message')] 작성되어야 합니다.
도움이 되었기를 바랍니다

%d , %o 등을 지원하는 솔루션을 원했지만 여전히 나머지 인수를 포함하도록 기본 설정되어 있으므로 logger.info('hello %d %j', 42, {a:3}, 'some', 'more', 'arguments') 가 다음과 같이 렌더링됩니다.

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

이에 대한 내 솔루션은 splat 기호를 사용했지만 기본적으로 나머지 인수를 포함하는 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'));

처리해야 할 많은 것들이 있으며 그 중 일부는

• 첫 번째 인수로 객체와 같은 값
• 혼합 값의 여러 인수
• ANSI 이스케이프 코드가 있는 문자열(예: chalk
• Function 및 RegEx와 같은 난해한 값
• 첫 번째 인수 또는 그 이후의 모든 위치에서 오류
• 여전히 다른 포맷터와 함께 잘 작동해야 합니다.

이 솔루션의 현재 버그

• 첫 번째 인수로 오류를 전달하면 스택 추적이 인쇄되지 않습니다.
  
  
  
  • info.message 는 문자열일 뿐이고 스택 영역은 stack 속성에 있기 때문입니다.
  
  
• message 속성이 있는 개체를 첫 번째 인수로 전달하면 message 만 인쇄되고 다른 속성은 무시됩니다.
  
  
  
  • 위와 같은 이유
  
  
• 두 번째 인수로 오류를 전달하면 info.message (일반적으로 첫 번째 인수의 값) 위에 오류 메시지가 연결되어 오류 메시지가 두 번 표시됩니다.
  
  
  
  • 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}`;
        })
    )
});

주요 버전이 주요 변경 사항을 도입한다는 것을 이해하지만, 제 맙소사...

어떤 솔루션도 winston v2와 동일한 동작을 제공하지 않았습니다.
@henhal 및 @yamadashy의 솔루션에는 모두 동일한 문제가 있습니다. 메시지 값이 문자열로 표시됩니다.
logger.debug(err) 로그 메시지 생성:

debug:  Error: ETIMEDOUT

반면 logger.debug('anystringhere', err) 생성합니다.

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

두 번째 문제는 정보 수준과 함께 사용할 때 추가 인수가 억제된다는 것입니다. winston v3는 서식 지정하기 전에 다른 방식으로 처리하는 것 같습니다.

세 번째 문제는 2개의 메시지 사이에 공백이 없다는 것입니다("anystringhereError" 참고).

내 현재 v3 로거 구성:

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

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

나는 그것으로 충분했고 다음과 같이 winston 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 구성에는 위에서 언급한 문제가 없습니다.

내 winston 설정을 공유하고 싶습니다.

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

위에 제안을 게시한 사람에게 감사합니다.
젠장, 내 프로젝트에 Winston 3를 통합하기 위해 하루를 버렸습니다./

이것은 오늘 나를 쳤습니다 - 나는 멋진 새 로거가 내 모든 ...rest 인수를 던지고 있다는 것을 깨달았습니다. 이것은 모든 사람 또는 모든 사용 사례에서 작동하지 않을 수 있지만 제 경우에는 배열로 기록하려는 모든 것을 래핑하는 것이 허용된다는 것을 알았습니다. 가장 예쁘지는 않지만 더 많은 코드가 필요한 [매우 영리한] 해결 방법보다 가볍습니다. 이것이 다른 사람을 돕기를 바랍니다!

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

정말 그들이 주요 변경이 대형하기로 결정하고 STILL 마이그레이션 설명서 나 문서에 언급되지 않았 음을 화나게.

그럼에도 불구하고 나는 매우 컴팩트하고 node 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을 사용하려고 하면 항상 많은 시간이 낭비되고 로깅에 놀라운 문제가 발생합니다.

정말 그들이 주요 변경이 대형하기로 결정하고 STILL 마이그레이션 설명서 나 문서에 언급되지 않았 음을 화나게.

그럼에도 불구하고 나는 매우 컴팩트하고 node 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을 사용하여 메시지와 splat을 결합하는 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 어느 시점에서 여전히 이 문제를 해결할 계획

내 프로젝트에서 사용할 winston을 탐색 중입니다. 이제 이 문제가 2년 이상 열려 있으므로 위험을 감수할 가치가 있는지 궁금합니다. 나에게 이것은 모든 로깅 프레임 워크의 기본 기능처럼 보입니다.