feat(logging): tag logs with a per-session ID (#1073)

## What

Introduce a per-session identifier and make the extension tag every log
line with it, so all logs for a session can be correlated by searching a
single ID.

This is **Phase 1 of 3** for
[DEVEX-661](https://linear.app/codercom/issue/DEVEX-661) — "VS Code: add
`session_id` to all requests, logs, existing telemetry, and CLI
invocations".

## Changes

- Add `SessionLogger` (`src/logging/sessionLogger.ts`) — a `Logger` that
wraps the Coder output channel and prefixes every message with
`[<sessionId>]`.
- Generate the session ID once in `ServiceContainer` (reusing the
existing `newSessionId()` that already backs the telemetry session, so
logs, telemetry, requests, and the CLI all share one ID), and expose it
via `getSessionId()` for the later phases.

Because every service already receives `Logger` by injection,
session-tagged logging propagates with no call-site changes.

## Design notes

The code owner (Ehab) suggested composing the session ID and the VS Code
logger inside `container.ts`'s `ServiceContainer`; this PR follows that
approach. The telemetry `sessionId` from `newSessionId()` *is* the RFC
`session_id` (confirmed with Ehab — reuse it rather than minting a
second ID).

## Testing

- `pnpm typecheck`, targeted `pnpm lint`, and `pnpm test:extension`
(full suite: 2108 passing).
- New unit tests for `SessionLogger` prefixing and argument forwarding.

<details>
<summary>Implementation plan (DEVEX-661)</summary>

Thread a single per-session identifier (16-byte / 32-char lowercase hex)
so that
logs, API requests, existing telemetry, and the CLI `ssh` invocation the
extension drives can all be correlated by one `session_id`.

**In-scope RFC requirements**

| Req | Summary | Where |
| --- | ------- | ----- |
| 1 | Generate 16-byte / 32-hex session ID | Reuse existing
`newSessionId()` |
| 2 | Session ID on every client log | Phase 1 (this PR) |
| 3 | `session_id` on every API request via baggage | Phase 2 |
| 4.2 | `session_id` on VS Code telemetry | Phase 2 (already covered by
reusing the ID) |
| 5.2/5.3 | `CODER_TRACE_SESSION_ID` via `process.env` + terminal env
collection | Phase 2 |
| 7 | Log workspace/agent/lifecycle state changes at `info` | Phase 3 |
| 16 | Default `--log-dir` + old-log cleanup | Already implemented —
verify only |

**Out of scope:** coderd tracing middleware (req 6),
agent/coordination-protocol
changes and the CLI `ssh` subcommand behavior (reqs 8–15) live in
`coder/coder`.
Req 13 (in-memory log buffer flushed on connection failure) is deferred
to a
follow-up.

**Key decisions**

- D1 (resolved): the telemetry `sessionId` *is* the RFC `session_id` —
one ID,
  generated once in `ServiceContainer`.
- D2: session scope is per activation; Remote-SSH opens each workspace
in a fresh
  activation, so container-scoped ≈ per-connection.
- D3 (resolved): prefix every log line with the full 32-hex ID as
  `[<sessionId>] <message>`.
- D4: `baggage: session_id=<hex>` header.

**Phases**

1. Session ID + `SessionLogger` composition in the container (this PR).
2. Thread the ID to API requests (baggage), telemetry (already covered),
and the
   CLI via `CODER_TRACE_SESSION_ID` on `process.env` + the terminal env
   collection.
3. Log workspace / agent / lifecycle state transitions at `info`.

</details>

---

🤖 Generated by Coder Agents.

Author: aqandrew

src/core/container.ts

@@ -1,6 +1,8 @@
 import * as vscode from "vscode";
 
 import { AuthTelemetry } from "../instrumentation/auth";
+import { prefixLogger } from "../logging/prefixLogger";
+import { shortId } from "../logging/utils";
 import { LoginCoordinator } from "../login/loginCoordinator";
 import { OAuthCallback } from "../oauth/oauthCallback";
 import { buildSession, extractExtensionVersion } from "../telemetry/event";
@@ -26,7 +28,9 @@ import type { Logger } from "../logging/logger";
  * Centralizes the creation and management of all core services.
  */
 export class ServiceContainer implements vscode.Disposable {
-	private readonly logger: vscode.LogOutputChannel;
+	private readonly outputChannel: vscode.LogOutputChannel;
+	private readonly sessionId: string;
+	private readonly logger: Logger;
 	private readonly pathResolver: PathResolver;
 	private readonly mementoManager: MementoManager;
 	private readonly secretsManager: SecretsManager;
@@ -42,7 +46,16 @@ export class ServiceContainer implements vscode.Disposable {
 	private readonly commandManager: CommandManager;
 
 	constructor(context: vscode.ExtensionContext) {
-		this.logger = vscode.window.createOutputChannel("Coder", { log: true });
+		this.outputChannel = vscode.window.createOutputChannel("Coder", {
+			log: true,
+		});
+		// One session ID per activation, shared by logs, API requests,
+		// telemetry, and the CLI so all data for a session correlates.
+		this.sessionId = newSessionId();
+		this.logger = prefixLogger(
+			this.outputChannel,
+			`[session ${shortId(this.sessionId)}]`,
+		);
 		this.pathResolver = new PathResolver(
 			context.globalStorageUri.fsPath,
 			context.logUri.fsPath,
@@ -56,7 +69,7 @@ export class ServiceContainer implements vscode.Disposable {
 
 		const session = buildSession(
 			extractExtensionVersion(context.extension.packageJSON),
-			newSessionId(),
+			this.sessionId,
 		);
 		const localJsonlSink = LocalJsonlSink.start(
 			{
@@ -187,7 +200,7 @@ export class ServiceContainer implements vscode.Disposable {
 		try {
 			await this.telemetryService.dispose();
 		} finally {
-			this.logger.dispose();
+			this.outputChannel.dispose();
 		}
 	}
 }

src/logging/httpLogger.ts

@@ -45,7 +45,7 @@ export function logRequest(
 	const { requestId, method, url, requestSize } = parseConfig(config);
 
 	const msg = [
-		`→ ${shortId(requestId)} ${method} ${url} ${requestSize}`,
+		`→ [request ${shortId(requestId)}] ${method} ${url} ${requestSize}`,
 		...buildExtraLogs(
 			config.headers,
 			config.data,
@@ -73,7 +73,7 @@ export function logResponse(
 	);
 
 	const msg = [
-		`← ${shortId(requestId)} ${response.status} ${method} ${url} ${responseSize} ${time}`,
+		`← [request ${shortId(requestId)}] ${response.status} ${method} ${url} ${responseSize} ${time}`,
 		...buildExtraLogs(
 			response.headers,
 			response.data,
@@ -115,7 +115,7 @@ export function logError(
 				);
 			}
 
-			logPrefix = `← ${shortId(requestId)} ${error.response.status} ${method} ${url} ${time}`;
+			logPrefix = `← [request ${shortId(requestId)}] ${error.response.status} ${method} ${url} ${time}`;
 			extraLines = buildExtraLogs(
 				error.response.headers,
 				error.response.data,
@@ -126,7 +126,7 @@ export function logError(
 			if (errorParts.length === 0) {
 				errorParts.push(error.code || "Network error");
 			}
-			logPrefix = `✗ ${shortId(requestId)} ${method} ${url} ${time}`;
+			logPrefix = `✗ [request ${shortId(requestId)}] ${method} ${url} ${time}`;
 			extraLines = buildExtraLogs(
 				error?.config?.headers ?? {},
 				error.config?.data,

src/logging/prefixLogger.ts

@@ -0,0 +1,18 @@
+import type { Logger } from "./logger";
+
+/**
+ * Wraps a {@link Logger} so every message is prefixed, letting all lines that
+ * share a prefix (a session ID, a workspace name) be found with one search.
+ * Extra arguments are forwarded untouched.
+ */
+export function prefixLogger(inner: Logger, prefix: string): Logger {
+	const tag = (message: string) => `${prefix} ${message}`;
+	return {
+		trace: (message, ...args) => inner.trace(tag(message), ...args),
+		debug: (message, ...args) => inner.debug(tag(message), ...args),
+		info: (message, ...args) => inner.info(tag(message), ...args),
+		warn: (message, ...args) => inner.warn(tag(message), ...args),
+		error: (message, ...args) => inner.error(tag(message), ...args),
+		show: () => inner.show(),
+	};
+}

test/unit/logging/httpLogger.test.ts

@@ -72,6 +72,40 @@ describe("REST HTTP Logger", () => {
 		});
 	});
 
+	describe("request identifiers", () => {
+		const REQUEST_ID = "abcdef1234567890abcdef1234567890";
+		const config = {
+			method: "GET",
+			url: "https://api.example.com/endpoint",
+			headers: {} as unknown as AxiosHeaders,
+			metadata: { requestId: REQUEST_ID, startedAt: Date.now() },
+		} as RequestConfigWithMeta;
+
+		it("labels the shortened request ID on requests", () => {
+			const logger = createMockLogger();
+
+			logRequest(logger, config, HttpClientLogLevel.BASIC);
+
+			expect(logger.trace).toHaveBeenCalledWith(
+				expect.stringContaining("[request abcdef12]"),
+			);
+		});
+
+		it("labels the shortened request ID on responses", () => {
+			const logger = createMockLogger();
+
+			logResponse(
+				logger,
+				{ status: 200, config, headers: {}, data: {} } as AxiosResponse,
+				HttpClientLogLevel.BASIC,
+			);
+
+			expect(logger.trace).toHaveBeenCalledWith(
+				expect.stringContaining("[request abcdef12]"),
+			);
+		});
+	});
+
 	describe("error handling", () => {
 		it("distinguishes between network errors and response errors", () => {
 			const logger = createMockLogger();

test/unit/logging/prefixLogger.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import { prefixLogger } from "@/logging/prefixLogger";
+
+import { createMockLogger } from "../../mocks/testHelpers";
+
+const PREFIX = "[0123456789abcdef0123456789abcdef]";
+
+describe("prefixLogger", () => {
+	it("prefixes every level with the given prefix", () => {
+		const inner = createMockLogger();
+		const logger = prefixLogger(inner, PREFIX);
+
+		logger.trace("trace msg");
+		logger.debug("debug msg");
+		logger.info("info msg");
+		logger.warn("warn msg");
+		logger.error("error msg");
+
+		expect(inner.trace).toHaveBeenCalledWith(`${PREFIX} trace msg`);
+		expect(inner.debug).toHaveBeenCalledWith(`${PREFIX} debug msg`);
+		expect(inner.info).toHaveBeenCalledWith(`${PREFIX} info msg`);
+		expect(inner.warn).toHaveBeenCalledWith(`${PREFIX} warn msg`);
+		expect(inner.error).toHaveBeenCalledWith(`${PREFIX} error msg`);
+	});
+
+	it("forwards additional arguments unchanged", () => {
+		const inner = createMockLogger();
+		const logger = prefixLogger(inner, PREFIX);
+		const err = new Error("boom");
+
+		logger.error("failed", err, 42);
+
+		expect(inner.error).toHaveBeenCalledWith(`${PREFIX} failed`, err, 42);
+	});
+
+	it("delegates show() to the underlying logger", () => {
+		const inner = createMockLogger();
+		const logger = prefixLogger(inner, PREFIX);
+
+		logger.show();
+
+		expect(inner.show).toHaveBeenCalledOnce();
+	});
+});