fix(webapp): treat final runs without completedAt as finished

Some cancelled runs never get a completion time. Their run page now
stops live-updating once they're done, and their trace reads stop
shortly after the run's last update instead of scanning up to the
present.

Mono-RevId: da61b00e64a77644ae169308b445dfbf8c3ae0ef

Author: Mariefay

.server-changes/cancelled-run-page-stops-live-updates.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: fix
+---
+
+Fix the run page continuing to live-update forever for some cancelled runs. These runs now show as finished, and loading their trace is faster.

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

@@ -15,6 +15,7 @@ import { applyAncestorOverrides, buildTraceView } from "~/v3/eventRepository/tra
 import { runStore } from "~/v3/runStore.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
 import { runTriggeredAt } from "~/v3/runTimestamps";
+import { getRunFinishedAt, getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 
 export class RunEnvironmentMismatchError extends Error {
   constructor(message: string) {
@@ -97,6 +98,7 @@ export class RunPresenter {
           queueTimestamp: true,
           scheduleId: true,
           completedAt: true,
+          updatedAt: true,
           logsDeletedAt: true,
           annotations: true,
           rootTaskRun: {
@@ -166,6 +168,7 @@ export class RunPresenter {
       isFinished: isFinalRunStatus(run.status),
       startedAt: run.startedAt,
       completedAt: run.completedAt,
+      finishedAt: getRunFinishedAt(run) ?? null,
       logsDeletedAt: showDeletedLogs ? null : run.logsDeletedAt,
       rootTaskRun: run.rootTaskRun,
       parentTaskRun: run.parentTaskRun,
@@ -195,7 +198,7 @@ export class RunPresenter {
     // A child view only reads its own lifetime, not the root's.
     const traceTimeBounds = {
       startCreatedAt: run.createdAt,
-      endCreatedAt: run.completedAt ?? undefined,
+      endCreatedAt: getTraceStartTimeEnd(run),
     };
 
     // Resolve agent-kind once so the tree renderer can swap icon/colour for

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

@@ -52,6 +52,7 @@ import {
   type ResolvedRunLockedWorker,
 } from "~/v3/runOpsMigration/controlPlaneResolver.server";
 import type { AuthenticatedEnvironment } from "@trigger.dev/core/v3/auth/environment";
+import { getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 
 export type PromptSpanData = {
   slug: string;
@@ -158,8 +159,10 @@ export class SpanPresenter extends BasePresenter {
           runtimeEnvironmentId: true,
           projectId: true,
           taskEventStore: true,
+          status: true,
           createdAt: true,
           completedAt: true,
+          updatedAt: true,
         },
       },
       this._prisma
@@ -227,7 +230,7 @@ export class SpanPresenter extends BasePresenter {
       environmentId: parentRun.runtimeEnvironmentId,
       projectId: parentRun.projectId,
       createdAt: parentRun.createdAt,
-      completedAt: parentRun.completedAt,
+      endCreatedAt: getTraceStartTimeEnd(parentRun),
       eventRepository: repository,
       showDebug,
     });
@@ -693,7 +696,7 @@ export class SpanPresenter extends BasePresenter {
     environmentId,
     projectId,
     createdAt,
-    completedAt,
+    endCreatedAt,
     showDebug,
   }: {
     eventRepository: IEventRepository;
@@ -703,7 +706,7 @@ export class SpanPresenter extends BasePresenter {
     projectId: string;
     eventStore: TaskEventStoreTable;
     createdAt: Date;
-    completedAt: Date | null;
+    endCreatedAt: Date | undefined;
     showDebug: boolean;
   }) {
     const span = await eventRepository.getSpan(
@@ -712,7 +715,7 @@ export class SpanPresenter extends BasePresenter {
       spanId,
       traceId,
       createdAt,
-      completedAt ?? undefined,
+      endCreatedAt,
       { includeDebugLogs: showDebug }
     );
 

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

@@ -5,6 +5,7 @@ import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
 import { runStore } from "~/v3/runStore.server";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
+import { getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 
 export class TraceChunkPresenter {
   #prismaClient: PrismaClient;
@@ -47,7 +48,9 @@ export class TraceChunkPresenter {
           createdAt: true,
           taskEventStore: true,
           traceId: true,
+          status: true,
           completedAt: true,
+          updatedAt: true,
           logsDeletedAt: true,
           runtimeEnvironmentId: true,
         },
@@ -91,7 +94,7 @@ export class TraceChunkPresenter {
     const storeTable = getTaskEventStoreTableForRun(run);
     // A child view only reads its own lifetime, not the root's.
     const startCreatedAt = run.createdAt;
-    const endCreatedAt = run.completedAt ?? undefined;
+    const endCreatedAt = getTraceStartTimeEnd(run);
 
     if (filter === "errors") {
       const errors = await repository.getTraceErrorEvents(

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/route.tsx

@@ -481,7 +481,7 @@ export default function Page() {
   const environment = useEnvironment();
   const isConnected = useCrossEngineIsConnected({
     logCount: trace?.events.length ?? 0,
-    isCompleted: run.completedAt !== null,
+    isCompleted: run.finishedAt !== null,
   });
   const { value } = useSearchParams();
   const tableState = decodeURIComponent(value("tableState") ?? "");
@@ -711,17 +711,17 @@ const INSPECTOR_REFRESH_MS = 5_000;
 // final rows that become visible late still land, but not long after completion.
 const LIVE_TAIL_UNRESOLVED_ROOT_MS = 5 * 60_000;
 
-function msSinceCompleted(run: { completedAt: string | null }): number | null {
-  return run.completedAt ? Date.now() - new Date(run.completedAt).getTime() : null;
+function msSinceFinished(run: { finishedAt: string | null }): number | null {
+  return run.finishedAt ? Date.now() - new Date(run.finishedAt).getTime() : null;
 }
 
 function shouldLiveReload(
-  run: { completedAt: string | null },
+  run: { finishedAt: string | null },
   rootSpanStatus: "executing" | "completed" | "failed"
 ): boolean {
-  const sinceCompleted = msSinceCompleted(run);
-  if (sinceCompleted === null || sinceCompleted < 30_000) return true;
-  return rootSpanStatus === "executing" && sinceCompleted < LIVE_TAIL_UNRESOLVED_ROOT_MS;
+  const sinceFinished = msSinceFinished(run);
+  if (sinceFinished === null || sinceFinished < 30_000) return true;
+  return rootSpanStatus === "executing" && sinceFinished < LIVE_TAIL_UNRESOLVED_ROOT_MS;
 }
 
 // Legacy path (live tail off): revalidate on ping, with the old size cap.
@@ -732,10 +732,10 @@ function shouldLiveReloadLegacy({
 }: {
   events: TraceEvent[];
   maximumLiveReloadingSetting: number;
-  run: { completedAt: string | null };
+  run: { finishedAt: string | null };
 }): boolean {
   if (events.length > maximumLiveReloadingSetting) return false;
-  if (run.completedAt && new Date(run.completedAt).getTime() < Date.now() - 30_000) return false;
+  if (run.finishedAt && new Date(run.finishedAt).getTime() < Date.now() - 30_000) return false;
   return true;
 }
 
@@ -785,7 +785,7 @@ function TraceView({
   const traceIsTruncated = isTruncated || progressiveIsTruncated;
 
   // The page data still shows the run unfinished, so a finish reload is useful.
-  const runDataUnfinished = !run.isFinished && run.completedAt === null;
+  const runDataUnfinished = !run.isFinished && run.finishedAt === null;
 
   // Display only: live reload and finish detection keep using the unsettled root.
   const settled = useMemo(
@@ -794,9 +794,9 @@ function TraceView({
         events,
         duration,
         rootSpanStatus,
-        run: { status: run.status, completedAt: run.completedAt },
+        run: { status: run.status, finishedAt: run.finishedAt },
       }),
-    [events, duration, rootSpanStatus, run.status, run.completedAt]
+    [events, duration, rootSpanStatus, run.status, run.finishedAt]
   );
 
   const changeToSpan = useDebounce((selectedSpan: string) => {
@@ -814,8 +814,8 @@ function TraceView({
       });
 
   const traceStatus = getTraceStatus({
-    // Same rule as live reload: only an end time means the run is done.
-    runFinished: run.completedAt !== null,
+    // Same rule as live reload: only a finished time means the run is done.
+    runFinished: run.finishedAt !== null,
     rootSpanStatus,
     isComplete,
     isTruncated: traceIsTruncated,
@@ -888,8 +888,8 @@ function TraceView({
 
   // SSE is off during the background load, so pick up rows written meanwhile. Runs
   // even if live reload already stopped, as long as the run finished recently.
-  const sinceCompleted = msSinceCompleted(run);
-  const recentlyActive = sinceCompleted === null || sinceCompleted < LIVE_TAIL_UNRESOLVED_ROOT_MS;
+  const sinceFinished = msSinceFinished(run);
+  const recentlyActive = sinceFinished === null || sinceFinished < LIVE_TAIL_UNRESOLVED_ROOT_MS;
   const prevIsCompleteRef = useRef(isComplete);
   useEffect(() => {
     const wasComplete = prevIsCompleteRef.current;
@@ -969,7 +969,7 @@ function TraceView({
                 environmentType={run.environment.type}
                 rootRun={run.rootTaskRun}
                 parentRun={run.parentTaskRun}
-                isCompleted={run.completedAt !== null}
+                isCompleted={run.finishedAt !== null}
                 treeSnapshot={resizable.tree as ResizableSnapshot}
                 errorsOnly={errorsOnly}
                 filterText={filterText}
@@ -1061,11 +1061,11 @@ function NoLogsView({
 
   const logRetention = plan?.v3Subscription?.plan?.limits.logRetentionDays.number ?? 30;
 
-  const completedAt = run.completedAt ? new Date(run.completedAt) : undefined;
+  const finishedAt = run.finishedAt ? new Date(run.finishedAt) : undefined;
   const now = new Date();
 
-  const daysSinceCompleted = completedAt
-    ? Math.floor((now.getTime() - completedAt.getTime()) / (1000 * 60 * 60 * 24))
+  const daysSinceCompleted = finishedAt
+    ? Math.floor((now.getTime() - finishedAt.getTime()) / (1000 * 60 * 60 * 24))
     : undefined;
 
   const isWithinLogRetention =
@@ -1089,7 +1089,7 @@ function NoLogsView({
               // Buffered runs always carry a synthetic trace (see
               // buildSyntheticTraceForBufferedRun) so they never reach
               // this branch — the message here is the pre-mollifier
-              // copy for runs with no completedAt and no logs.
+              // copy for runs with no finished time and no logs.
               <InfoPanel variant="info" icon={InformationCircleIcon} title="We delete old logs">
                 <Paragraph variant="small">
                   We tidy up older logs to keep things running smoothly.

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.runs.$runParam/settleUnloadedRoot.ts

@@ -17,7 +17,7 @@ type SettleInput<E extends SettleableEvent> = {
   events: E[];
   duration: number;
   rootSpanStatus: RootSpanStatus;
-  run: { status: TaskRunStatus; completedAt: Date | string | null };
+  run: { status: TaskRunStatus; finishedAt: Date | string | null };
 };
 
 type Settled<E> = { events: E[]; duration: number; rootSpanStatus: RootSpanStatus };
@@ -38,13 +38,13 @@ function rootOutcome(
   return undefined;
 }
 
-/** Ends a finished run's root at `completedAt` while its completion row is missing. */
+/** Ends a finished run's root at its finished time while its completion row is missing. */
 export function settleUnloadedRoot<E extends SettleableEvent>(input: SettleInput<E>): Settled<E> {
   const { events, duration, rootSpanStatus, run } = input;
   const unchanged = { events, duration, rootSpanStatus };
 
   const root = events[0];
-  if (!run.completedAt || rootSpanStatus !== "executing" || !root?.data.isPartial) {
+  if (!run.finishedAt || rootSpanStatus !== "executing" || !root?.data.isPartial) {
     return unchanged;
   }
 
@@ -53,7 +53,7 @@ export function settleUnloadedRoot<E extends SettleableEvent>(input: SettleInput
 
   const rootDuration = Math.max(
     0,
-    (new Date(run.completedAt).getTime() - new Date(root.data.startTime).getTime()) * 1_000_000
+    (new Date(run.finishedAt).getTime() - new Date(root.data.startTime).getTime()) * 1_000_000
   );
 
   const settledRoot = {

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

@@ -4,6 +4,7 @@ import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
 import { anyResource, createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { ApiRetrieveRunPresenter } from "~/presenters/v3/ApiRetrieveRunPresenter.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 
 const ParamsSchema = z.object({
   runId: z.string(), // This is the run friendly ID
@@ -56,7 +57,7 @@ export const loader = createLoaderApiRoute(
       run.traceId,
       run.friendlyId,
       run.createdAt,
-      run.completedAt ?? undefined
+      getTraceStartTimeEnd(run)
     );
 
     // TODO: return only relevant fields, avoid returning the whole events

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

@@ -5,6 +5,7 @@ import { $replica } from "~/db.server";
 import { extractAISpanData } from "~/components/runs/v3/ai";
 import { anyResource, createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
 import { findRunByIdWithMollifierFallback } from "~/v3/mollifier/readFallback.server";
 import { buildSyntheticSpanDetailBody } from "~/v3/mollifier/syntheticApiResponses.server";
@@ -106,7 +107,7 @@ export const loader = createLoaderApiRoute(
       params.spanId,
       run.traceId,
       run.createdAt,
-      run.completedAt ?? undefined
+      getTraceStartTimeEnd(run)
     );
 
     if (!span) {

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

@@ -8,7 +8,10 @@ import { env } from "~/env.server";
 import { anyResource, createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
 import { clampToEmergencySpanCap } from "~/v3/eventRepository/emergencySpanCap.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
-import { getTraceInsertedAtEnd } from "~/v3/eventRepository/traceInsertedAtBound";
+import {
+  getTraceInsertedAtEnd,
+  getTraceStartTimeEnd,
+} from "~/v3/eventRepository/traceInsertedAtBound";
 import { getRunTracePage } from "~/v3/eventRepository/runTracePage.server";
 import { FEATURE_FLAG } from "~/v3/featureFlags";
 import { makeFlag } from "~/v3/featureFlags.server";
@@ -128,7 +131,7 @@ export const loader = createLoaderApiRoute(
       run.traceId,
       run.spanId,
       run.createdAt,
-      run.completedAt ?? undefined,
+      getTraceStartTimeEnd(run),
       { insertedAtEnd: getTraceInsertedAtEnd(run) }
     );
 

apps/webapp/app/routes/resources.runs.$runParam.logs.download.ts

@@ -9,6 +9,7 @@ import { createGzip } from "zlib";
 import { Readable } from "stream";
 import { getTaskEventStoreTableForRun } from "~/v3/taskEventStore.server";
 import { getEventRepositoryForStore } from "~/v3/eventRepository/index.server";
+import { getTraceStartTimeEnd } from "~/v3/eventRepository/traceInsertedAtBound";
 import {
   getTraceExportFormat,
   streamTraceExport,
@@ -42,8 +43,10 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
             traceId: true,
             organizationId: true,
             runtimeEnvironmentId: true,
+            status: true,
             createdAt: true,
             completedAt: true,
+            updatedAt: true,
             taskEventStore: true,
             taskIdentifier: true,
           },
@@ -106,7 +109,7 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
     run.runtimeEnvironmentId,
     run.traceId,
     run.createdAt,
-    run.completedAt ?? undefined,
+    getTraceStartTimeEnd(run),
     { includeDebugLogs: showDebug }
   );