feat(telemetry): add Coder telemetry export command

Adds the "Coder: Export Telemetry" command that lets users save
recorded telemetry as a JSON array or an OTLP/JSON zip. The flow
prompts for a date range, a format, and a save location, then streams
events from the on-disk sink through the chosen writer inside a
cancellable progress notification.

TelemetryService gains public getContext() and flush() methods so the
command can attach an export-time snapshot to the OTLP zip and drain
pending events before listing files. #emit routes through getContext()
so the snapshot stays in sync with what events carry.

Flush and file-listing run inside withCancellableProgress so the
on-disk snapshot is taken right before streaming; the AbortSignal is
threaded through the event iterator and into the OTLP writer. Reveal
errors are swallowed locally so a missing revealFileInOS handler
(web/remote hosts) does not report "Telemetry export failed" after a
successful save. Writer failures show a single error notification
instead of re-throwing into the wrapping command.invoked trace (which
would leak the user's chosen save path via buildErrorBlock). Prompts
set ignoreFocusOut so an accidental focus loss does not silently
abort, and the custom-date prompt states the current UTC date
explicitly. The empty-events case removes the empty output file and
shows an info notification.

Adds unit tests for command orchestration, TelemetryService.getContext
/ flush, plus a Uri.fsPath getter on the vscode test mock so fsPath
template-literal interpolations stop rendering "undefined".

Author: EhabY

package.json

@@ -422,6 +422,11 @@
 				"title": "Coder: View Logs",
 				"icon": "$(list-unordered)"
 			},
+			{
+				"command": "coder.exportTelemetry",
+				"title": "Coder: Export Telemetry",
+				"icon": "$(save)"
+			},
 			{
 				"command": "coder.openAppStatus",
 				"title": "Open App Status",
@@ -536,6 +541,10 @@
 					"command": "coder.viewLogs",
 					"when": "true"
 				},
