Flush stdout/stderr before exiting in async path

Wait for stdout and stderr to drain before calling `process.exit()` in the async code path (`gracefulExit`, `signals`, `beforeExit`). This prevents output truncation when hooks write significant data to stdout/stderr.

Fixes #34

Author: sindresorhus

fixtures/closed-stdio.js

@@ -0,0 +1,9 @@
+import process from 'node:process';
+import {asyncExitHook, gracefulExit} from '../index.js';
+
+process.stdout.end();
+process.stderr.end();
+
+asyncExitHook(() => {}, {wait: 100});
+
+gracefulExit();

fixtures/flush-stdout-short-wait.js

@@ -0,0 +1,14 @@
+import process from 'node:process';
+import {asyncExitHook, gracefulExit} from '../index.js';
+
+const lineCount = Number.parseInt(process.argv[2], 10);
+
+asyncExitHook(() => {
+	for (let i = 0; i < lineCount; i++) {
+		process.stdout.write(`${'x'.repeat(200)}\n`);
+	}
+}, {wait: 10});
+
+setTimeout(() => {
+	gracefulExit();
+}, 50);

fixtures/flush-stdout-stderr-short-wait.js

@@ -0,0 +1,15 @@
+import process from 'node:process';
+import {asyncExitHook, gracefulExit} from '../index.js';
+
+const lineCount = Number.parseInt(process.argv[2], 10);
+
+asyncExitHook(() => {
+	for (let i = 0; i < lineCount; i++) {
+		process.stdout.write(`${'x'.repeat(200)}\n`);
+		process.stderr.write(`${'y'.repeat(200)}\n`);
+	}
+}, {wait: 10});
+
+setTimeout(() => {
+	gracefulExit();
+}, 50);

fixtures/flush-stdout-sync.js

@@ -0,0 +1,12 @@
+import process from 'node:process';
+import exitHook, {gracefulExit} from '../index.js';
+
+const lineCount = Number.parseInt(process.argv[2], 10);
+
+exitHook(() => {
+	for (let i = 0; i < lineCount; i++) {
+		process.stdout.write(`${'x'.repeat(200)}\n`);
+	}
+});
+
+gracefulExit();

fixtures/flush-stdout-timeout.js

@@ -0,0 +1,17 @@
+import process from 'node:process';
+import {asyncExitHook, gracefulExit} from '../index.js';
+
+const chunk = 'x'.repeat(1024 * 1024);
+
+asyncExitHook(() => {
+	for (let chunkIndex = 0; chunkIndex < 5; chunkIndex++) {
+		const canContinue = process.stdout.write(`${chunk}\n`);
+		if (!canContinue) {
+			break;
+		}
+	}
+}, {wait: 10});
+
+setTimeout(() => {
+	gracefulExit();
+}, 50);

fixtures/flush-stdout.js

@@ -0,0 +1,12 @@
+import process from 'node:process';
+import {asyncExitHook, gracefulExit} from '../index.js';
+
+const lineCount = Number.parseInt(process.argv[2], 10);
+
+asyncExitHook(() => {
+	for (let i = 0; i < lineCount; i++) {
+		process.stdout.write(`${'x'.repeat(200)}\n`);
+	}
+}, {wait: 2000});
+
+gracefulExit();

index.js

@@ -6,6 +6,41 @@ const callbacks = new Set();
 let isCalled = false;
 let isRegistered = false;
 
