Hide logs from startMixedModeSession (#9329)

* Hide logs from startMixedModeSession

* Add E2E test to verify no double logging

* Create selfish-numbers-play.md

* hide teardown logs

* add explanation

Author: penalosa

.changeset/selfish-numbers-play.md

@@ -0,0 +1,5 @@
+---
+"wrangler": patch
+---
+
+Hide logs in the `startMixedModeSession()` API

packages/wrangler/e2e/dev-mixed-mode.test.ts

@@ -3,6 +3,7 @@ import dedent from "ts-dedent";
 import { describe, expect, it } from "vitest";
 import { WranglerE2ETestHelper } from "./helpers/e2e-wrangler-test";
 import { fetchText } from "./helpers/fetch-text";
+import { normalizeOutput } from "./helpers/normalize";
 import { makeRoot, seed } from "./helpers/setup";
 
 describe("wrangler dev - mixed mode", () => {
@@ -92,6 +93,60 @@ describe("wrangler dev - mixed mode", () => {
 		`);
 	});
 
+	it("doesn't show any logs from startMixedModeSession()", async () => {
+		const helper = new WranglerE2ETestHelper();
+		await spawnLocalWorker(helper);
+		await helper.seed({
+			"wrangler.json": JSON.stringify({
+				name: "mixed-mode-mixed-bindings-test",
+				main: "index.js",
+				compatibility_date: "2025-05-07",
+				ai: {
+					binding: "AI",
+				},
+			}),
+			"index.js": dedent`
+							export default {
+								async fetch(request, env) {
+									const messages = [
+										{
+											role: "user",
+											// Doing snapshot testing against AI responses can be flaky, but this prompt generates the same output relatively reliably
+											content: "Respond with the exact text 'This is a response from Workers AI.'. Do not include any other text",
+										},
+									];
+
+									const { response } = await env.AI.run("@hf/thebloke/zephyr-7b-beta-awq", {
+										messages,
+									});
+
+									return new Response(\`REMOTE<AI>: \${response}\n\`);
+								}
+							}`,
+		});
+
+		const worker = helper.runLongLived("wrangler dev --x-mixed-mode");
+
+		const { url } = await worker.waitForReady();
+
+		await expect(fetchText(url)).resolves.toMatchInlineSnapshot(`
+			"REMOTE<AI>: "This is a response from Workers AI."
+			"
+		`);
+
+		// This should only include logs from the user Wrangler session (i.e. a single list of attached bindings, and only one ready message)
+		expect(normalizeOutput(worker.currentOutput)).toMatchInlineSnapshot(`
+			"Your Worker and resources are simulated locally via Miniflare. For more information, see: https://developers.cloudflare.com/workers/testing/local-development.
+			Your Worker has access to the following bindings:
+			- AI:
+			  - Name: AI [connected to remote resource]
+			[wrangler:inf] Ready on http://localhost:<PORT>
+			▲ [WARNING] Using Workers AI always accesses your Cloudflare account in order to run AI models, and so will incur usage charges even in local development.
+			⎔ Starting local server...
+			[wrangler:inf] GET / 200 OK (TIMINGS)"
+		`);
+	});
+
 	describe("multi-worker", () => {
 		it("handles both remote and local service bindings at the same time in all workers", async () => {
 			const helper = new WranglerE2ETestHelper();

packages/wrangler/e2e/helpers/normalize.ts

@@ -43,7 +43,7 @@ function stripEmptyNewlines(stdout: string): string {
 }
 
 function stripDevTimings(stdout: string): string {
-	return stdout.replace(/\(\dms\)/g, "(TIMINGS)");
+	return stdout.replace(/\(\d+ms\)/g, "(TIMINGS)");
 }
 
 function removeWorkerPreviewUrl(str: string) {

packages/wrangler/src/api/mixedMode/index.ts

@@ -45,6 +45,7 @@ export async function startMixedModeSession(
 			inspector: {
 				port: await getPort(),
 			},
+			logLevel: "none",
 		},
 		bindings: rawBindings,
 	});

packages/wrangler/src/api/startDevWorker/ConfigController.ts

@@ -13,7 +13,7 @@ import {
 import { getClassNamesWhichUseSQLite } from "../../dev/class-names-sqlite";
 import { getLocalPersistencePath } from "../../dev/get-local-persistence-path";
 import { UserError } from "../../errors";
-import { logger } from "../../logger";
+import { logger, runWithLogLevel } from "../../logger";
 import { checkTypesDiff } from "../../type-generation/helpers";
 import { requireApiToken, requireAuth } from "../../user";
 import {
@@ -418,7 +418,9 @@ export class ConfigController extends Controller<ConfigControllerEventMap> {
 	}
 
 	public set(input: StartDevWorkerInput, throwErrors = false) {
-		return this.#updateConfig(input, throwErrors);
+		return runWithLogLevel(input.dev?.logLevel, () =>
+			this.#updateConfig(input, throwErrors)
+		);
 	}
 	public patch(input: Partial<StartDevWorkerInput>) {
 		assert(
@@ -431,7 +433,9 @@ export class ConfigController extends Controller<ConfigControllerEventMap> {
 			...input,
 		};
 
-		return this.#updateConfig(config);
+		return runWithLogLevel(config.dev?.logLevel, () =>
+			this.#updateConfig(config)
+		);
 	}
 
 	async #updateConfig(input: StartDevWorkerInput, throwErrors = false) {

packages/wrangler/src/api/startDevWorker/DevEnv.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert";
 import { EventEmitter } from "node:events";
-import { logger } from "../../logger";
+import { logger, runWithLogLevel } from "../../logger";
 import { formatMessage, ParseError } from "../../parse";
 import { BundlerController } from "./BundlerController";
 import { ConfigController } from "./ConfigController";
@@ -94,23 +94,25 @@ export class DevEnv extends EventEmitter {
 	// *********************
 
 	async teardown() {
-		logger.debug("DevEnv teardown beginning...");
+		await runWithLogLevel(this.config.latestInput?.dev?.logLevel, async () => {
+			logger.debug("DevEnv teardown beginning...");
 
-		await Promise.all([
-			this.config.teardown(),
-			this.bundler.teardown(),
-			...this.runtimes.map((runtime) => runtime.teardown()),
-			this.proxy.teardown(),
-		]);
+			await Promise.all([
+				this.config.teardown(),
+				this.bundler.teardown(),
+				...this.runtimes.map((runtime) => runtime.teardown()),
+				this.proxy.teardown(),
+			]);
 
-		this.config.removeAllListeners();
-		this.bundler.removeAllListeners();
-		this.runtimes.forEach((runtime) => runtime.removeAllListeners());
-		this.proxy.removeAllListeners();
+			this.config.removeAllListeners();
+			this.bundler.removeAllListeners();
+			this.runtimes.forEach((runtime) => runtime.removeAllListeners());
+			this.proxy.removeAllListeners();
 
-		this.emit("teardown");
+			this.emit("teardown");
 
-		logger.debug("DevEnv teardown complete");
+			logger.debug("DevEnv teardown complete");
+		});
 	}
 
 	emitErrorEvent(ev: ErrorEvent) {

packages/wrangler/src/logger.ts

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { format } from "node:util";
 import chalk from "chalk";
 import CLITable from "cli-table3";
@@ -49,6 +50,22 @@ function getLoggerLevel(): LoggerLevel {
 	return "log";
 }
 
+const overrideLoggerLevel = new AsyncLocalStorage<{
+	logLevel: LoggerLevel | undefined;
+}>();
+
+/**
+ * This function runs a callback with a specified log level
+ * The provided log level is stored using AsyncLocalStorage, and will be used
+ * for all logger.* calls that happen within the callback.
+ */
+export const runWithLogLevel = <V>(
+	overrideLogLevel: LoggerLevel | undefined,
+	cb: () => V
+) => overrideLoggerLevel.run({ logLevel: overrideLogLevel }, cb);
+
+overrideLoggerLevel.getStore;
+
 export type TableRow<Keys extends string> = Record<Keys, string>;
 
 export class Logger {
@@ -58,7 +75,11 @@ export class Logger {
 	private onceHistory = new Set<string>();
 
 	get loggerLevel() {
-		return this.overrideLoggerLevel ?? getLoggerLevel();
+		return (
+			overrideLoggerLevel.getStore()?.logLevel ??
+			this.overrideLoggerLevel ??
+			getLoggerLevel()
+		);
 	}
 
 	set loggerLevel(val) {
@@ -106,10 +127,11 @@ export class Logger {
 		if (typeof console[method] !== "function") {
 			throw new Error(`console.${method}() is not a function`);
 		}
-
-		Logger.#beforeLogHook?.();
-		(console[method] as (...args: unknown[]) => unknown).apply(console, args);
-		Logger.#afterLogHook?.();
+		if (LOGGER_LEVELS[this.loggerLevel] !== LOGGER_LEVELS.none) {
+			Logger.#beforeLogHook?.();
+			(console[method] as (...args: unknown[]) => unknown).apply(console, args);
+			Logger.#afterLogHook?.();
+		}
 	}
 
 	get once() {