feat(webapp): turn on progressive trace loading and trace API paging for everyone

The run page now loads large traces progressively and updates live runs
incrementally, and the run trace API can page large traces with
`page[size]` and `page[after]`.

Mono-RevId: 928f7102a88b948176d94a9da1f0420866aa5193

Author: Mariefay

.server-changes/progressive-trace-loading.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+The run page now loads large traces progressively and updates live runs incrementally, so big traces open faster and open run pages no longer reload the whole trace while a run is executing. The run trace API can also page large traces.

apps/webapp/app/presenters/v3/RunPresenter.server.ts

@@ -6,8 +6,6 @@ import type { SpanSummary } from "~/v3/eventRepository/eventRepository.types";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
 import { isFinalRunStatus } from "~/v3/taskStatus";
 import { env } from "~/env.server";
-import { FEATURE_FLAG } from "~/v3/featureFlags";
-import { makeFlag } from "~/v3/featureFlags.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { canLiveTail } from "./liveTailGate";
 import { assembleFirstTraceChunk, type TraceReadScope } from "./traceFirstChunk.server";
@@ -131,7 +129,7 @@ export class RunPresenter {
         slug: projectSlug,
         organization: { members: { some: { userId } } },
       },
-      select: { id: true, organization: { select: { featureFlags: true } } },
+      select: { id: true },
     });
 
     if (!authorizedProject) {
@@ -209,31 +207,20 @@ export class RunPresenter {
       ? millisecondsToNanoseconds(run.startedAt.getTime() - triggeredAt.getTime())
       : undefined;
 
-    const orgFeatureFlags =
-      (authorizedProject.organization?.featureFlags as Record<string, unknown>) ?? {};
-
     // Read before the first chunk so the first tail covers the background load.
     const firstChunkReadAt = Date.now();
 
-    const progressivePromise = makeFlag(this.#prismaClient)({
-      key: FEATURE_FLAG.progressiveTraceLoadingEnabled,
-      defaultValue: false,
-      overrides: orgFeatureFlags,
-    });
-
-    const firstChunkPromise = progressivePromise.then((progressiveEnabled) =>
-      progressiveEnabled && canLiveTail(run.taskEventStore, env.TRACE_VIEW_EMERGENCY_SPAN_CAP)
-        ? repository.getTraceChunk(
-            getTaskEventStoreTableForRun(run),
-            environment.id,
-            run.traceId,
-            traceTimeBounds.startCreatedAt,
-            traceTimeBounds.endCreatedAt,
-            undefined,
-            { includeDebugLogs: showDebug }
-          )
-        : undefined
-    );
+    const firstChunkPromise = canLiveTail(run.taskEventStore, env.TRACE_VIEW_EMERGENCY_SPAN_CAP)
+      ? repository.getTraceChunk(
+          getTaskEventStoreTableForRun(run),
+          environment.id,
+          run.traceId,
+          traceTimeBounds.startCreatedAt,
+          traceTimeBounds.endCreatedAt,
+          undefined,
+          { includeDebugLogs: showDebug }
+        )
+      : Promise.resolve(undefined);
 
     const [user, firstChunk] = await Promise.all([
       this.#prismaClient.user.findFirst({

apps/webapp/app/routes/api.v1.runs.$runId.trace.ts

@@ -13,8 +13,6 @@ import {
   getTraceStartTimeEnd,
 } from "~/v3/eventRepository/traceInsertedAtBound";
 import { getRunTracePage } from "~/v3/eventRepository/runTracePage.server";
-import { FEATURE_FLAG } from "~/v3/featureFlags";
-import { makeFlag } from "~/v3/featureFlags.server";
 import { toPageSpan } from "~/v3/eventRepository/tracePage";
 import {
   DEFAULT_TRACE_PAGE_SIZE,
@@ -97,10 +95,7 @@ export const loader = createLoaderApiRoute(
   async ({ resource: resolved, authentication, request }) => {
     const searchParams = new URL(request.url).searchParams;
 
-    if (
-      hasPageParams(searchParams) &&
-      (await isTracePagingEnabled(authentication.environment.organization.featureFlags))
-    ) {
+    if (hasPageParams(searchParams)) {
       const pageRequest = parseTracePageRequest(searchParams, DEFAULT_TRACE_PAGE_SIZE);
       if (pageRequest.isErr()) {
         return json({ error: PAGE_REQUEST_ERRORS[pageRequest.error] }, { status: 400 });
@@ -157,15 +152,6 @@ function hasPageParams(searchParams: URLSearchParams): boolean {
   return searchParams.has("page[size]") || searchParams.has("page[after]");
 }
 
-// Off: page parameters are ignored and the request gets today's tree response.
-function isTracePagingEnabled(orgFeatureFlags: unknown): Promise<boolean> {
-  return makeFlag()({
-    key: FEATURE_FLAG.publicTracePagingEnabled,
-    defaultValue: false,
-    overrides: (orgFeatureFlags as Record<string, unknown>) ?? {},
-  });
-}
-
 const PAGE_REQUEST_ERRORS = {
   invalid_page_size: "page[size] must be a positive integer",
   invalid_cursor: "page[after] is not a valid cursor; pass back pagination.next unchanged",

apps/webapp/app/v3/featureFlags.ts

@@ -59,8 +59,6 @@ export const FEATURE_FLAG = {
   apiRateLimitMetricsEnabled: "apiRateLimitMetricsEnabled",
   queueArchivingEnabled: "queueArchivingEnabled",
   supportAccessSettingsEnabled: "supportAccessSettingsEnabled",
-  progressiveTraceLoadingEnabled: "progressiveTraceLoadingEnabled",
-  publicTracePagingEnabled: "publicTracePagingEnabled",
   runTokenInjection: "runTokenInjection",
 } as const;
 
@@ -235,9 +233,6 @@ export const FeatureFlagCatalog = {
   // Shows the org Support Access settings page. Off until every webapp enforces the setting;
   // the org override wins over the global value.
   [FEATURE_FLAG.supportAccessSettingsEnabled]: z.boolean(),
-  [FEATURE_FLAG.progressiveTraceLoadingEnabled]: z.boolean(),
-  // Page parameters on the public trace API. Off: they're ignored and the tree is returned.
-  [FEATURE_FLAG.publicTracePagingEnabled]: z.boolean(),
   // Injects a signed per-attempt TRIGGER_RUN_TOKEN into deployed runs. Org override wins over
   // the global value. Requires RUN_TOKEN_ISSUER_URL and an active internal run signing key.
   [FEATURE_FLAG.runTokenInjection]: z.boolean(),

docs/management/runs/retrieve-trace.mdx

@@ -3,8 +3,6 @@ title: "Retrieve run trace"
 openapi: "v3-openapi GET /api/v1/runs/{runId}/trace"
 ---
 
-import { RollingOut } from "/snippets/feature-status.jsx";
-
 Returns the OpenTelemetry trace subtree for the run you request. The response `trace.rootSpan` is that run's span — not necessarily the trace-wide root — with its descendant spans nested under `children`.
 
 For a child or nested run inside a large trace, this endpoint scopes the tree to that run so you still get a useful subtree even when the full trace has more spans than the platform can return in one response.
@@ -13,8 +11,6 @@ For a finished run, spans that finish more than 7 days after the run are returne
 
 ## Page large traces
 
-<RollingOut flag="publicTracePagingEnabled" />
-
 The tree response stops at a size limit. To get every span of a large trace, page it: send `page[size]` (1,000–10,000) on the first request, then pass each response's `pagination.next` back as `page[after]` until it's absent.
 
 ```ts Your backend code