fix: stop creating TaskRunTag records and join table entries during triggering

The TaskRun.runTags string array already stores tag names, making the
TaskRunTag M2M relation redundant write overhead. Remove createTags
calls, connect: tags, and join table writes from both V1 and V2 trigger
paths. Simplify the add-tags API to just push to runTags directly.

Prisma's upsert with empty update: {} generates DO UPDATE SET name=name
which creates dead tuples and WAL writes even when nothing changes.
Verified locally: DO UPDATE advances WAL and creates new tuple versions,
while DO NOTHING writes zero WAL. This change eliminates these writes
entirely rather than switching to createMany.

refs TRI-8451

Author: ericallam

.server-changes/stop-creating-taskruntag-records.md

@@ -0,0 +1,6 @@
+---
+area: webapp
+type: improvement
+---
+
+Stop creating TaskRunTag records and _TaskRunToTaskRunTag join table entries during task triggering. The denormalized runTags string array on TaskRun already stores tag names, making the M2M relation redundant write overhead.

apps/webapp/app/models/taskRunTag.server.ts

@@ -1,108 +1 @@
-import { Prisma } from "@trigger.dev/database";
-import { prisma } from "~/db.server";
-import { generateFriendlyId } from "~/v3/friendlyIdentifiers";
-import { PrismaClientOrTransaction } from "@trigger.dev/database";
-
 export const MAX_TAGS_PER_RUN = 10;
-const MAX_RETRIES = 3;
-
-export async function createTag(
-  { tag, projectId }: { tag: string; projectId: string },
-  prismaClient: PrismaClientOrTransaction = prisma
-) {
-  if (tag.trim().length === 0) return;
-
-  let attempts = 0;
-  const friendlyId = generateFriendlyId("runtag");
-
-  while (attempts < MAX_RETRIES) {
-    try {
-      return await prisma.taskRunTag.upsert({
-        where: {
-          projectId_name: {
-            projectId,
-            name: tag,
-          },
-        },
-        create: {
-          friendlyId,
-          name: tag,
-          projectId,
-        },
-        update: {},
-      });
-    } catch (error) {
-      if (error instanceof Prisma.PrismaClientKnownRequestError && error.code === "P2002") {
-        // Handle unique constraint violation (conflict)
-        attempts++;
-        if (attempts >= MAX_RETRIES) {
-          throw new Error(`Failed to create tag after ${MAX_RETRIES} attempts due to conflicts.`);
-        }
-      } else {
-        throw error; // Re-throw other errors
-      }
-    }
-  }
-}
-
-export type TagRecord = {
-  id: string;
-  name: string;
-};
-
-export async function createTags(
-  {
-    tags,
-    projectId,
-  }: {
-    tags: string | string[] | undefined;
-    projectId: string;
-  },
-  prismaClient: PrismaClientOrTransaction = prisma
-): Promise<TagRecord[]> {
-  if (!tags) {
-    return [];
-  }
-
-  const tagsArray = typeof tags === "string" ? [tags] : tags;
-
-  if (tagsArray.length === 0) {
-    return [];
-  }
-
-  const tagRecords: TagRecord[] = [];
-  for (const tag of tagsArray) {
-    const tagRecord = await createTag(
-      {
-        tag,
-        projectId,
-      },
-      prismaClient
-    );
-    if (tagRecord) {
-      tagRecords.push({ id: tagRecord.id, name: tagRecord.name });
-    }
-  }
-
-  return tagRecords;
-}
-
-export async function getTagsForRunId({
-  friendlyId,
-  environmentId,
-}: {
-  friendlyId: string;
-  environmentId: string;
-}) {
-  const run = await prisma.taskRun.findFirst({
-    where: {
-      friendlyId,
-      runtimeEnvironmentId: environmentId,
-    },
-    select: {
-      tags: true,
-    },
-  });
-
-  return run?.tags ?? undefined;
-}

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

@@ -2,7 +2,7 @@ import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
 import { AddTagsRequestBody } from "@trigger.dev/core/v3";
 import { z } from "zod";
 import { prisma } from "~/db.server";
