v3: Various fixes to support papermark use-case (#970)

* Adding a changeset for v3

* Add a version field to @trigger.dev/core-apps package.json

* Build trigger.dev when doing a prerelease

* bundle @trigger.dev/core-apps with trigger.dev cli

* Fix the init command config template

* Don’t use * for the @trigger.dev/core dep version specifier

* strip workspace: from the package version before installing it

* Added dependenciesToBundle config option to bundle ESM only packages

* Added logging around resolving dependency paths

* Try again

* Resolve dependencies based on the project dir first

* flip the bundled default

* Adding some logs around dev task completion notifications

* Adding some additional logs

* Add more logs

* Write out the log using process.stdout

* Store pending completion notifications and resume them when awaited (fixes race condition)

* Cleanup some of the logs

* Copy over the postinstall step from the projects package.json

* Add support for including additional files when deploying (e.g. prisma schema)

* Don’t run scripts when resolving deps

* copy all the files just in case anything is needed in postinstall

* Remove duplicate option

* Use the tag when outputting the dev command

* Remove the postinstall script

* add the trigger dir to the config if the default is not chosen

* Remove the “hud” display in the dev command

* trigger file names with dashes now work

* Better file watching in dev

* Much better duplicate ID experience now

* Much better “Project not found” error

* Export the handleError function types from sdk

* Add support for configuring instrumentation

* Upgrade and unify @opentelemetry/* packages (and remove storybook from the webapp)

* Fix typescript error in react package

* Upgrade react types in webapp

* Allow span icons to be determined based on the span name (e.g. prisma:)

* Ignore built-in env vars when checking for env vars, and allow continuing the deployment even if missing env vars were detected

* Improve the retry.fetch default behavior and option structure

* Fixed typescript errors with packages/email react types

* Update the retry.fetch docs

Author: ericallam

.changeset/config.json

@@ -16,7 +16,10 @@
     "emails",
     "proxy",
     "yalt",
-    "@trigger.dev/database"
+    "@trigger.dev/database",
+    "coordinator",
+    "docker-provider",
+    "kubernetes-provider"
   ],
   "___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH": {
     "onlyUpdatePeerDependentsWhenOutOfRange": true

.changeset/sweet-lizards-press.md

@@ -0,0 +1,8 @@
+---
+"trigger.dev": major
+"@trigger.dev/core": major
+"@trigger.dev/otlp-importer": major
+"@trigger.dev/sdk": major
+---
+
+Updates to support Trigger.dev v3

CHANGESETS.md

@@ -47,7 +47,7 @@ pnpm exec changeset version --snapshot prerelease
 3. Build the packages:
 
 ```sh
-pnpm run build --filter "@trigger.dev/*"
+pnpm run build --filter "@trigger.dev/*" --filter "trigger.dev"
 ```
 
 4. Publish the snapshot (replace "dev" with your tag)

apps/webapp/.storybook/main.ts

@@ -12,10 +12,30 @@ import { cn } from "~/utils/cn";
 
 type TaskIconProps = {
   name: string | undefined;
+  spanName: string;
   className?: string;
 };
 
-export function RunIcon({ name, className }: TaskIconProps) {
+type SpanNameIcons = {
+  matcher: RegExp;
+  iconName: string;
+};
+
+const spanNameIcons: SpanNameIcons[] = [{ matcher: /^prisma:/, iconName: "brand-prisma" }];
+
+export function RunIcon({ name, className, spanName }: TaskIconProps) {
+  const spanNameIcon = spanNameIcons.find(({ matcher }) => matcher.test(spanName));
+
+  if (spanNameIcon) {
+    return (
+      <NamedIcon
+        name={spanNameIcon.iconName}
+        className={cn(className)}
+        fallback={<InformationCircleIcon className={cn(className, "text-text-dimmed")} />}
+      />
+    );
+  }
+
   if (!name) return <Squares2X2Icon className={cn(className, "text-text-dimmed")} />;
 
   switch (name) {

apps/webapp/.storybook/preview.tsx

@@ -1,4 +1,3 @@
-import { H } from "@highlight-run/node";
 import {
   createReadableStreamFromReadable,
   type DataFunctionArgs,
@@ -165,10 +164,6 @@ function handleBrowserRequest(
   });
 }
 
-if (env.HIGHLIGHT_PROJECT_ID) {
-  H.init({ projectID: env.HIGHLIGHT_PROJECT_ID });
-}
-
 export function handleError(error: unknown, { request, params, context }: DataFunctionArgs) {
   logError(error, request);
 }
@@ -178,18 +173,6 @@ Worker.init().catch((error) => {
 });
 
 function logError(error: unknown, request?: Request) {
-  if (env.HIGHLIGHT_PROJECT_ID) {
-    const parsed = request ? H.parseHeaders(Object.fromEntries(request.headers)) : undefined;
-    if (error instanceof Error) {
-      H.consumeError(error, parsed?.secureSessionId, parsed?.requestId);
-    } else {
-      H.consumeError(
-        new Error(`Unknown error: ${JSON.stringify(error)}`),
-        parsed?.secureSessionId,
-        parsed?.requestId
-      );
-    }
-  }
   console.error(error);
 }
 

apps/webapp/app/components/runs/v3/RunIcon.tsx

@@ -1,4 +1,3 @@
-import { ErrorBoundary as HighlightErrorBoundary } from "@highlight-run/react";
 import type { LinksFunction, LoaderFunctionArgs, MetaFunction } from "@remix-run/node";
 import type { ShouldRevalidateFunction } from "@remix-run/react";
 import { Links, LiveReload, Meta, Outlet, Scripts, ScrollRestoration } from "@remix-run/react";
@@ -111,9 +110,7 @@ function App() {
           <Links />
         </head>
         <body className="bg-darkBackground h-full overflow-hidden">
-          <HighlightErrorBoundary>
-            <Outlet />
-          </HighlightErrorBoundary>
+          <Outlet />
           <Toast />
           <ScrollRestoration />
           <ExternalScripts />

apps/webapp/app/entry.server.tsx

@@ -60,7 +60,11 @@ export default function Page() {
     >
       <div className="mx-3 flex items-center justify-between gap-2 border-b border-grid-dimmed">
         <div className="flex items-center gap-1 overflow-x-hidden">
-          <RunIcon name={event.style?.icon} className="h-4 min-h-4 w-4 min-w-4" />
+          <RunIcon
+            name={event.style?.icon}
+            spanName={event.message}
+            className="h-4 min-h-4 w-4 min-w-4"
+          />
           <Header2 className={cn("whitespace-nowrap")}>
             <SpanTitle {...event} size="large" />
           </Header2>

apps/webapp/app/root.tsx

@@ -362,7 +362,11 @@ function TasksTreeView({
 
                   <div className="flex w-full items-center justify-between gap-2 pl-1">
                     <div className="flex items-center gap-2 overflow-x-hidden">
-                      <RunIcon name={node.data.style?.icon} className="h-4 min-h-4 w-4 min-w-4" />
+                      <RunIcon
+                        name={node.data.style?.icon}
+                        spanName={node.data.message}
+                        className="h-4 min-h-4 w-4 min-w-4"
+                      />
                       <NodeText node={node} />
                       {node.data.isRoot && <Badge variant="outline-rounded">Root</Badge>}
                     </div>

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.v3.$projectParam.runs.$runParam.spans.$spanParam/route.tsx

@@ -1,6 +1,6 @@
 import { CreateBackgroundWorkerRequestBody, TaskResource } from "@trigger.dev/core/v3";
 import type { BackgroundWorker } from "@trigger.dev/database";
-import { PrismaClientOrTransaction } from "~/db.server";
+import { Prisma, PrismaClientOrTransaction } from "~/db.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { logger } from "~/services/logger.server";
 import { generateFriendlyId } from "../friendlyIdentifiers";
@@ -89,46 +89,83 @@ export async function createBackgroundTasks(
   prisma: PrismaClientOrTransaction
 ) {
   for (const task of tasks) {
-    await prisma.backgroundWorkerTask.create({
-      data: {
-        friendlyId: generateFriendlyId("task"),
-        projectId: worker.projectId,
-        runtimeEnvironmentId: worker.runtimeEnvironmentId,
-        workerId: worker.id,
-        slug: task.id,
-        filePath: task.filePath,
-        exportName: task.exportName,
-        retryConfig: task.retry,
-        queueConfig: task.queue,
-      },
-    });
+    try {
+      await prisma.backgroundWorkerTask.create({
+        data: {
+          friendlyId: generateFriendlyId("task"),
+          projectId: worker.projectId,
+          runtimeEnvironmentId: worker.runtimeEnvironmentId,
+          workerId: worker.id,
+          slug: task.id,
+          filePath: task.filePath,
+          exportName: task.exportName,
+          retryConfig: task.retry,
+          queueConfig: task.queue,
+        },
+      });
 
-    const queueName = task.queue?.name ?? `task/${task.id}`;
+      const queueName = task.queue?.name ?? `task/${task.id}`;
 
-    const taskQueue = await prisma.taskQueue.upsert({
-      where: {
-        runtimeEnvironmentId_name: {
-          runtimeEnvironmentId: worker.runtimeEnvironmentId,
+      const taskQueue = await prisma.taskQueue.upsert({
+        where: {
+          runtimeEnvironmentId_name: {
+            runtimeEnvironmentId: worker.runtimeEnvironmentId,
+            name: queueName,
+          },
+        },
+        update: {
+          concurrencyLimit: task.queue?.concurrencyLimit,
+          rateLimit: task.queue?.rateLimit,
+        },
+        create: {
+          friendlyId: generateFriendlyId("queue"),
           name: queueName,
+          concurrencyLimit: task.queue?.concurrencyLimit,
+          runtimeEnvironmentId: worker.runtimeEnvironmentId,
+          projectId: worker.projectId,
+          rateLimit: task.queue?.rateLimit,
+          type: task.queue?.name ? "NAMED" : "VIRTUAL",
         },
-      },
-      update: {
-        concurrencyLimit: task.queue?.concurrencyLimit,
-        rateLimit: task.queue?.rateLimit,
-      },
-      create: {
-        friendlyId: generateFriendlyId("queue"),
-        name: queueName,
-        concurrencyLimit: task.queue?.concurrencyLimit,
-        runtimeEnvironmentId: worker.runtimeEnvironmentId,
-        projectId: worker.projectId,
-        rateLimit: task.queue?.rateLimit,
-        type: task.queue?.name ? "NAMED" : "VIRTUAL",
-      },
-    });
+      });
 
-    if (taskQueue.concurrencyLimit) {
-      await marqs?.updateQueueConcurrency(env, taskQueue.name, taskQueue.concurrencyLimit);
+      if (taskQueue.concurrencyLimit) {
+        await marqs?.updateQueueConcurrency(env, taskQueue.name, taskQueue.concurrencyLimit);
+      }
+    } catch (error) {
+      if (error instanceof Prisma.PrismaClientKnownRequestError) {
+        // The error code for unique constraint violation in Prisma is P2002
+        if (error.code === "P2002") {
+          logger.warn("Task already exists", {
+            task,
+            worker,
+          });
+        } else {
+          logger.error("Prisma Error creating background worker task", {
+            error: {
+              code: error.code,
+              message: error.message,
+            },
+            task,
+            worker,
+          });
+        }
+      } else if (error instanceof Error) {
+        logger.error("Error creating background worker task", {
+          error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+          },
+          task,
+          worker,
+        });
+      } else {
+        logger.error("Unknown error creating background worker task", {
+          error,
+          task,
+          worker,
+        });
+      }
     }
   }
 }