trigger.dev 3.0.0-beta.4 → 3.0.0-beta.40

package/dist/templates/trigger.config.ts.template

@@ -4,7 +4,7 @@ export const config: TriggerConfig = {
   project: "${projectRef}",
   logLevel: "log",
   retries: {
-    enabledInDev: false,
+    enabledInDev: true,
     default: {
       maxAttempts: 3,
       minTimeoutInMs: 1000,

package/dist/workers/dev/worker-facade.js

@@ -1,36 +1,40 @@
 // src/workers/dev/worker-facade.ts
 import {
-  TaskExecutor,
-  DurableClock,
   clock,
-  logLevels,
-  getEnvVar,
-  ZodSchemaParsedError
+  taskCatalog
 } from "@trigger.dev/core/v3";
 import {
-  ConsoleInterceptor,
-  DevRuntimeManager,
+  TaskExecutor,
+  DurableClock,
+  getEnvVar,
+  logLevels,
   OtelTaskLogger,
+  ConsoleInterceptor,
+  usage,
+  DevUsageManager
+} from "@trigger.dev/core/v3/workers";
+import {
   TaskRunErrorCodes,
   TriggerTracer,
-  ZodMessageHandler,
   logger,
   runtime,
   workerToChildMessages
 } from "@trigger.dev/core/v3";
-
-// package.json
-var version = "3.0.0-beta.4";
-
-// src/workers/dev/worker-facade.ts
+import { DevRuntimeManager } from "@trigger.dev/core/v3/dev";
+import {
+  ZodMessageHandler,
+  ZodSchemaParsedError
+} from "@trigger.dev/core/v3/zodMessageHandler";
 __WORKER_SETUP__;
 __IMPORTED_PROJECT_CONFIG__;
-var otelTracer = tracingSDK.getTracer("trigger-dev-worker", version);
-var otelLogger = tracingSDK.getLogger("trigger-dev-worker", version);
 var durableClock = new DurableClock();
 clock.setGlobalClock(durableClock);
+usage.setGlobalUsageManager(new DevUsageManager());
 var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
-var consoleInterceptor = new ConsoleInterceptor(otelLogger);
+var consoleInterceptor = new ConsoleInterceptor(
+  otelLogger,
+  typeof __PROJECT_CONFIG__.enableConsoleLogging === "boolean" ? __PROJECT_CONFIG__.enableConsoleLogging : true
+);
 var devRuntimeManager = new DevRuntimeManager();
 runtime.setGlobalRuntimeManager(devRuntimeManager);
 var triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
@@ -38,56 +42,27 @@ var configLogLevel = triggerLogLevel ? triggerLogLevel : importedConfig ? import
 var otelTaskLogger = new OtelTaskLogger({
   logger: otelLogger,
   tracer,
-  level: logLevels.includes(configLogLevel) ? configLogLevel : "log"
+  level: logLevels.includes(configLogLevel) ? configLogLevel : "info"
 });
 logger.setGlobalTaskLogger(otelTaskLogger);
 var TaskFileImports = {};
 var TaskFiles = {};
 __TASKS__;
-function getTasks() {
-  const result = [];
+(() => {
   for (const [importName, taskFile] of Object.entries(TaskFiles)) {
     const fileImports = TaskFileImports[importName];
     for (const [exportName, task] of Object.entries(fileImports ?? {})) {
-      if (task.__trigger) {
-        result.push({
-          id: task.__trigger.id,
-          exportName,
-          packageVersion: task.__trigger.packageVersion,
-          filePath: taskFile.filePath,
-          queue: task.__trigger.queue,
-          retry: task.__trigger.retry,
-          machine: task.__trigger.machine,
-          fns: task.__trigger.fns
-        });
+      if (typeof task === "object" && task !== null && "id" in task && typeof task.id === "string") {
+        if (taskCatalog.taskExists(task.id)) {
+          taskCatalog.registerTaskFileMetadata(task.id, {
+            exportName,
+            filePath: taskFile.filePath
+          });
+        }
       }
     }
   }
-  return result;
-}
-function getTaskMetadata() {
-  const result = getTasks();
-  return result.map((task) => {
-    const { fns, ...metadata } = task;
-    return metadata;
-  });
-}
-var tasks = getTasks();
-runtime.registerTasks(tasks);
-var taskExecutors = /* @__PURE__ */ new Map();
-for (const task of tasks) {
-  taskExecutors.set(
-    task.id,
-    new TaskExecutor(task, {
-      tracer,
-      tracingSDK,
-      consoleInterceptor,
-      projectConfig: __PROJECT_CONFIG__,
-      importedConfig,
-      handleErrorFn: handleError
-    })
-  );
-}
+})();
 var _execution;
 var _isRunning = false;
 var handler = new ZodMessageHandler({
@@ -100,47 +75,77 @@ var handler = new ZodMessageHandler({
           execution,
           result: {
             ok: false,
-            id: execution.attempt.id,
+            id: execution.run.id,
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
+            },
+            usage: {
+              durationMs: 0
             }
           }
         });
         return;
       }
       process.title = `trigger-dev-worker: ${execution.task.id} ${execution.run.id}`;
-      const executor = taskExecutors.get(execution.task.id);
-      if (!executor) {
-        console.error(`Could not find executor for task ${execution.task.id}`);
+      const task = taskCatalog.getTask(execution.task.id);
+      if (!task) {
+        console.error(`Could not find task ${execution.task.id}`);
         await sender.send("TASK_RUN_COMPLETED", {
           execution,
           result: {
             ok: false,
-            id: execution.attempt.id,
+            id: execution.run.id,
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
+            },
+            usage: {
+              durationMs: 0
             }
           }
         });
         return;
       }
+      const executor = new TaskExecutor(task, {
+        tracer,
+        tracingSDK,
+        consoleInterceptor,
+        projectConfig: __PROJECT_CONFIG__,
+        importedConfig,
+        handleErrorFn: handleError
+      });
       try {
         _execution = execution;
         _isRunning = true;
-        const result = await executor.execute(execution, metadata, traceContext);
+        const measurement = usage.start();
+        const { result } = await executor.execute(execution, metadata, traceContext, measurement);
+        const usageSample = usage.stop(measurement);
         return sender.send("TASK_RUN_COMPLETED", {
           execution,
-          result
+          result: {
+            ...result,
+            usage: {
+              durationMs: usageSample.cpuTime
+            }
+          }
         });
       } finally {
         _execution = void 0;
         _isRunning = false;
       }
     },
-    TASK_RUN_COMPLETED_NOTIFICATION: async ({ completion, execution }) => {
-      devRuntimeManager.resumeTask(completion, execution);
+    TASK_RUN_COMPLETED_NOTIFICATION: async (payload) => {
+      switch (payload.version) {
+        case "v1": {
+          devRuntimeManager.resumeTask(payload.completion, payload.execution.run.id);
+          break;
+        }
+        case "v2": {
+          devRuntimeManager.resumeTask(payload.completion, payload.completion.id);
+          break;
+        }
+      }
     },
     CLEANUP: async ({ flush, kill }) => {
       if (kill) {
@@ -157,7 +162,7 @@ var handler = new ZodMessageHandler({
 process.on("message", async (msg) => {
   await handler.handleMessage(msg);
 });
-var TASK_METADATA = getTaskMetadata();
+var TASK_METADATA = taskCatalog.getAllTaskMetadata();
 sender.send("TASKS_READY", { tasks: TASK_METADATA }).catch((err) => {
   if (err instanceof ZodSchemaParsedError) {
     sender.send("TASKS_FAILED_TO_PARSE", { zodIssues: err.error.issues, tasks: TASK_METADATA });
@@ -166,7 +171,7 @@ sender.send("TASKS_READY", { tasks: TASK_METADATA }).catch((err) => {
   }
 });
 process.title = "trigger-dev-worker";
-async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 5) {
+async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 30) {
   async function _doHeartbeat() {
     while (true) {
       if (_isRunning && _execution) {

package/dist/workers/dev/worker-setup.js

@@ -1,40 +1,35 @@
 // src/workers/dev/worker-setup.ts
-import "source-map-support/register.js";
-import { Resource } from "@opentelemetry/resources";
+import { childToWorkerMessages, taskCatalog } from "@trigger.dev/core/v3";
 import {
-  SemanticInternalAttributes,
-  TracingSDK,
-  ZodMessageSender,
-  childToWorkerMessages
-} from "@trigger.dev/core/v3";
+  StandardTaskCatalog,
+  TracingSDK
+} from "@trigger.dev/core/v3/workers";
+import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
+import "source-map-support/register.js";
+
+// package.json
+var version = "3.0.0-beta.40";
+
+// src/workers/dev/worker-setup.ts
 __SETUP_IMPORTED_PROJECT_CONFIG__;
 var tracingSDK = new TracingSDK({
   url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318",
-  resource: new Resource({
-    [SemanticInternalAttributes.CLI_VERSION]: "3.0.0"
-  }),
   instrumentations: setupImportedConfig?.instrumentations ?? [],
-  diagLogLevel: process.env.OTEL_LOG_LEVEL ?? "none"
+  diagLogLevel: process.env.OTEL_LOG_LEVEL ?? "none",
+  forceFlushTimeoutMillis: 5e3
 });
+var otelTracer = tracingSDK.getTracer("trigger-dev-worker", version);
+var otelLogger = tracingSDK.getLogger("trigger-dev-worker", version);
 var sender = new ZodMessageSender({
   schema: childToWorkerMessages,
   sender: async (message) => {
     process.send?.(message);
   }
 });
-process.on("uncaughtException", (error, origin) => {
-  sender.send("UNCAUGHT_EXCEPTION", {
-    error: {
-      name: error.name,
-      message: error.message,
-      stack: error.stack
-    },
-    origin
-  }).catch((err) => {
-    console.error("Failed to send UNCAUGHT_EXCEPTION message", err);
-  });
-});
+taskCatalog.setGlobalTaskCatalog(new StandardTaskCatalog());
 export {
+  otelLogger,
+  otelTracer,
   sender,
   tracingSDK
 };