transports.File is not flushing on end.

Please tell us about your environment:

• winston version?
  • winston@2
  • winston@3
• node -v outputs: v10.10.0
• Operating System? (Windows, macOS, or Linux)
• Language? (all | TypeScript X.X | ES6/7 | ES5 | Dart)

What is the problem?

File transport is not flushing on exit. Even when flushing per https://github.com/winstonjs/winston#awaiting-logs-to-be-written-in-winston

Steps to reproduce:

'use strict';

let winston = require('winston');
// VERSION: "winston": "^3.1.0",

let file_transport = new winston.transports.File({
    filename: `${__dirname}/myfile.log.json`,
});
let logger = winston.createLogger({
    transports: [file_transport],
});


async function run() {
    for (let i = 0; i < 1000; i++) {
        logger.info('message');
    }

    logger.info('THE LAST MESSAGE');

    await new Promise(resolve => {
        file_transport.on('finish', resolve);
        logger.end();
    });

    process.exit(1);
}

run();

What do you expect to happen instead?

all messages (including THE LAST MESSAGE) should be written to the file.

[ronanquillevere]

I am experiencing the exact same issue, the posted code by @racquetmaster is correct. It makes it almost impossible to use winston with asynchronous processing

I have been following the documentation (below) calling the end() on Logger. I also tried directly on (File) Transport like @racquetmaster without success. IMO this is a very important issue.

Often it is useful to wait for your logs to be written before exiting the process. Each instance of winston.Logger is also a [Node.js stream]. A finish event will be raised when all logs have flushed to all transports after the stream has been ended.

'use strict'

const winston = require('winston')

const logFilePath = __dirname + '/test-async.log'

const logger = winston.createLogger({
  level: 'debug',
  format: winston.format.combine(
    winston.format.timestamp({
      format: 'YYYY-MM-DD HH:mm:ss'
    }),
    winston.format.simple(),
    winston.format.printf(info => {
      return `[${info.timestamp}] [${info.level}] ${info.message}`
    })),
  transports: [
    new winston.transports.File({
      filename: logFilePath
    })
  ]
})

let code = 1
const asyncFunction = async function(){
  return new Promise(function(resolve) {
    setTimeout(function() {
      logger.info('resolved')
      resolve(0)
    }, 300)
  })
}

const start = async function(){

  logger.info('START')

  code = await asyncFunction()
  logger.info(`code : ${code}`)
  logger.on('finish', function() {
    process.exit(code)
  })

  //Should display END before exiting the process according to doc
  logger.info('END')
  logger.end()
}

start()

[yogeshbiz]

This is still a major problem searched on internet. Graceful exit is okay to advise but most cases, developers just call exit(), which does not executes all pending async task. But this “caution” advisory must be shouted loudly in Winston documents. Program must wait to drain everything, do you think it is obvious to guess this, even knowing node is async? Make it easy for developers to create robust and reliable logging. Could there be a sync call that returns when all transports are written and flushed.

Found this, https://www.npmjs.com/package/winston-log-and-exit after wasting 6-7 hours.