+async function flushStdio() {
+	const flush = stream => new Promise(resolve => {
+		if (!stream || !stream.writable || stream.writableEnded || stream.destroyed) {
+			resolve();
+			return;
+		}
+
+		const onError = () => {
+			stream.off('error', onError);
+			resolve();
+		};
+
+		stream.once('error', onError);
+
+		try {
+			stream.write('', () => {
+				stream.off('error', onError);
+				resolve();
+			});
+		} catch {
+			stream.off('error', onError);
+			resolve();
+		}
+	});
+
+	const timeout = new Promise(resolve => {
+		setTimeout(resolve, 1000);
+	});
+
+	await Promise.race([
+		Promise.all([flush(process.stdout), flush(process.stderr)]),
+		timeout,
+	]);
+}
+
 async function exit(shouldManuallyExit, isSynchronous, signal) {
 	if (isCalled) {
 		return;
@@ -56,12 +91,16 @@ async function exit(shouldManuallyExit, isSynchronous, signal) {
 	}
 
 	// Force exit if we exceeded our wait value
-	const asyncTimer = setTimeout(() => {
-		done(true);
-	}, forceAfter);
+	const asyncTimer = forceAfter > 0
+		? setTimeout(() => {
+			done(true);
+		}, forceAfter)
+		: undefined;
 
 	await Promise.all(promises);
+	// Let flushStdio handle its own timeout without the force-exit timer.
 	clearTimeout(asyncTimer);
+	await flushStdio();
 	done();
 }
 

test.js

@@ -1,8 +1,13 @@
 import process from 'node:process';
+import {spawn} from 'node:child_process';
+import {once} from 'node:events';
+import {setTimeout as delay} from 'node:timers/promises';
 import test from 'ava';
 import {execa} from 'execa';
 import exitHook, {asyncExitHook} from './index.js';
 
+const isContinuousIntegration = Boolean(process.env.CI);
+
 test('main', async t => {
 	const {stdout, stderr, exitCode} = await execa(process.execPath, ['./fixtures/sync.js']);
 	t.is(stdout, 'foo\nbar');
@@ -155,6 +160,105 @@ test('type enforcing', t => {
 	});
 });
 
+test('flushes stdout before exit with async hook', async t => {
+	const lineCount = 10_000;
+	const {stdout, exitCode} = await execa(process.execPath, ['./fixtures/flush-stdout.js', String(lineCount)]);
+	const lines = stdout.split('\n').filter(Boolean);
+	t.is(lines.length, lineCount);
+	t.is(exitCode, 0);
+});
+
+test('flushes stdout before exit with short wait and backpressure', async t => {
+	const lineCount = 20_000;
+	const childProcess = spawn(process.execPath, ['./fixtures/flush-stdout-short-wait.js', String(lineCount)], {
+		stdio: ['ignore', 'pipe', 'ignore'],
+	});
+
+	childProcess.stdout.setEncoding('utf8');
+
+	let stdout = '';
+	childProcess.stdout.on('data', data => {
+		stdout += data;
+	});
+
+	childProcess.stdout.pause();
+	await delay(200);
+	childProcess.stdout.resume();
+
+	const [exitCode] = await once(childProcess, 'close');
+	t.is(exitCode, 0);
+
+	const lines = stdout.split('\n').filter(Boolean);
+	t.is(lines.length, lineCount);
+});
+
+test('flushes stdout and stderr before exit with short wait and backpressure', async t => {
+	const lineCount = 10_000;
+	const childProcess = spawn(process.execPath, ['./fixtures/flush-stdout-stderr-short-wait.js', String(lineCount)], {
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+
+	childProcess.stdout.setEncoding('utf8');
+	childProcess.stderr.setEncoding('utf8');
+
+	let stdout = '';
+	let stderr = '';
+	childProcess.stdout.on('data', data => {
+		stdout += data;
+	});
+	childProcess.stderr.on('data', data => {
+		stderr += data;
+	});
+
+	childProcess.stdout.pause();
+	childProcess.stderr.pause();
+	await delay(200);
+	childProcess.stdout.resume();
+	childProcess.stderr.resume();
+
+	const [exitCode] = await once(childProcess, 'close');
+	t.is(exitCode, 0);
+
+	const stdoutLines = stdout.split('\n').filter(Boolean);
+	const stderrLines = stderr.split('\n').filter(Boolean);
+	t.is(stdoutLines.length, lineCount);
+	t.is(stderrLines.length, lineCount);
+});
+
+test('flush timeout prevents hanging when stdout is blocked', async t => {
+	t.timeout(isContinuousIntegration ? 15_000 : 8000);
+
+	const startTime = Date.now();
+	const childProcess = spawn(process.execPath, ['./fixtures/flush-stdout-timeout.js'], {
+		stdio: ['ignore', 'pipe', 'ignore'],
+	});
+	const closePromise = once(childProcess, 'close');
+
+	childProcess.stdout.pause();
+	await delay(1500);
+	childProcess.stdout.resume();
+
+	const [exitCode] = await closePromise;
+	const elapsedMilliseconds = Date.now() - startTime;
+	t.is(exitCode, 0);
+	t.true(elapsedMilliseconds >= 900);
+});
+
+test('flushes stdout before exit with sync hook', async t => {
+	const lineCount = 10_000;
+	const {stdout, exitCode} = await execa(process.execPath, ['./fixtures/flush-stdout-sync.js', String(lineCount)]);
+	const lines = stdout.split('\n').filter(Boolean);
+	t.is(lines.length, lineCount);
+	t.is(exitCode, 0);
+});
+
+test('does not throw when stdio is closed before flush', async t => {
+	const {stdout, stderr, exitCode} = await execa(process.execPath, ['./fixtures/closed-stdio.js']);
+	t.is(stdout, '');
+	t.is(stderr, '');
+	t.is(exitCode, 0);
+});
+
 const signalTests = [
 	['SIGINT', 130],
 	['SIGTERM', 143],