refactor: replace stream-based logger with LoggerOutput abstraction

- Add `LoggerOutputs` interface and `setOutputs`/`reset` methods to `Logger`
- Add `NoopLoggerOutput` for silent test runs when `APIFY_NO_LOGS_IN_TESTS` is set
- Update `useConsoleSpy` to install a capturing `LoggerOutput` directly instead of wrapping raw streams

Author: vladfrangu

src/lib/logger.ts

@@ -20,7 +20,8 @@ export interface LoggerStreams {
 
 /**
  * The full surface of a single output channel. `logger.stdout` and
- * `logger.stderr` both satisfy this shape.
+ * `logger.stderr` both satisfy this shape. Tests plug in custom
+ * implementations via {@link Logger.setOutputs}.
  */
 export interface LoggerOutput {
 	/** Emit `message` as-is, no prefix, followed by a newline. */
@@ -41,6 +42,11 @@ export interface LoggerOutput {
 	json(data: unknown): void;
 }
 
+export interface LoggerOutputs {
+	stdout: LoggerOutput;
+	stderr: LoggerOutput;
+}
+
 class StreamLoggerOutput implements LoggerOutput {
 	stream: LoggerStream;
 
@@ -85,33 +91,80 @@ class StreamLoggerOutput implements LoggerOutput {
 	}
 }
 
+/**
+ * Output that drops every message. Used as the default channel when the
+ * `APIFY_NO_LOGS_IN_TESTS` env var is set (vitest workers) so test runs stay
+ * quiet unless a test opts into capture via `useConsoleSpy`.
+ */
+/* eslint-disable @typescript-eslint/no-empty-function */
+export class NoopLoggerOutput implements LoggerOutput {
+	log(): void {}
+	info(): void {}
+	warning(): void {}
+	success(): void {}
+	error(): void {}
+	run(): void {}
+	link(): void {}
+	json(): void {}
+}
+/* eslint-enable @typescript-eslint/no-empty-function */
+
+function createDefaultOutputs(): LoggerOutputs {
+	if (process.env.APIFY_NO_LOGS_IN_TESTS) {
+		return {
+			stdout: new NoopLoggerOutput(),
+			stderr: new NoopLoggerOutput(),
+		};
+	}
+	return {
+		stdout: new StreamLoggerOutput(process.stdout),
+		stderr: new StreamLoggerOutput(process.stderr),
+	};
+}
+
 /**
  * CLI logger with explicit `stdout` and `stderr` channels. Every channel
  * exposes the same {@link LoggerOutput} surface — call
  * `logger.stdout.info(...)` when the output is meant to be piped or scripted
  * against, and `logger.stderr.info(...)` for progress/diagnostics the user
  * reads but does not consume programmatically.
  *
- * Streams are swappable at runtime (see {@link setStreams}); tests rely on
- * this to capture output without stubbing `console`.
+ * Outputs are swappable at runtime. Production code almost never touches this;
+ * tests use {@link setOutputs} to install a capturing or silent implementation.
  */
 export class Logger {
-	readonly stdout: LoggerOutput;
-	readonly stderr: LoggerOutput;
+	stdout: LoggerOutput;
+	stderr: LoggerOutput;
 
-	constructor(streams: LoggerStreams = { stdout: process.stdout, stderr: process.stderr }) {
-		this.stdout = new StreamLoggerOutput(streams.stdout);
-		this.stderr = new StreamLoggerOutput(streams.stderr);
+	constructor(outputs: LoggerOutputs = createDefaultOutputs()) {
+		this.stdout = outputs.stdout;
+		this.stderr = outputs.stderr;
+	}
+
+	/**
+	 * Replace the underlying outputs with arbitrary {@link LoggerOutput}
+	 * implementations — e.g. the capturing output used by `useConsoleSpy`, a
+	 * file-backed output, or {@link NoopLoggerOutput} to silence everything.
+	 */
+	setOutputs(outputs: LoggerOutputs): void {
+		this.stdout = outputs.stdout;
+		this.stderr = outputs.stderr;
 	}
 
 	/**
-	 * Replace the underlying stdout/stderr streams. Primarily used by the test
-	 * hook {@link useConsoleSpy} to redirect output into assertable arrays;
-	 * production code almost never needs to call this.
+	 * Convenience shortcut: point the logger at a pair of writable streams.
+	 * Equivalent to `setOutputs` with fresh {@link StreamLoggerOutput}s.
 	 */
 	setStreams(streams: LoggerStreams): void {
-		(this.stdout as StreamLoggerOutput).stream = streams.stdout;
-		(this.stderr as StreamLoggerOutput).stream = streams.stderr;
+		this.stdout = new StreamLoggerOutput(streams.stdout);
+		this.stderr = new StreamLoggerOutput(streams.stderr);
+	}
+
+	/** Restore the outputs the logger was constructed with (per env defaults). */
+	reset(): void {
+		const defaults = createDefaultOutputs();
+		this.stdout = defaults.stdout;
+		this.stderr = defaults.stderr;
 	}
 }
 

test/__setup__/hooks/useConsoleSpy.ts

@@ -1,8 +1,8 @@
 import { appendFileSync } from 'node:fs';
-import process from 'node:process';
 
 import type { MockInstance } from 'vitest';
 
+import type { LoggerOutput } from '../../../src/lib/logger.js';
 import { logger } from '../../../src/lib/logger.js';
 
 interface ConsoleSpyOptions {
@@ -24,38 +24,57 @@ function maybeStringify(itm: unknown): string {
 	}
 }
 
-function stripTrailingNewline(chunk: string): string {
-	return chunk.replace(/\r?\n$/, '');
-}
-
+/**
+ * Installs a test-friendly {@link LoggerOutput} on the global `logger` and
+ * wraps `console.log` / `console.error` so assertions can run against either
+ * path. Every write is mirrored into:
+ *
+ *   - `logMessages.log` / `logMessages.error` for string-based matching
+ *   - `logSpy()` / `errorSpy()` vitest mocks for call-count assertions
+ *
+ * Prefixes (`Info:`, `Warning:`, `Success:`, `Error:`, `Run:`) are preserved
+ * in the captured strings (without chalk color codes) so existing tests that
+ * match on those labels keep working.
+ */
 export function useConsoleSpy(options: ConsoleSpyOptions = { resetMessagesPerTest: true }) {
-	let logSpy!: MockInstance<(typeof console)['log']>;
-	let errorSpy!: MockInstance<(typeof console)['error']>;
-
 	const logMessages = {
 		log: [] as string[],
 		error: [] as string[],
 	};
 
+	// Mutable spy container. The capture outputs read `spies.stdout` /
+	// `spies.stderr` at call time, so the fresh `vitest.fn()`s created in each
+	// `beforeEach` are visible without re-installing the outputs.
+	const spies = {
+		stdout: null as MockInstance<(message: string) => void> | null,
+		stderr: null as MockInstance<(message: string) => void> | null,
+	};
+
 	vitest.setConfig({ restoreMocks: false });
 
-	// Route every `logger.stdout.*` / `logger.stderr.*` write into the same
-	// arrays the console spies populate. The closures read `logMessages.log` /
-	// `logMessages.error` on each call so that the per-test reassignment in
-	// `beforeEach` (below) still captures new writes into the fresh arrays.
-	logger.setStreams({
-		stdout: {
-			write(chunk: string) {
-				logMessages.log.push(stripTrailingNewline(String(chunk)));
-				return true;
-			},
-		},
-		stderr: {
-			write(chunk: string) {
-				logMessages.error.push(stripTrailingNewline(String(chunk)));
-				return true;
-			},
-		},
+	function makeCaptureOutput(channel: 'stdout' | 'stderr'): LoggerOutput {
+		const write = (formatted: string) => {
+			const bucket = channel === 'stdout' ? logMessages.log : logMessages.error;
+			bucket.push(formatted);
+			const spy = channel === 'stdout' ? spies.stdout : spies.stderr;
+			spy?.(formatted);
+		};
+
+		return {
+			log: (message) => write(message),
+			info: (message) => write(`Info: ${message}`),
+			warning: (message) => write(`Warning: ${message}`),
+			success: (message) => write(`Success: ${message}`),
+			error: (message) => write(`Error: ${message}`),
+			run: (message) => write(`Run: ${message}`),
+			link: (message, url) => write(`${message} ${url}`),
+			json: (data) => write(JSON.stringify(data, null, 2)),
+		};
+	}
+
+	logger.setOutputs({
+		stdout: makeCaptureOutput('stdout'),
+		stderr: makeCaptureOutput('stderr'),
 	});
 
 	beforeEach(() => {
@@ -64,28 +83,40 @@ export function useConsoleSpy(options: ConsoleSpyOptions = { resetMessagesPerTes
 			logMessages.error = [];
 		}
 
-		logSpy = vitest.spyOn(console, 'log').mockImplementation((...args) => {
-			logMessages.log.push(args.map(maybeStringify).join(' '));
-		});
+		// Fresh mocks per test so `toHaveBeenCalledTimes` assertions are scoped
+		// to a single test without needing explicit `mockClear()` calls.
+		spies.stdout = vitest.fn();
+		spies.stderr = vitest.fn();
 
-		errorSpy = vitest.spyOn(console, 'error').mockImplementation((...args) => {
-			logMessages.error.push(args.map(maybeStringify).join(' '));
+		// Some commands still write directly via `console.log` / `console.error`
+		// (e.g. help rendering, raw JSON dumps). Mirror those calls into the
+		// same arrays/spies so tests don't need to care which path produced the
+		// output.
+		vitest.spyOn(console, 'log').mockImplementation((...args) => {
+			const combined = args.map(maybeStringify).join(' ');
+			logMessages.log.push(combined);
+			spies.stdout?.(combined);
+		});
+		vitest.spyOn(console, 'error').mockImplementation((...args) => {
+			const combined = args.map(maybeStringify).join(' ');
+			logMessages.error.push(combined);
+			spies.stderr?.(combined);
 		});
 	});
 
 	afterAll(() => {
-		// Return the logger to real process streams so post-suite teardown
-		// (and any subsequent suite that did not opt into the spy) writes to
-		// the real console.
-		logger.setStreams({ stdout: process.stdout, stderr: process.stderr });
+		// Return the global logger to its environment-appropriate defaults so
+		// subsequent suites (or post-suite teardown) don't inherit the capture
+		// outputs installed above.
+		logger.reset();
 	});
 
 	return {
 		logSpy() {
-			return logSpy;
+			return spies.stdout!;
 		},
 		errorSpy() {
-			return errorSpy;
+			return spies.stderr!;
 		},
 		logMessages,
 		lastLogMessage() {