+				{
+					"command": "coder.exportTelemetry",
+					"when": "true"
+				},
 				{
 					"command": "coder.openAppStatus",
 					"when": "false"

src/commands.ts

@@ -26,6 +26,7 @@ import {
 	applySettingOverrides,
 } from "./remote/sshOverrides";
 import { resolveCliAuth } from "./settings/cli";
+import { runExportTelemetryCommand } from "./telemetry/export/command";
 import { toRemoteAuthority, toSafeHost } from "./util";
 import { vscodeProposed } from "./vscodeProposed";
 import { parseSpeedtestResult } from "./webviews/speedtest/types";
@@ -49,6 +50,7 @@ import type { SecretsManager } from "./core/secretsManager";
 import type { DeploymentManager } from "./deployment/deploymentManager";
 import type { Logger } from "./logging/logger";
 import type { LoginCoordinator } from "./login/loginCoordinator";
+import type { TelemetryService } from "./telemetry/service";
 import type { SpeedtestPanelFactory } from "./webviews/speedtest/speedtestPanelFactory";
 import type {
 	DuplicateWorkspaceIpc,
@@ -80,6 +82,7 @@ export class Commands {
 	private readonly loginCoordinator: LoginCoordinator;
 	private readonly duplicateWorkspaceIpc: DuplicateWorkspaceIpc;
 	private readonly speedtestPanelFactory: SpeedtestPanelFactory;
+	private readonly telemetryService: TelemetryService;
 
 	// These will only be populated when actively connected to a workspace and are
 	// used in commands.  Because commands can be executed by the user, it is not
@@ -97,6 +100,7 @@ export class Commands {
 		private readonly extensionClient: CoderApi,
 		private readonly deploymentManager: DeploymentManager,
 	) {
+		this.telemetryService = serviceContainer.getTelemetryService();
 		this.logger = serviceContainer.getLogger();
 		this.pathResolver = serviceContainer.getPathResolver();
 		this.mementoManager = serviceContainer.getMementoManager();
@@ -350,6 +354,15 @@ export class Commands {
 		});
 	}
 
+	public async exportTelemetry(): Promise<void> {
+		await runExportTelemetryCommand(
+			this.pathResolver.getTelemetryPath(),
+			this.logger,
+			() => this.telemetryService.flush(),
+			this.telemetryService.getContext(),
+		);
+	}
+
 	/**
 	 * View the logs for the currently connected workspace.
 	 */

src/core/commandManager.ts

@@ -20,6 +20,7 @@ export const CODER_COMMAND_IDS = [
 	"coder.navigateToWorkspaceSettings",
 	"coder.refreshWorkspaces",
 	"coder.viewLogs",
+	"coder.exportTelemetry",
 	"coder.searchMyWorkspaces",
 	"coder.searchAllWorkspaces",
 	"coder.manageCredentials",

src/extension.ts

@@ -295,6 +295,10 @@ async function doActivate(
 		void allWorkspacesProvider.fetchAndRefresh();
 	});
 	commandManager.register("coder.viewLogs", commands.viewLogs.bind(commands));
+	commandManager.register(
+		"coder.exportTelemetry",
+		commands.exportTelemetry.bind(commands),
+	);
 	commandManager.register("coder.searchMyWorkspaces", async () =>
 		showTreeViewSearch(MY_WORKSPACES_TREE_ID),
 	);

src/telemetry/export/command.ts

@@ -0,0 +1,306 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as vscode from "vscode";
+
+import { toError } from "../../error/errorUtils";
+import { withCancellableProgress } from "../../progress";
+
+import { listTelemetryFilesForRange, streamTelemetryEvents } from "./files";
+import {
+	TELEMETRY_RANGE_PRESETS,
+	createCustomDateRange,
+	createPresetDateRange,
+	validateUtcDateInput,
+	type TelemetryDateRange,
+	type TelemetryRangePresetId,
+} from "./range";
+import { writeJsonArrayExport } from "./writers/json";
+import { writeOtlpZipExport } from "./writers/otlp/writer";
+
+import type { Logger } from "../../logging/logger";
+import type { TelemetryContext, TelemetryEvent } from "../event";
+
+interface FormatPick extends vscode.QuickPickItem {
+	readonly id: "json" | "otlp";
+}
+
+interface RangePick extends vscode.QuickPickItem {
+	readonly id: TelemetryRangePresetId | "custom";
+}
+
+const FORMAT_PICKS: readonly FormatPick[] = [
+	{
+		id: "json",
+		label: "JSON array",
+		detail: "Single JSON document for human inspection or compliance review.",
+	},
+	{
+		id: "otlp",
+		label: "OTLP/JSON zip",
+		detail:
+			"Zip containing logs.json, traces.json, and metrics.json for OTLP endpoints.",
+	},
+];
+
+interface ExportSummary {
+	readonly filesScanned: number;
+	readonly eventCount: number;
+}
+
+export async function runExportTelemetryCommand(
+	telemetryDir: string,
+	logger: Logger,
+	flushTelemetry: () => Promise<void>,
+	context: TelemetryContext,
+): Promise<void> {
+	const range = await promptDateRange();
+	if (!range) {
+		return;
+	}
+	const format = await promptFormat();
+	if (!format) {
+		return;
+	}
+	const outputUri = await promptOutputUri(range, format.id);
+	if (!outputUri) {
+		return;
+	}
+
+	const onCleanupError = (err: unknown, tempPath: string): void => {
+		logger.warn("Failed to delete telemetry export temp file", tempPath, err);
+	};
+	const onStagingCleanupError = (err: unknown, dir: string): void => {
+		logger.warn(
+			"Failed to delete telemetry export staging directory",
+			dir,
+			err,
+		);
+	};
+
+	// Flush + list happen inside the progress callback so the snapshot of
+	// files-on-disk is taken right before streaming (closing the window during
+	// which the live sink could rotate a segment or cross UTC midnight), and so
+	// the user can cancel a long flush via the notification.
+	const result = await withCancellableProgress(
+		async ({ signal, progress }): Promise<ExportSummary> => {
+			progress.report({ message: "Flushing buffered events..." });
+			await flushTelemetry();
+			throwIfAborted(signal);
+
+			progress.report({ message: "Locating telemetry files..." });
+			const filePaths = await listTelemetryFilesForRange(telemetryDir, range);
+			if (filePaths.length === 0) {
+				return { filesScanned: 0, eventCount: 0 };
+			}
+
+			progress.report({ message: "Writing export..." });
+			const events = withCancellation(
+				streamTelemetryEvents(filePaths, range),
+				signal,
+			);
+			const eventCount = await writeExport(
+				format.id,
+				outputUri.fsPath,
+				events,
+				context,
+				onCleanupError,
+				onStagingCleanupError,
+				signal,
+			);
+			return { filesScanned: filePaths.length, eventCount };
+		},
+		{
+			location: vscode.ProgressLocation.Notification,
+			title: "Exporting Coder telemetry",
+			cancellable: true,
+		},
+	);
+
+	if (!result.ok) {
+		if (result.cancelled) {
+			return;
+		}
+		logger.error("Telemetry export failed", result.error);
+		vscode.window.showErrorMessage(
+			`Telemetry export failed: ${toError(result.error).message}`,
+		);
+		return;
+	}
+
+	const summary = result.value;
+	if (summary.filesScanned === 0) {
+		vscode.window.showInformationMessage(
+			`No telemetry files found for ${range.label}.`,
+		);
+		return;
+	}
+	if (summary.eventCount === 0) {
+		// The writer ran but no events matched the timestamp filter; remove the
+		// empty file so the user isn't left with an artifact they didn't ask for.
+		await fs
+			.rm(outputUri.fsPath, { force: true })
+			.catch((err) =>
+				logger.warn(
+					"Failed to remove empty telemetry export",
+					outputUri.fsPath,
+					err,
+				),
+			);
+		vscode.window.showInformationMessage(
+			`No telemetry events matched ${range.label}.`,
+		);
+		return;
+	}
+
+	const action = await vscode.window.showInformationMessage(
+		`Exported ${summary.eventCount} telemetry event(s) to ${outputUri.fsPath}.`,
+		"Reveal in File Explorer",
+	);
+	if (action === "Reveal in File Explorer") {
+		try {
+			await vscode.commands.executeCommand("revealFileInOS", outputUri);
+		} catch (err) {
+			// The export already succeeded; a reveal failure is informational.
+			logger.warn("Failed to reveal exported telemetry file", err);
+		}
+	}
+}
+
+async function writeExport(
+	formatId: FormatPick["id"],
+	outputPath: string,
+	events: AsyncIterable<TelemetryEvent>,
+	context: TelemetryContext,
+	onCleanupError: (err: unknown, tempPath: string) => void,
+	onStagingCleanupError: (err: unknown, dir: string) => void,
+	signal: AbortSignal,
+): Promise<number> {
+	if (formatId === "json") {
+		return writeJsonArrayExport(outputPath, events, onCleanupError);
+	}
+	const counts = await writeOtlpZipExport(
+		outputPath,
+		events,
+		context,
+		onCleanupError,
+		{ signal, onStagingCleanupError },
+	);
+	return counts.logs + counts.traces + counts.metrics;
+}
+
+/** Wraps an async iterable to honor an AbortSignal between yields. */
+async function* withCancellation<T>(
+	iterable: AsyncIterable<T>,
+	signal: AbortSignal,
+): AsyncIterable<T> {
+	for await (const item of iterable) {
+		throwIfAborted(signal);
+		yield item;
+	}
+}
+
+function throwIfAborted(signal: AbortSignal): void {
+	if (!signal.aborted) {
+		return;
+	}
+	const reason: unknown = signal.reason;
+	throw reason instanceof Error
+		? reason
+		: Object.assign(new Error("Aborted"), { name: "AbortError" });
+}
+
+async function promptDateRange(): Promise<TelemetryDateRange | undefined> {
+	const pick = await vscode.window.showQuickPick(
+		[
+			...TELEMETRY_RANGE_PRESETS.map(
+				(preset): RangePick => ({
+					id: preset.id,
+					label: preset.label,
+					detail: preset.detail,
+				}),
+			),
+			{
+				id: "custom",
+				label: "Custom range…",
+				detail: "Choose inclusive UTC start and end dates.",
+			} satisfies RangePick,
+		],
+		{
+			title: "Export Telemetry: Date Range",
+			placeHolder: "Select telemetry date range",
+			ignoreFocusOut: true,
+		},
+	);
+	if (!pick) {
+		return undefined;
+	}
+	if (pick.id === "custom") {
+		return promptCustomDateRange();
+	}
+	return createPresetDateRange(pick.id);
+}
+
+async function promptCustomDateRange(): Promise<
+	TelemetryDateRange | undefined
+> {
+	const todayUtc = new Date().toISOString().slice(0, 10);
+	const startDate = await vscode.window.showInputBox({
+		title: "Export Telemetry: Custom Start Date",
+		prompt: `Start date in UTC (YYYY-MM-DD). Today in UTC is ${todayUtc}; your local date may differ.`,
+		value: todayUtc,
+		validateInput: validateUtcDateInput,
+		ignoreFocusOut: true,
+	});
+	if (startDate === undefined) {
+		return undefined;
+	}
+
+	const endDate = await vscode.window.showInputBox({
+		title: "Export Telemetry: Custom End Date",
+		prompt: `End date in UTC (YYYY-MM-DD, inclusive). Today in UTC is ${todayUtc}.`,
+		value: startDate,
+		validateInput: (value) => {
+			const invalidDate = validateUtcDateInput(value);
+			if (invalidDate !== undefined) {
+				return invalidDate;
+			}
+			try {
+				createCustomDateRange(startDate, value);
+				return undefined;
+			} catch (err) {
+				return toError(err).message;
+			}
+		},
+		ignoreFocusOut: true,
+	});
+	if (endDate === undefined) {
+		return undefined;
+	}
+
+	return createCustomDateRange(startDate, endDate);
+}
+
+function promptFormat(): Thenable<FormatPick | undefined> {
+	return vscode.window.showQuickPick(FORMAT_PICKS, {
+		title: "Export Telemetry: Format",
+		placeHolder: "Select export format",
+		ignoreFocusOut: true,
+	});
+}
+
+function promptOutputUri(
+	range: TelemetryDateRange,
+	format: FormatPick["id"],
+): Thenable<vscode.Uri | undefined> {
+	const defaultName =
+		format === "json"
+			? `coder-telemetry-${range.filenamePart}.json`
+			: `coder-telemetry-${range.filenamePart}.otlp.zip`;
+	return vscode.window.showSaveDialog({
+		defaultUri: vscode.Uri.file(path.join(os.homedir(), defaultName)),
+		filters:
+			format === "json" ? { "JSON files": ["json"] } : { "Zip files": ["zip"] },
+		title: "Save Telemetry Export",
+	});
+}