feat(init): measure interactive prompt wait time (#1257)

## Summary

Separates human think-time from actual `sentry init` execution time.
Every real Ink prompt now emits a `ui.prompt` child span, while
automatic `--yes` and non-interactive paths remain uninstrumented.

The root transaction also gets an accumulated `wizard.user_wait_ms`
measurement, so active wizard time can be calculated as total duration
minus user wait. Workflow prompts include the active step ID (for
example `select-features`); welcome, git, and preflight prompts are
marked as `preflight`.

Feature selection now records `wizard.features.offered` before the
prompt and `wizard.features.selected` after the response. This preserves
the offered set even when the user cancels at the feature prompt or the
workflow fails later.

## Test plan

- `pnpm exec tsc --noEmit`
- `pnpm exec biome check src/lib/telemetry.ts
src/lib/init/interactive.ts src/lib/init/ui/ink-ui.ts
test/lib/telemetry.test.ts test/lib/init/interactive.test.ts
test/lib/init/ui/ink-ui-telemetry.test.ts`
- `pnpm vitest run test/lib/init`
- `pnpm vitest run test/lib/telemetry.test.ts`

Author: betegon

src/lib/init/interactive.ts

@@ -10,6 +10,7 @@
  * `LoggingUI` (CI / npm fallback).
  */
 
+import { setTag } from "@sentry/node-core/light";
 import chalk from "chalk";
 import { WizardError } from "../errors.js";
 import {
@@ -198,6 +199,7 @@ async function handleMultiSelect(
   }
   hints.push(`${bar}  ${chalk.dim("space=toggle, a=all, enter=confirm")}`);
 
+  setTag("wizard.features.offered", available.join(","));
   const selected = await ui.multiselect<string>({
     message: `${payload.prompt}\n${hints.join("\n")}`,
     options: optional.map((feature) => {
@@ -213,7 +215,9 @@ async function handleMultiSelect(
   });
 
   const chosen = abortIfCancelled(selected);
-  return { features: prependRequiredFeature(chosen, hasRequired) };
+  const features = prependRequiredFeature(chosen, hasRequired);
+  setTag("wizard.features.selected", features.join(","));
+  return { features };
 }
 
 async function handleConfirm(

src/lib/init/ui/ink-ui.ts

@@ -56,6 +56,10 @@ import { setTag } from "@sentry/node-core/light";
 import { FULL_BANNER_LINES } from "../../banner.js";
 import { CLI_VERSION } from "../../constants.js";
 import { stripAnsi } from "../../formatters/plain-detect.js";
+import {
+  createWizardPromptTelemetry,
+  type WizardPromptKind,
+} from "../../telemetry.js";
 import { formatFeedbackHint, type InitFeedbackOutcome } from "../feedback.js";
 import { formatFailureReport, formatSuccessReport } from "./ink-report.js";
 import { LEARN_SEQUENCE } from "./learn-content.js";
@@ -81,10 +85,16 @@ type CreateInkUIOptions = {
 
 type PendingWelcome = {
   promise: Promise<"continue" | Cancelled>;
+  tracedPromise?: Promise<"continue" | Cancelled>;
   resolve: (value: "continue" | Cancelled) => void;
   settled: boolean;
 };
 
+type InkPromptOptions = {
+  initialWelcome?: PendingWelcome;
+  telemetry?: ReturnType<typeof createWizardPromptTelemetry>;
+};
+
 /** Tip rotation cadence in the sidebar — slow enough to read each tip. */
 const TIP_ROTATE_INTERVAL_MS = 15_000;
 
@@ -273,6 +283,7 @@ export async function createInkUI(
   if (opts.initialWelcome && initialWelcome) {
     seedWelcomePrompt(store, opts.initialWelcome, initialWelcome);
   }
+  const promptTelemetry = createWizardPromptTelemetry();
 
   // Open a fresh /dev/tty so Ink's `readable` event listener
   // actually fires — see the module docstring for the Bun bug
@@ -305,7 +316,10 @@ export async function createInkUI(
   try {
     const instance = app.mountApp(store, renderOptions);
 
-    return new InkUI(instance, store, freshStdin, initialWelcome);
+    return new InkUI(instance, store, freshStdin, {
+      initialWelcome,
+      telemetry: promptTelemetry,
+    });
   } catch (error) {
     // Restore the terminal if Ink rendering or UI init fails,
     // otherwise the user is stuck in the alternate screen buffer.
@@ -356,6 +370,9 @@ export class InkUI implements WizardUI {
    * `process.stdin` in that case.
    */
   private readonly freshStdin: ReadStream | null;
+  private readonly promptTelemetry: ReturnType<
+    typeof createWizardPromptTelemetry
+  >;
   private tipTimer: ReturnType<typeof setInterval> | undefined;
   private learnTimer: ReturnType<typeof setInterval> | undefined;
 
@@ -401,13 +418,23 @@ export class InkUI implements WizardUI {
     instance: InkInstance,
     store: WizardStore,
     freshStdin: ReadStream | null,
-    initialWelcome?: PendingWelcome
+    promptOptions: InkPromptOptions = {}
   ) {
     this.instance = instance;
     this.store = store;
     this.freshStdin = freshStdin;
-    this.initialWelcome = initialWelcome;
-    if (initialWelcome && !initialWelcome.settled) {
+    this.initialWelcome = promptOptions.initialWelcome;
+    this.promptTelemetry =
+      promptOptions.telemetry ?? createWizardPromptTelemetry();
+    if (this.initialWelcome && !this.initialWelcome.tracedPromise) {
+      const initialWelcome = this.initialWelcome;
+      initialWelcome.tracedPromise = this.promptTelemetry.tracePrompt(
+        "welcome",
+        () => initialWelcome.promise
+      );
+    }
+    if (this.initialWelcome && !this.initialWelcome.settled) {
+      const initialWelcome = this.initialWelcome;
       this.activePromptCancel = () => {
         this.store.setPrompt(null);
         this.activePromptCancel = undefined;
@@ -469,6 +496,7 @@ export class InkUI implements WizardUI {
     stepId: string,
     status: "in_progress" | "completed" | "failed" | "skipped"
   ): void {
+    this.promptTelemetry.setActiveStep(stepId, status === "in_progress");
     this.store.setStepStatus(stepId, status);
   }
 
@@ -543,8 +571,16 @@ export class InkUI implements WizardUI {
 
   // ── Prompts ───────────────────────────────────────────────────────
 
+  /** Measures only the interval in which the prompt can accept user input. */
+  private waitForPrompt<T>(
+    kind: WizardPromptKind,
+    mount: (resolve: (value: T) => void) => void
+  ): Promise<T> {
+    return this.promptTelemetry.tracePrompt(kind, () => new Promise<T>(mount));
+  }
+
   select<T extends string>(opts: SelectOptions<T>): Promise<T | Cancelled> {
-    return new Promise((resolve) => {
+    return this.waitForPrompt<T | Cancelled>("select", (resolve) => {
       const initialIndex =
         opts.initialValue !== undefined
           ? Math.max(
@@ -584,7 +620,7 @@ export class InkUI implements WizardUI {
   multiselect<T extends string>(
     opts: MultiSelectOptions<T>
   ): Promise<T[] | Cancelled> {
-    return new Promise((resolve) => {
+    return this.waitForPrompt<T[] | Cancelled>("multiselect", (resolve) => {
       this.activePromptCancel = () => {
         this.store.setPrompt(null);
         this.activePromptCancel = undefined;
@@ -614,7 +650,7 @@ export class InkUI implements WizardUI {
   }
 
   confirm(opts: ConfirmOptions): Promise<boolean | Cancelled> {
-    return new Promise<boolean | Cancelled>((resolve) => {
+    return this.waitForPrompt<boolean | Cancelled>("confirm", (resolve) => {
       this.activePromptCancel = () => {
         this.store.setPrompt(null);
         this.activePromptCancel = undefined;
@@ -644,12 +680,19 @@ export class InkUI implements WizardUI {
       if (!this.initialWelcome.settled) {
         seedWelcomePrompt(this.store, opts, this.initialWelcome);
       }
-      return this.initialWelcome.promise.finally(() => {
+      const initialWelcome = this.initialWelcome;
+      const promptPromise =
+        initialWelcome.tracedPromise ??
+        this.promptTelemetry.tracePrompt(
+          "welcome",
+          () => initialWelcome.promise
+        );
+      return promptPromise.finally(() => {
         this.activePromptCancel = undefined;
         this.initialWelcome = undefined;
       });
     }
-    return new Promise<"continue" | Cancelled>((resolve) => {
+    return this.waitForPrompt<"continue" | Cancelled>("welcome", (resolve) => {
       this.activePromptCancel = () => {
         this.store.setPrompt(null);
         this.activePromptCancel = undefined;

src/lib/telemetry.ts

@@ -922,6 +922,73 @@ export function recordCacheHit(cacheName: string, hit: boolean): void {
   });
 }
 
+export type WizardPromptKind = "select" | "multiselect" | "confirm" | "welcome";
+
+type WizardPromptTelemetry = {
+  setActiveStep(stepId: string, active: boolean): void;
+  tracePrompt<T>(kind: WizardPromptKind, prompt: () => Promise<T>): Promise<T>;
+};
+
+/**
+ * Track time spent waiting for human input during `sentry init`.
+ *
+ * Prompt spans make user think-time visible in the trace instead of folding it
+ * into the top-level `sentry.init` duration. The measurement is accumulated on
+ * the root span so a run can be compared both with and without user wait time.
+ */
+export function createWizardPromptTelemetry(): WizardPromptTelemetry {
+  let activeStepId: string | undefined;
+  let totalWaitMs = 0;
+
+  return {
+    setActiveStep(stepId, active) {
+      if (active) {
+        activeStepId = stepId;
+      } else if (activeStepId === stepId) {
+        activeStepId = undefined;
+      }
+    },
+    tracePrompt(kind, prompt) {
+      const stepId = activeStepId;
+      return withTracingSpan(
+        `wizard.prompt.${kind}`,
+        "ui.prompt",
+        async (span) => {
+          const startedAt = performance.now();
+          try {
+            return await prompt();
+          } finally {
+            const waitMs = Math.max(0, performance.now() - startedAt);
+            totalWaitMs += waitMs;
+
+            span.setAttributes({
+              "wizard.user_wait_ms": waitMs,
+              "wizard.user_wait_total_ms": totalWaitMs,
+            });
+            Sentry.setMeasurement(
+              "wizard.user_wait_ms",
+              totalWaitMs,
+              "millisecond",
+              Sentry.getRootSpan(span)
+            );
+            Sentry.metrics.distribution("wizard.user_wait_ms", waitMs, {
+              attributes: {
+                prompt_kind: kind,
+                ...(stepId ? { workflow_step: stepId } : {}),
+              },
+            });
+          }
+        },
+        {
+          "wizard.prompt.kind": kind,
+          "wizard.prompt.phase": stepId ? "workflow" : "preflight",
+          ...(stepId ? { "wizard.step.id": stepId } : {}),
+        }
+      );
+    },
+  };
+}
+
 /**
  * Wrap an operation with a Sentry span for tracing.
  *

test/lib/init/interactive.test.ts

@@ -7,7 +7,9 @@
  * terminal.
  */
 
-import { describe, expect, test } from "vitest";
+// biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
+import * as Sentry from "@sentry/node-core/light";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { WizardError } from "../../../src/lib/errors.js";
 import { handleInteractive } from "../../../src/lib/init/interactive.js";
 import type { InteractiveContext } from "../../../src/lib/init/types.js";
@@ -24,6 +26,10 @@ function makeOptions(
   };
 }
 
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
 describe("handleInteractive dispatcher", () => {
   test("throws WizardError for unknown kind", async () => {
     const { ui } = createMockUI();
@@ -270,6 +276,36 @@ describe("handleSelect with --app flag", () => {
 });
 
 describe("handleMultiSelect", () => {
+  test("records offered and selected features for interactive prompts", async () => {
+    const setTagSpy = vi.spyOn(Sentry, "setTag");
+    const { ui, respond } = createMockUI();
+    respond.multiselect(["sessionReplay"]);
+
+    await handleInteractive(
+      {
+        type: "interactive",
+        prompt: "Select features",
+        kind: "multi-select",
+        availableFeatures: [
+          "errorMonitoring",
+          "performanceMonitoring",
+          "sessionReplay",
+        ],
+      },
+      makeOptions(),
+      ui
+    );
+
+    expect(setTagSpy).toHaveBeenCalledWith(
+      "wizard.features.offered",
+      "errorMonitoring,performanceMonitoring,sessionReplay"
+    );
+    expect(setTagSpy).toHaveBeenCalledWith(
+      "wizard.features.selected",
+      "errorMonitoring,sessionReplay"
+    );
+  });
+
   test("auto-selects all features with --yes", async () => {
     const { ui } = createMockUI();
     const result = await handleInteractive(
@@ -336,6 +372,7 @@ describe("handleMultiSelect", () => {
   });
 
   test("throws WizardCancelledError when user cancels multi-select", async () => {
+    const setTagSpy = vi.spyOn(Sentry, "setTag");
     const { ui, respond } = createMockUI();
     respond.multiselect(CANCELLED);
 
@@ -351,6 +388,14 @@ describe("handleMultiSelect", () => {
         ui
       )
     ).rejects.toThrow("Setup cancelled");
+    expect(setTagSpy).toHaveBeenCalledWith(
+      "wizard.features.offered",
+      "errorMonitoring,performanceMonitoring"
+    );
+    expect(setTagSpy).not.toHaveBeenCalledWith(
+      "wizard.features.selected",
+      expect.anything()
+    );
   });
 
   test("returns required feature without calling multiselect when only errorMonitoring available", async () => {