fix: allow updating run metadata up to 1 hour after completion

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

@@ -1,8 +1,10 @@
 import { json } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/utils";
 import { UpdateMetadataRequestBody } from "@trigger.dev/core/v3";
 import { z } from "zod";
 import { updateMetadataService } from "~/services/metadata/updateMetadata.server";
 import { createActionApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+import { ServiceValidationError } from "~/v3/services/baseService.server";
 
 const ParamsSchema = z.object({
   runId: z.string(),
@@ -16,7 +18,17 @@ const { action } = createActionApiRoute(
     method: "PUT",
   },
   async ({ authentication, body, params }) => {
-    const result = await updateMetadataService.call(params.runId, body, authentication.environment);
+    const [error, result] = await tryCatch(
+      updateMetadataService.call(params.runId, body, authentication.environment)
+    );
+
+    if (error) {
+      if (error instanceof ServiceValidationError) {
+        return json({ error: error.message }, { status: error.status ?? 422 });
+      }
+
+      return json({ error: "Internal Server Error" }, { status: 500 });
+    }
 
     if (!result) {
       return json({ error: "Task Run not found" }, { status: 404 });

apps/webapp/app/services/metadata/updateMetadata.server.ts

@@ -9,7 +9,6 @@ import { prisma, PrismaClientOrTransaction } from "~/db.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { handleMetadataPacket } from "~/utils/packets";
 import { BaseService, ServiceValidationError } from "~/v3/services/baseService.server";
-import { isFinalRunStatus } from "~/v3/taskStatus";
 
 import { Effect, Schedule, Duration } from "effect";
 import { type RuntimeFiber } from "effect/Fiber";
@@ -18,6 +17,8 @@ import { singleton } from "~/utils/singleton";
 import { env } from "~/env.server";
 import { setTimeout } from "timers/promises";
 
+const RUN_UPDATABLE_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+
 type BufferedRunMetadataChangeOperation = {
   runId: string;
   timestamp: number;
@@ -246,6 +247,7 @@ export class UpdateMetadataService extends BaseService {
           },
       select: {
         id: true,
+        completedAt: true,
         status: true,
         metadata: true,
         metadataType: true,
@@ -269,7 +271,7 @@ export class UpdateMetadataService extends BaseService {
       return;
     }
 
-    if (isFinalRunStatus(taskRun.status)) {
+    if (!this.#isRunUpdatable(taskRun)) {
       throw new ServiceValidationError("Cannot update metadata for a completed run");
     }
 
@@ -391,6 +393,17 @@ export class UpdateMetadataService extends BaseService {
     }
   }
 
+  // Checks to see if a run is updatable
+  // if there is no completedAt, the run is updatable
+  // if the run is completed, but the completedAt is within the last 10 minutes, the run is updatable
+  #isRunUpdatable(run: { completedAt: Date | null }) {
+    if (!run.completedAt) {
+      return true;
+    }
+
+    return run.completedAt.getTime() > Date.now() - RUN_UPDATABLE_WINDOW_MS;
+  }
+
   async #updateRunMetadataDirectly(
     runId: string,
     body: UpdateMetadataRequestBody,

references/hello-world/src/trigger/metadata.ts

@@ -1,4 +1,5 @@
-import { metadata, task } from "@trigger.dev/sdk";
+import { logger, metadata, task } from "@trigger.dev/sdk";
+import { setTimeout } from "node:timers/promises";
 
 export const metadataTestTask = task({
   id: "metadata-tester",
@@ -8,9 +9,29 @@ export const metadataTestTask = task({
     maxTimeoutInMs: 1000,
     factor: 1.5,
   },
-  run: async (payload: any, { ctx }) => {
-    metadata.set("test-key", "test-value");
-    metadata.append("test-keys", "test-value");
-    metadata.increment("test-counter", 1);
+  run: async (payload: any, { ctx, signal }) => {
+    let iteration = 0;
+
+    while (!signal.aborted) {
+      await setTimeout(1000);
+
+      iteration++;
+
+      metadata.set(`test-key-${iteration}`, `test-value-${iteration}`);
+      metadata.append(`test-keys-${iteration}`, `test-value-${iteration}`);
+      metadata.increment(`test-counter-${iteration}`, 1);
+
+      await setTimeout(1000);
+    }
+
+    logger.info("Run completed", { iteration });
+
+    return {
+      success: true,
+    };
+  },
+  onCancel: async ({ runPromise }) => {
+    await metadata.flush();
+    await runPromise;
   },
 });