fix: ensure File transport flushes all data before emitting finish (#2594)

Fixes #1504

The File transport was emitting the 'finish' event before all buffered
data was actually written to disk. This caused data loss when calling
logger.end() followed by process.exit().

The root cause was that the transport's internal PassThrough stream
could finish before the underlying fs.WriteStream had flushed to disk.

This adds a _final() method that waits for the destination file stream
to complete before signaling that the transport has finished.

Author: mldangelo

lib/winston/transports/file.js

@@ -109,6 +109,38 @@ module.exports = class File extends TransportStream {
     }
   }
 
+  /**
+   * Called by Node.js Writable stream before emitting 'finish'.
+   * Ensures all buffered data is flushed to the underlying file stream
+   * before the transport signals completion.
+   * @param {Function} callback - Callback to signal completion.
+   * @private
+   */
+  _final(callback) {
+    // If still opening, wait for the file to be opened first
+    if (this._opening) {
+      this.once('open', () => this._final(callback));
+      return;
+    }
+
+    // End the PassThrough stream
+    this._stream.end();
+
+    // No destination stream, call callback immediately
+    if (!this._dest) {
+      return callback();
+    }
+
+    // Destination is already finished
+    if (this._dest.writableFinished) {
+      return callback();
+    }
+
+    // Wait for destination stream to finish writing
+    this._dest.once('finish', callback);
+    this._dest.once('error', callback);
+  }
+
   /**
    * Core logging method exposed to Winston. Metadata is optional.
    * @param {Object} info - TODO: add param description.

test/unit/winston/transports/file.test.js

@@ -399,6 +399,85 @@ describe('File Transport', function () {
     it.todo('should write to the stream when logged to with expected object');
   });
 
+  describe('Flushing on end (issue #1504)', function () {
+    it('should flush all messages to file when logger.end() is called', async function () {
+      const expectedFilename = 'test-flush.log';
+      const expectedMessageCount = 100;
+
+      const logger = winston.createLogger({
+        transports: [
+          new winston.transports.File({
+            filename: expectedFilename,
+            dirname: testLogFixturesPath
+          })
+        ]
+      });
+
+      // Log multiple messages
+      for (let i = 0; i < expectedMessageCount; i++) {
+        logger.info(`message ${i}`);
+      }
+      logger.info('THE LAST MESSAGE');
+
+      // Wait for logger to finish
+      await new Promise((resolve) => {
+        logger.on('finish', resolve);
+        logger.end();
+      });
+
+      // Verify all messages were written
+      await waitForFile(expectedFilename);
+      const fileContents = fs.readFileSync(getFilePath(expectedFilename), 'utf8');
+      const lines = fileContents.split('\n').filter(l => l.trim());
+
+      assert.strictEqual(
+        lines.length,
+        expectedMessageCount + 1,
+        `Expected ${expectedMessageCount + 1} lines, got ${lines.length}`
+      );
+      assert.ok(
+        fileContents.includes('THE LAST MESSAGE'),
+        'File should contain THE LAST MESSAGE'
+      );
+    });
+
+    it('should flush all messages when transport finish event is used', async function () {
+      const expectedFilename = 'test-flush-transport.log';
+      const expectedMessageCount = 50;
+
+      const transport = new winston.transports.File({
+        filename: expectedFilename,
+        dirname: testLogFixturesPath
+      });
+
+      const logger = winston.createLogger({
+        transports: [transport]
+      });
+
+      // Log multiple messages
+      for (let i = 0; i < expectedMessageCount; i++) {
+        logger.info(`message ${i}`);
+      }
+
+      // Wait for transport to finish (original issue pattern)
+      await new Promise((resolve) => {
+        transport.on('finish', resolve);
+        logger.end();
+      });
+
+      // Verify all messages were written
+      await waitForFile(expectedFilename);
+      const fileContents = fs.readFileSync(getFilePath(expectedFilename), 'utf8');
+      const lines = fileContents.split('\n').filter(l => l.trim());
+
+      assert.strictEqual(
+        lines.length,
+        expectedMessageCount,
+        `Expected ${expectedMessageCount} lines, got ${lines.length}`
+      );
+    });
+  });
+
 
   // TODO: Reintroduce these tests
   //