-import { createTag, getTagsForRunId, MAX_TAGS_PER_RUN } from "~/models/taskRunTag.server";
+import { MAX_TAGS_PER_RUN } from "~/models/taskRunTag.server";
 import { authenticateApiRequest } from "~/services/apiAuth.server";
 
 const ParamsSchema = z.object({
@@ -37,17 +37,23 @@ export async function action({ request, params }: ActionFunctionArgs) {
       return json({ error: "Invalid request body", issues: body.error.issues }, { status: 400 });
     }
 
-    const existingTags =
-      (await getTagsForRunId({
+    const run = await prisma.taskRun.findFirst({
+      where: {
         friendlyId: parsedParams.data.runId,
-        environmentId: authenticationResult.environment.id,
-      })) ?? [];
+        runtimeEnvironmentId: authenticationResult.environment.id,
+      },
+      select: {
+        runTags: true,
+      },
+    });
+
+    const existingTags = run?.runTags ?? [];
 
     //remove duplicate tags from the new tags
     const bodyTags = typeof body.data.tags === "string" ? [body.data.tags] : body.data.tags;
     const newTags = bodyTags.filter((tag) => {
       if (tag.trim().length === 0) return false;
-      return !existingTags.map((t) => t.name).includes(tag);
+      return !existingTags.includes(tag);
     });
 
     if (existingTags.length + newTags.length > MAX_TAGS_PER_RUN) {
@@ -65,29 +71,12 @@ export async function action({ request, params }: ActionFunctionArgs) {
       return json({ message: "No new tags to add" }, { status: 200 });
     }
 
-    //create tags
-    let tagIds: string[] = existingTags.map((t) => t.id);
-    if (newTags.length > 0) {
-      for (const tag of newTags) {
-        const tagRecord = await createTag({
-          tag,
-          projectId: authenticationResult.environment.projectId,
-        });
-        if (tagRecord) {
-          tagIds.push(tagRecord.id);
-        }
-      }
-    }
-
     await prisma.taskRun.update({
       where: {
         friendlyId: parsedParams.data.runId,
         runtimeEnvironmentId: authenticationResult.environment.id,
       },
       data: {
-        tags: {
-          connect: tagIds.map((id) => ({ id })),
-        },
         runTags: {
           push: newTags,
         },

apps/webapp/app/runEngine/services/triggerTask.server.ts

@@ -20,7 +20,6 @@ import {
   stringifyDuration,
 } from "@trigger.dev/core/v3/isomorphic";
 import type { PrismaClientOrTransaction } from "@trigger.dev/database";
-import { createTags } from "~/models/taskRunTag.server";
 import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { parseDelay } from "~/utils/delays";
@@ -287,14 +286,11 @@ export class RunEngineTriggerTaskService {
           )
         : undefined;
 
-      //upsert tags
-      const tags = await createTags(
-        {
-          tags: body.options?.tags,
-          projectId: environment.projectId,
-        },
-        this.prisma
-      );
+      const tags = body.options?.tags
+        ? typeof body.options.tags === "string"
+          ? [body.options.tags]
+          : body.options.tags
+        : [];
 
       const depth = parentRun ? parentRun.depth + 1 : 0;
 

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

@@ -13,7 +13,7 @@ import {
 import { Prisma } from "@trigger.dev/database";
 import { z } from "zod";
 import { env } from "~/env.server";
-import { createTag, MAX_TAGS_PER_RUN } from "~/models/taskRunTag.server";
+import { MAX_TAGS_PER_RUN } from "~/models/taskRunTag.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { autoIncrementCounter } from "~/services/autoIncrementCounter.server";
 import { logger } from "~/services/logger.server";
@@ -345,21 +345,8 @@ export class TriggerTaskServiceV1 extends BaseService {
 
                 span.setAttribute("queueName", queueName);
 
-                //upsert tags
-                let tagIds: string[] = [];
                 const bodyTags =
                   typeof body.options?.tags === "string" ? [body.options.tags] : body.options?.tags;
-                if (bodyTags && bodyTags.length > 0) {
-                  for (const tag of bodyTags) {
-                    const tagRecord = await createTag({
-                      tag,
-                      projectId: environment.projectId,
-                    });
-                    if (tagRecord) {
-                      tagIds.push(tagRecord.id);
-                    }
-                  }
-                }
 
                 const depth = dependentAttempt
                   ? dependentAttempt.taskRun.depth + 1
@@ -409,12 +396,6 @@ export class TriggerTaskServiceV1 extends BaseService {
                     maxAttempts: body.options?.maxAttempts,
                     taskEventStore: store,
                     ttl,
-                    tags:
-                      tagIds.length === 0
-                        ? undefined
-                        : {
-                            connect: tagIds.map((id) => ({ id })),
-                          },
                     parentTaskRunId:
                       dependentAttempt?.taskRun.id ??
                       parentAttempt?.taskRun.id ??

internal-packages/run-engine/src/engine/index.ts

@@ -637,13 +637,7 @@ export class RunEngine {
               priorityMs,
               queueTimestamp: queueTimestamp ?? delayUntil ?? new Date(),
               ttl: resolvedTtl,
-              tags:
-                tags.length === 0
-                  ? undefined
-                  : {
-                    connect: tags,
-                  },
-              runTags: tags.length === 0 ? undefined : tags.map((tag) => tag.name),
+              runTags: tags.length === 0 ? undefined : tags,
               oneTimeUseToken,
               parentTaskRunId,
               rootTaskRunId,

internal-packages/run-engine/src/engine/systems/debounceSystem.ts

@@ -32,7 +32,7 @@ export type DebounceOptions = {
     payloadType: string;
     metadata?: string;
     metadataType?: string;
-    tags?: { id: string; name: string }[];
+    tags?: string[];
     maxAttempts?: number;
     maxDurationInSeconds?: number;
     machine?: string;
@@ -876,10 +876,7 @@ return 0
 
     // Handle tags update - replace existing tags
     if (updateData.tags !== undefined) {
-      updatePayload.runTags = updateData.tags.map((t) => t.name);
-      updatePayload.tags = {
-        set: updateData.tags.map((t) => ({ id: t.id })),
-      };
+      updatePayload.runTags = updateData.tags;
     }
 
     const updatedRun = await prisma.taskRun.update({

internal-packages/run-engine/src/engine/types.ts

@@ -194,7 +194,7 @@ export type TriggerParams = {
   priorityMs?: number;
   queueTimestamp?: Date;
   ttl?: string;
-  tags: { id: string; name: string }[];
+  tags: string[];
   parentTaskRunId?: string;
   rootTaskRunId?: string;
   replayedFromTaskRunFriendlyId?: string;