Unfriendly IDs

Author: nicktrn

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.v3.$projectParam.test.tasks.$taskParam/route.tsx

@@ -121,7 +121,7 @@ export const action: ActionFunction = async ({ request, params }) => {
       );
     }
 
-    logger.error("Failed to start a test run", { error: e });
+    logger.error("Failed to start a test run", { error: e instanceof Error ? e.message : e });
 
     return redirectBackWithErrorMessage(
       request,

apps/webapp/app/routes/api.v1.tasks.$taskId.trigger.ts

@@ -96,7 +96,6 @@ const { action, loader } = createActionApiRoute(
       return json(
         {
           id: run.friendlyId,
-          internalId: run.id,
         },
         {
           headers: $responseHeaders,

apps/webapp/app/routes/api.v1.worker-actions.runs.$runId.snapshots.$snapshotId.attempts.complete.ts renamed to apps/webapp/app/routes/api.v1.worker-actions.runs.$runFriendlyId.snapshots.$snapshotFriendlyId.attempts.complete.ts

@@ -10,8 +10,8 @@ export const action = createActionWorkerApiRoute(
   {
     body: WorkerApiRunAttemptCompleteRequestBody,
     params: z.object({
-      runId: z.string(),
-      snapshotId: z.string(),
+      runFriendlyId: z.string(),
+      snapshotFriendlyId: z.string(),
     }),
   },
   async ({
@@ -20,11 +20,11 @@ export const action = createActionWorkerApiRoute(
     params,
   }): Promise<TypedResponse<WorkerApiRunAttemptCompleteResponseBody>> => {
     const { completion } = body;
-    const { runId, snapshotId } = params;
+    const { runFriendlyId, snapshotFriendlyId } = params;
 
     const completeResult = await authenticatedWorker.completeRunAttempt({
-      runId,
-      snapshotId,
+      runFriendlyId,
+      snapshotFriendlyId,
       completion,
     });
 

apps/webapp/app/routes/api.v1.worker-actions.runs.$runId.snapshots.$snapshotId.attempts.start.ts renamed to apps/webapp/app/routes/api.v1.worker-actions.runs.$runFriendlyId.snapshots.$snapshotFriendlyId.attempts.start.ts

@@ -10,20 +10,20 @@ export const action = createActionWorkerApiRoute(
   {
     body: WorkerApiRunAttemptStartRequestBody,
     params: z.object({
-      runId: z.string(),
-      snapshotId: z.string(),
+      runFriendlyId: z.string(),
+      snapshotFriendlyId: z.string(),
     }),
   },
   async ({
     authenticatedWorker,
     body,
     params,
   }): Promise<TypedResponse<WorkerApiRunAttemptStartResponseBody>> => {
-    const { runId, snapshotId } = params;
+    const { runFriendlyId, snapshotFriendlyId } = params;
 
     const runExecutionData = await authenticatedWorker.startRunAttempt({
-      runId,
-      snapshotId,
+      runFriendlyId,
+      snapshotFriendlyId,
       isWarmStart: body.isWarmStart,
     });
 

apps/webapp/app/routes/api.v1.worker-actions.runs.$runId.snapshots.$snapshotId.heartbeat.ts renamed to apps/webapp/app/routes/api.v1.worker-actions.runs.$runFriendlyId.snapshots.$snapshotFriendlyId.heartbeat.ts

@@ -6,19 +6,19 @@ import { createActionWorkerApiRoute } from "~/services/routeBuilders/apiBuilder.
 export const action = createActionWorkerApiRoute(
   {
     params: z.object({
-      runId: z.string(),
-      snapshotId: z.string(),
+      runFriendlyId: z.string(),
+      snapshotFriendlyId: z.string(),
     }),
   },
   async ({
     authenticatedWorker,
     params,
   }): Promise<TypedResponse<WorkloadHeartbeatResponseBody>> => {
-    const { runId, snapshotId } = params;
+    const { runFriendlyId, snapshotFriendlyId } = params;
 
     await authenticatedWorker.heartbeatRun({
-      runId,
-      snapshotId,
+      runFriendlyId,
+      snapshotFriendlyId,
     });
 
     return json({ ok: true });

apps/webapp/app/routes/api.v1.worker-actions.runs.$runId.snapshots.$snapshotId.wait.duration.ts renamed to apps/webapp/app/routes/api.v1.worker-actions.runs.$runFriendlyId.snapshots.$snapshotFriendlyId.wait.duration.ts

@@ -10,20 +10,20 @@ export const action = createActionWorkerApiRoute(
   {
     body: WorkerApiWaitForDurationRequestBody,
     params: z.object({
-      runId: z.string(),
-      snapshotId: z.string(),
+      runFriendlyId: z.string(),
+      snapshotFriendlyId: z.string(),
     }),
   },
   async ({
     authenticatedWorker,
     body,
     params,
   }): Promise<TypedResponse<WorkerApiWaitForDurationResponseBody>> => {
-    const { runId, snapshotId } = params;
+    const { runFriendlyId, snapshotFriendlyId } = params;
 
     const waitResult = await authenticatedWorker.waitForDuration({
-      runId,
-      snapshotId,
+      runFriendlyId,
+      snapshotFriendlyId,
       date: body.date,
     });
 

apps/webapp/app/routes/api.v1.worker-actions.runs.$runId.snapshots.latest.ts renamed to apps/webapp/app/routes/api.v1.worker-actions.runs.$runFriendlyId.snapshots.latest.ts

@@ -6,17 +6,17 @@ import { createLoaderWorkerApiRoute } from "~/services/routeBuilders/apiBuilder.
 export const loader = createLoaderWorkerApiRoute(
   {
     params: z.object({
-      runId: z.string(),
+      runFriendlyId: z.string(),
     }),
   },
   async ({
     authenticatedWorker,
     params,
   }): Promise<TypedResponse<WorkerApiRunLatestSnapshotResponseBody>> => {
-    const { runId } = params;
+    const { runFriendlyId } = params;
 
     const executionData = await authenticatedWorker.getLatestSnapshot({
-      runId,
+      runFriendlyId,
     });
 
     if (!executionData) {

apps/webapp/app/v3/handleSocketIo.server.ts

@@ -455,12 +455,12 @@ function createWorkerNamespace(io: Server) {
       clearInterval(interval);
     });
 
-    socket.on("run:subscribe", async ({ version, runIds }) => {
-      logger.debug("run:subscribe", { version, runIds });
+    socket.on("run:subscribe", async ({ version, runFriendlyIds }) => {
+      logger.debug("run:subscribe", { version, runFriendlyIds });
 
       const settledResult = await Promise.allSettled(
-        runIds.map((runId) => {
-          const room = roomFromRunId(runId);
+        runFriendlyIds.map((friendlyId) => {
+          const room = roomFromFriendlyRunId(friendlyId);
 
           logger.debug("Joining room", { room });
 
@@ -472,7 +472,7 @@ function createWorkerNamespace(io: Server) {
       for (const result of settledResult) {
         if (result.status === "rejected") {
           logger.error("Error joining room", {
-            runIds,
+            runFriendlyIds,
             error: result.reason instanceof Error ? result.reason.message : result.reason,
           });
         }
@@ -484,12 +484,12 @@ function createWorkerNamespace(io: Server) {
       });
     });
 
-    socket.on("run:unsubscribe", async ({ version, runIds }) => {
-      logger.debug("run:unsubscribe", { version, runIds });
+    socket.on("run:unsubscribe", async ({ version, runFriendlyIds }) => {
+      logger.debug("run:unsubscribe", { version, runFriendlyIds });
 
       const settledResult = await Promise.allSettled(
-        runIds.map((runId) => {
-          const room = roomFromRunId(runId);
+        runFriendlyIds.map((friendlyId) => {
+          const room = roomFromFriendlyRunId(friendlyId);
 
           logger.debug("Leaving room", { room });
 
@@ -501,7 +501,7 @@ function createWorkerNamespace(io: Server) {
       for (const result of settledResult) {
         if (result.status === "rejected") {
           logger.error("Error leaving room", {
-            runIds,
+            runFriendlyIds,
             error: result.reason instanceof Error ? result.reason.message : result.reason,
           });
         }
@@ -517,6 +517,6 @@ function createWorkerNamespace(io: Server) {
   return worker;
 }
 
-function roomFromRunId(runId: string) {
-  return `run:${runId}`;
+export function roomFromFriendlyRunId(id: string) {
+  return `room:${id}`;
 }

apps/webapp/app/v3/runEngineHandlers.server.ts

@@ -5,9 +5,10 @@ import { logger } from "~/services/logger.server";
 import { safeJsonParse } from "~/utils/json";
 import type { Attributes } from "@opentelemetry/api";
 import { reportInvocationUsage } from "~/services/platform.v3.server";
-import { socketIo } from "./handleSocketIo.server";
+import { roomFromFriendlyRunId, socketIo } from "./handleSocketIo.server";
 import { engine } from "./runEngine.server";
 import { PerformTaskRunAlertsService } from "./services/alerts/performTaskRunAlerts.server";
+import { RunId } from "@trigger.dev/core/v3/apps";
 
 export function registerRunEngineEventBusHandlers() {
   engine.eventBus.on("runSucceeded", async ({ time, run }) => {
@@ -286,7 +287,12 @@ export function registerRunEngineEventBusHandlers() {
     logger.debug("[workerNotification] Notifying worker", { time, runId: run.id });
 
     try {
-      socketIo.workerNamespace.to(`run:${run.id}`).emit("run:notify", { version: "1", run });
+      const runFriendlyId = RunId.toFriendlyId(run.id);
+      const room = roomFromFriendlyRunId(runFriendlyId);
+
+      socketIo.workerNamespace
+        .to(room)
+        .emit("run:notify", { version: "1", run: { friendlyId: runFriendlyId } });
     } catch (error) {
       logger.error("[workerNotification] Failed to notify worker", {
         error: error instanceof Error ? error.message : error,

apps/webapp/app/v3/services/batchTriggerV2.server.ts

@@ -709,18 +709,18 @@ export class BatchTriggerV2Service extends BaseService {
     | { status: "ERROR"; error: string; workingIndex: number }
   > {
     // Grab the next PROCESSING_BATCH_SIZE runIds
-    const runIds = batch.runIds.slice(currentIndex, currentIndex + batchSize);
+    const runFriendlyIds = batch.runIds.slice(currentIndex, currentIndex + batchSize);
 
     logger.debug("[BatchTriggerV2][processBatchTaskRun] Processing batch items", {
       batchId: batch.friendlyId,
       currentIndex,
-      runIds,
+      runIds: runFriendlyIds,
       runCount: batch.runCount,
     });
 
     // Combine the "window" between currentIndex and currentIndex + PROCESSING_BATCH_SIZE with the runId and the item in the payload which is an array
-    const itemsToProcess = runIds.map((runId, index) => ({
-      runId,
+    const itemsToProcess = runFriendlyIds.map((runFriendlyId, index) => ({
+      runFriendlyId,
       item: items[index + currentIndex],
     }));
 
@@ -757,13 +757,13 @@ export class BatchTriggerV2Service extends BaseService {
   async #processBatchTaskRunItem(
     batch: BatchTaskRun,
     environment: AuthenticatedEnvironment,
-    task: { runId: string; item: BatchTriggerTaskV2RequestBody["items"][number] },
+    task: { runFriendlyId: string; item: BatchTriggerTaskV2RequestBody["items"][number] },
     currentIndex: number,
     options?: BatchTriggerTaskServiceOptions
   ) {
     logger.debug("[BatchTriggerV2][processBatchTaskRunItem] Processing item", {
       batchId: batch.friendlyId,
-      runId: task.runId,
+      runId: task.runFriendlyId,
       currentIndex,
     });
 
@@ -786,12 +786,12 @@ export class BatchTriggerV2Service extends BaseService {
         spanParentAsLink: options?.spanParentAsLink,
         batchId: batch.friendlyId,
         skipChecks: true,
-        runId: task.runId,
+        runFriendlyId: task.runFriendlyId,
       }
     );
 
     if (!run) {
-      throw new Error(`Failed to trigger run ${task.runId} for batch ${batch.friendlyId}`);
+      throw new Error(`Failed to trigger run ${task.runFriendlyId} for batch ${batch.friendlyId}`);
     }
 
     await this._prisma.batchTaskRunItem.create({