@trigger.dev/core 0.0.0-v3-prerelease-20240424101411 → 0.0.0-v3-prerelease-20240425102616

package/dist/v3/workers/index.mjs

@@ -1,5 +1,4 @@
 import { SpanStatusCode, DiagLogLevel, diag, DiagConsoleLogger, propagation, context, SpanKind } from '@opentelemetry/api';
-import 'node:path';
 import { logs, SeverityNumber } from '@opentelemetry/api-logs';
 import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
@@ -38,6 +37,8 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
+
+// src/v3/errors.ts
 function parseError(error) {
   if (error instanceof Error) {
     return {
@@ -1968,11 +1969,18 @@ function accessoryAttributes(accessory) {
 __name(accessoryAttributes, "accessoryAttributes");
 
 // src/v3/workers/taskExecutor.ts
-var _callRun, callRun_fn, _callTaskInit, callTaskInit_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
+var _callRun, callRun_fn, _callInitFunctions, callInitFunctions_fn, _callConfigInit, callConfigInit_fn, _callOnSuccessFunctions, callOnSuccessFunctions_fn, _callOnSuccessFunction, callOnSuccessFunction_fn, _callOnFailureFunctions, callOnFailureFunctions_fn, _callOnFailureFunction, callOnFailureFunction_fn, _callOnStartFunctions, callOnStartFunctions_fn, _callOnStartFunction, callOnStartFunction_fn, _callTaskCleanup, callTaskCleanup_fn, _handleError, handleError_fn;
 var _TaskExecutor = class _TaskExecutor {
   constructor(task, options) {
     __privateAdd(this, _callRun);
-    __privateAdd(this, _callTaskInit);
+    __privateAdd(this, _callInitFunctions);
+    __privateAdd(this, _callConfigInit);
+    __privateAdd(this, _callOnSuccessFunctions);
+    __privateAdd(this, _callOnSuccessFunction);
+    __privateAdd(this, _callOnFailureFunctions);
+    __privateAdd(this, _callOnFailureFunction);
+    __privateAdd(this, _callOnStartFunctions);
+    __privateAdd(this, _callOnStartFunction);
     __privateAdd(this, _callTaskCleanup);
     __privateAdd(this, _handleError);
     this.task = task;
@@ -2006,8 +2014,12 @@ var _TaskExecutor = class _TaskExecutor {
         try {
           const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
           parsedPayload = await parsePacket(payloadPacket);
-          initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          if (execution.attempt.number === 1) {
+            await __privateMethod(this, _callOnStartFunctions, callOnStartFunctions_fn).call(this, parsedPayload, ctx);
+          }
+          initOutput = await __privateMethod(this, _callInitFunctions, callInitFunctions_fn).call(this, parsedPayload, ctx);
           const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
+          await __privateMethod(this, _callOnSuccessFunctions, callOnSuccessFunctions_fn).call(this, parsedPayload, output, ctx, initOutput);
           try {
             const stringifiedOutput = await stringifyIO(output);
             const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
@@ -2037,6 +2049,9 @@ var _TaskExecutor = class _TaskExecutor {
           try {
             const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
             recordSpanException(span, handleErrorResult.error ?? runError);
+            if (handleErrorResult.status !== "retry") {
+              await __privateMethod(this, _callOnFailureFunctions, callOnFailureFunctions_fn).call(this, parsedPayload, handleErrorResult.error ?? runError, ctx, initOutput);
+            }
             return {
               id: execution.run.id,
               ok: false,
@@ -2100,8 +2115,9 @@ callRun_fn = /* @__PURE__ */ __name(async function(payload, ctx, init) {
     })
   });
 }, "#callRun");
-_callTaskInit = new WeakSet();
-callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+_callInitFunctions = new WeakSet();
+callInitFunctions_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
+  await __privateMethod(this, _callConfigInit, callConfigInit_fn).call(this, payload1, ctx1);
   const initFn = this.task.fns.init;
   if (!initFn) {
     return {};
@@ -2110,23 +2126,114 @@ callTaskInit_fn = /* @__PURE__ */ __name(async function(payload1, ctx1) {
     return await initFn(payload1, {
       ctx: ctx1
     });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
+  });
+}, "#callInitFunctions");
+_callConfigInit = new WeakSet();
+callConfigInit_fn = /* @__PURE__ */ __name(async function(payload2, ctx2) {
+  const initFn = this._importedConfig?.init;
+  if (!initFn) {
+    return {};
+  }
+  return this._tracer.startActiveSpan("config.init", async (span) => {
+    return await initFn(payload2, {
+      ctx: ctx2
+    });
+  }, {
+    attributes: {
+      [SemanticInternalAttributes.STYLE_ICON]: "function"
+    }
   });
-}, "#callTaskInit");
+}, "#callConfigInit");
+_callOnSuccessFunctions = new WeakSet();
+callOnSuccessFunctions_fn = /* @__PURE__ */ __name(async function(payload3, output, ctx3, initOutput) {
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this.task.fns.onSuccess, "task.onSuccess", payload3, output, ctx3, initOutput);
+  await __privateMethod(this, _callOnSuccessFunction, callOnSuccessFunction_fn).call(this, this._importedConfig?.onSuccess, "config.onSuccess", payload3, output, ctx3, initOutput);
+}, "#callOnSuccessFunctions");
+_callOnSuccessFunction = new WeakSet();
+callOnSuccessFunction_fn = /* @__PURE__ */ __name(async function(onSuccessFn, name, payload4, output1, ctx4, initOutput1) {
+  if (!onSuccessFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name, async (span) => {
+      return await onSuccessFn(payload4, output1, {
+        ctx: ctx4,
+        init: initOutput1
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnSuccessFunction");
+_callOnFailureFunctions = new WeakSet();
+callOnFailureFunctions_fn = /* @__PURE__ */ __name(async function(payload5, error, ctx5, initOutput2) {
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this.task.fns.onFailure, "task.onFailure", payload5, error, ctx5, initOutput2);
+  await __privateMethod(this, _callOnFailureFunction, callOnFailureFunction_fn).call(this, this._importedConfig?.onFailure, "config.onFailure", payload5, error, ctx5, initOutput2);
+}, "#callOnFailureFunctions");
+_callOnFailureFunction = new WeakSet();
+callOnFailureFunction_fn = /* @__PURE__ */ __name(async function(onFailureFn, name1, payload6, error1, ctx6, initOutput3) {
+  if (!onFailureFn) {
+    return;
+  }
+  try {
+    return await this._tracer.startActiveSpan(name1, async (span) => {
+      return await onFailureFn(payload6, error1, {
+        ctx: ctx6,
+        init: initOutput3
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch (e) {
+  }
+}, "#callOnFailureFunction");
+_callOnStartFunctions = new WeakSet();
+callOnStartFunctions_fn = /* @__PURE__ */ __name(async function(payload7, ctx7) {
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this._importedConfig?.onStart, "config.onStart", payload7, ctx7, {});
+  await __privateMethod(this, _callOnStartFunction, callOnStartFunction_fn).call(this, this.task.fns.onStart, "task.onStart", payload7, ctx7, {});
+}, "#callOnStartFunctions");
+_callOnStartFunction = new WeakSet();
+callOnStartFunction_fn = /* @__PURE__ */ __name(async function(onStartFn, name2, payload8, ctx8, initOutput4) {
+  if (!onStartFn) {
+    return;
+  }
+  try {
+    await this._tracer.startActiveSpan(name2, async (span) => {
+      return await onStartFn(payload8, {
+        ctx: ctx8
+      });
+    }, {
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "function"
+      }
+    });
+  } catch {
+  }
+}, "#callOnStartFunction");
 _callTaskCleanup = new WeakSet();
-callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload2, ctx2, init1) {
+callTaskCleanup_fn = /* @__PURE__ */ __name(async function(payload9, ctx9, init1) {
   const cleanupFn = this.task.fns.cleanup;
   if (!cleanupFn) {
     return;
   }
   return this._tracer.startActiveSpan("cleanup", async (span) => {
-    return await cleanupFn(payload2, {
-      ctx: ctx2,
+    return await cleanupFn(payload9, {
+      ctx: ctx9,
       init: init1
     });
   });
 }, "#callTaskCleanup");
 _handleError = new WeakSet();
-handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload3, ctx3) {
+handleError_fn = /* @__PURE__ */ __name(async function(execution, error2, payload10, ctx10) {
   const retriesConfig = this._importedConfig?.retries ?? this._config.retries;
   const retry = this.task.retry ?? retriesConfig?.default;
   if (!retry) {
@@ -2141,13 +2248,13 @@ handleError_fn = /* @__PURE__ */ __name(async function(execution, error, payload
     };
   }
   return this._tracer.startActiveSpan("handleError()", async (span) => {
-    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload3, error, {
-      ctx: ctx3,
+    const handleErrorResult = this.task.fns.handleError ? await this.task.fns.handleError(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0
-    }) : this._importedConfig ? await this._handleErrorFn?.(payload3, error, {
-      ctx: ctx3,
+    }) : this._importedConfig ? await this._handleErrorFn?.(payload10, error2, {
+      ctx: ctx10,
       retry,
       retryDelayInMs: delay,
       retryAt: delay ? new Date(Date.now() + delay) : void 0