refactor(telemetry): simplify auth/workspace instrumentation

- workspace.ts: inline single-use transition helpers, unify on the
  spread idiom for optional `observedDurationMs`, move `performance.now()`
  below the dedup early-return, drop the no-op `() => fn()` wrapper in
  `traceUpdateTriggered`, and make `INITIAL_STATE` private.
- auth.ts: replace the `T extends LoginPromptResult` constraint with a
  `LoginPromptTracer` exposing `markAborted()`, matching the
  `RemoteSetupTracer` pattern. Callers now drive abort signaling, so
  telemetry no longer depends on `LoginResult`'s shape.
- loginCoordinator: call `tracer.markAborted()` on `!result.success`.

Author: EhabY

src/instrumentation/auth.ts

@@ -10,8 +10,9 @@ export type AuthIntercept401Recovery =
 	| "none";
 export type AuthLoginPromptTrigger = "auth_required" | "missing_session";
 
-interface LoginPromptResult {
-	readonly success: boolean;
+/** Helpers scoped to the auth.login_prompt trace's lifetime. */
+export interface LoginPromptTracer {
+	markAborted(): void;
 }
 
 export class AuthTelemetry {
@@ -30,19 +31,13 @@ export class AuthTelemetry {
 		this.telemetry.log("auth.intercept_401", { recovery });
 	}
 
-	public traceLoginPrompt<T extends LoginPromptResult>(
+	public traceLoginPrompt<T>(
 		trigger: AuthLoginPromptTrigger,
-		fn: () => Promise<T>,
+		fn: (tracer: LoginPromptTracer) => Promise<T>,
 	): Promise<T> {
 		return this.telemetry.trace(
 			"auth.login_prompt",
-			async (span) => {
-				const result = await fn();
-				if (!result.success) {
-					span.markAborted();
-				}
-				return result;
-			},
+			(span) => fn({ markAborted: () => span.markAborted() }),
 			{ trigger },
 		);
 	}

src/instrumentation/workspace.ts

@@ -4,35 +4,14 @@ import {
 } from "../telemetry/reporter";
 
 import type {
-	BuildReason,
 	Workspace,
 	WorkspaceAgent,
 	WorkspaceAgentLifecycle,
 	WorkspaceAgentStatus,
 	WorkspaceStatus,
-	WorkspaceTransition,
 } from "coder/site/src/api/typesGenerated";
 
-export const INITIAL_STATE = "unknown";
-
-type InitialState = typeof INITIAL_STATE;
-
-interface WorkspaceStateTransition {
-	readonly from: WorkspaceStatus | InitialState;
-	readonly to: WorkspaceStatus;
-	readonly transition?: WorkspaceTransition;
-	readonly reason?: BuildReason;
-	readonly observedDurationMs?: number;
-}
-
-interface WorkspaceAgentStateTransition {
-	readonly agentName: string;
-	readonly fromStatus: WorkspaceAgentStatus | InitialState;
-	readonly toStatus: WorkspaceAgentStatus;
-	readonly fromLifecycleState: WorkspaceAgentLifecycle | InitialState;
-	readonly toLifecycleState: WorkspaceAgentLifecycle;
-	readonly observedDurationMs?: number;
-}
+const INITIAL_STATE = "unknown";
 
 interface ObservedWorkspaceState {
 	readonly status: WorkspaceStatus;
@@ -55,42 +34,50 @@ export class WorkspaceTelemetry {
 
 	public observeWorkspace(workspace: Workspace): void {
 		const status = workspace.latest_build.status;
-		const now = performance.now();
 		const previous = this.observedWorkspaceState;
 		if (previous?.status === status) {
 			return;
 		}
+		const now = performance.now();
 
-		this.workspaceStateTransition({
-			from: previous?.status ?? INITIAL_STATE,
-			to: status,
-			transition: workspace.latest_build.transition,
-			reason: workspace.latest_build.reason,
-			...(previous && {
-				observedDurationMs: now - previous.observedAtMs,
-			}),
-		});
+		this.telemetry.log(
+			"workspace.state_transitioned",
+			{
+				from: previous?.status ?? INITIAL_STATE,
+				to: status,
+				...(workspace.latest_build.transition && {
+					transition: workspace.latest_build.transition,
+				}),
+				...(workspace.latest_build.reason && {
+					reason: workspace.latest_build.reason,
+				}),
+			},
+			previous ? { observedDurationMs: now - previous.observedAtMs } : {},
+		);
 		this.observedWorkspaceState = { status, observedAtMs: now };
 	}
 
 	public observeAgent(agent: WorkspaceAgent): void {
-		const now = performance.now();
 		const previous = this.observedAgentState;
 		if (
 			previous?.status === agent.status &&
 			previous.lifecycleState === agent.lifecycle_state
 		) {
 			return;
 		}
+		const now = performance.now();
 
-		this.agentStateTransition({
-			agentName: agent.name,
-			fromStatus: previous?.status ?? INITIAL_STATE,
-			toStatus: agent.status,
-			fromLifecycleState: previous?.lifecycleState ?? INITIAL_STATE,
-			toLifecycleState: agent.lifecycle_state,
-			...(previous && { observedDurationMs: now - previous.observedAtMs }),
-		});
+		this.telemetry.log(
+			"workspace.agent.state_transitioned",
+			{
+				agentName: agent.name,
+				fromStatus: previous?.status ?? INITIAL_STATE,
+				toStatus: agent.status,
+				fromLifecycleState: previous?.lifecycleState ?? INITIAL_STATE,
+				toLifecycleState: agent.lifecycle_state,
+			},
+			previous ? { observedDurationMs: now - previous.observedAtMs } : {},
+		);
 		this.observedAgentState = {
 			status: agent.status,
 			lifecycleState: agent.lifecycle_state,
@@ -102,40 +89,7 @@ export class WorkspaceTelemetry {
 		this.observedAgentState = undefined;
 	}
 
-	private workspaceStateTransition(transition: WorkspaceStateTransition): void {
-		this.telemetry.log(
-			"workspace.state_transitioned",
-			{
-				from: transition.from,
-				to: transition.to,
-				...(transition.transition && { transition: transition.transition }),
-				...(transition.reason && { reason: transition.reason }),
-			},
-			transition.observedDurationMs === undefined
-				? {}
-				: { observedDurationMs: transition.observedDurationMs },
-		);
-	}
-
-	private agentStateTransition(
-		transition: WorkspaceAgentStateTransition,
-	): void {
-		this.telemetry.log(
-			"workspace.agent.state_transitioned",
-			{
-				agentName: transition.agentName,
-				fromStatus: transition.fromStatus,
-				toStatus: transition.toStatus,
-				fromLifecycleState: transition.fromLifecycleState,
-				toLifecycleState: transition.toLifecycleState,
-			},
-			transition.observedDurationMs === undefined
-				? {}
-				: { observedDurationMs: transition.observedDurationMs },
-		);
-	}
-
 	public traceUpdateTriggered<T>(fn: () => Promise<T>): Promise<T> {
-		return this.telemetry.trace("workspace.update.triggered", () => fn());
+		return this.telemetry.trace("workspace.update.triggered", fn);
 	}
 }

src/login/loginCoordinator.ts

@@ -99,7 +99,13 @@ export class LoginCoordinator implements vscode.Disposable {
 	): Promise<LoginResult> {
 		return this.authTelemetry.traceLoginPrompt(
 			options.trigger ?? "auth_required",
-			() => this.performLoginDialog(options),
+			async (tracer) => {
+				const result = await this.performLoginDialog(options);
+				if (!result.success) {
+					tracer.markAborted();
+				}
+				return result;
+			},
 		);
 	}