@trigger.dev/core 0.0.0-v3-trigger-dirs-20240423091017 → 0.0.0-v3-trigger-dirs-20240423123825

package/dist/v3/workers/index.js

@@ -2,10 +2,23 @@
 
 var api = require('@opentelemetry/api');
 require('path');
-var async_hooks = require('async_hooks');
+var apiLogs = require('@opentelemetry/api-logs');
+var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var instrumentation = require('@opentelemetry/instrumentation');
+var resources = require('@opentelemetry/resources');
+var sdkLogs = require('@opentelemetry/sdk-logs');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
 var zod = require('zod');
 var zodValidationError = require('zod-validation-error');
+var async_hooks = require('async_hooks');
 var preciseDate = require('@google-cloud/precise-date');
+var util = require('util');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var util__default = /*#__PURE__*/_interopDefault(util);
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -61,6 +74,14 @@ function parseError(error) {
 __name(parseError, "parseError");
 
 // src/v3/limits.ts
+var OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_LOG_ATTRIBUTE_COUNT_LIMIT = 256;
+var OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT = 1028;
+var OTEL_SPAN_EVENT_COUNT_LIMIT = 10;
+var OTEL_LINK_COUNT_LIMIT = 2;
+var OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT = 10;
+var OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT = 10;
 var OFFLOAD_IO_PACKET_LENGTH_LIMIT = 128 * 1024;
 
 // src/v3/semanticInternalAttributes.ts
@@ -153,37 +174,55 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 __name(isRecord, "isRecord");
-var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
-  constructor() {
-    this.storage = new async_hooks.AsyncLocalStorage();
-  }
-  runWith(context2, fn) {
-    return this.storage.run(context2, fn);
-  }
-  getStore() {
-    return this.storage.getStore();
+
+// src/v3/utils/platform.ts
+var _globalThis = typeof globalThis === "object" ? globalThis : global;
+
+// src/v3/utils/globals.ts
+var GLOBAL_TRIGGER_DOT_DEV_KEY = Symbol.for(`dev.trigger.ts.api`);
+var _global = _globalThis;
+function registerGlobal(type, instance, allowOverride = false) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] = _global[GLOBAL_TRIGGER_DOT_DEV_KEY] ?? {};
+  if (!allowOverride && api[type]) {
+    return false;
+  }
+  api[type] = instance;
+  return true;
+}
+__name(registerGlobal, "registerGlobal");
+function getGlobal(type) {
+  return _global[GLOBAL_TRIGGER_DOT_DEV_KEY]?.[type];
+}
+__name(getGlobal, "getGlobal");
+function unregisterGlobal(type) {
+  const api = _global[GLOBAL_TRIGGER_DOT_DEV_KEY];
+  if (api) {
+    delete api[type];
   }
-};
-__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
-var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
+}
+__name(unregisterGlobal, "unregisterGlobal");
 
-// src/v3/tasks/taskContextManager.ts
-var _getStore, getStore_fn;
-var _TaskContextManager = class _TaskContextManager {
+// src/v3/taskContext/index.ts
+var API_NAME = "task-context";
+var _getTaskContext, getTaskContext_fn;
+var _TaskContextAPI = class _TaskContextAPI {
   constructor() {
-    __privateAdd(this, _getStore);
-    __publicField(this, "_storage", new SafeAsyncLocalStorage());
+    __privateAdd(this, _getTaskContext);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TaskContextAPI();
+    }
+    return this._instance;
   }
   get isInsideTask() {
-    return __privateMethod(this, _getStore, getStore_fn).call(this) !== void 0;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this) !== void 0;
   }
   get ctx() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.ctx;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.ctx;
   }
   get worker() {
-    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
-    return store?.worker;
+    return __privateMethod(this, _getTaskContext, getTaskContext_fn).call(this)?.worker;
   }
   get attributes() {
     if (this.ctx) {
@@ -229,27 +268,34 @@ var _TaskContextManager = class _TaskContextManager {
     }
     return {};
   }
-  runWith(context2, fn) {
-    return this._storage.runWith(context2, fn);
+  disable() {
+    unregisterGlobal(API_NAME);
+  }
+  setGlobalTaskContext(taskContext2) {
+    return registerGlobal(API_NAME, taskContext2);
   }
 };
-_getStore = new WeakSet();
-getStore_fn = /* @__PURE__ */ __name(function() {
-  return this._storage.getStore();
-}, "#getStore");
-__name(_TaskContextManager, "TaskContextManager");
-var TaskContextManager = _TaskContextManager;
-var taskContextManager = new TaskContextManager();
+_getTaskContext = new WeakSet();
+getTaskContext_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME);
+}, "#getTaskContext");
+__name(_TaskContextAPI, "TaskContextAPI");
+var TaskContextAPI = _TaskContextAPI;
+
+// src/v3/task-context-api.ts
+var taskContext = TaskContextAPI.getInstance();
+
+// src/v3/taskContext/otelProcessors.ts
 var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
   constructor(innerProcessor) {
     this._innerProcessor = innerProcessor;
   }
   // Called when a span starts
   onStart(span, parentContext) {
-    if (taskContextManager.ctx) {
+    if (taskContext.ctx) {
       span.setAttributes(flattenAttributes({
-        [SemanticInternalAttributes.ATTEMPT_ID]: taskContextManager.ctx.attempt.id,
-        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContextManager.ctx.attempt.number
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContext.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContext.ctx.attempt.number
       }, SemanticInternalAttributes.METADATA));
     }
     this._innerProcessor.onStart(span, parentContext);
@@ -267,6 +313,28 @@ var _TaskContextSpanProcessor = class _TaskContextSpanProcessor {
 };
 __name(_TaskContextSpanProcessor, "TaskContextSpanProcessor");
 var TaskContextSpanProcessor = _TaskContextSpanProcessor;
+var _TaskContextLogProcessor = class _TaskContextLogProcessor {
+  constructor(innerProcessor) {
+    this._innerProcessor = innerProcessor;
+  }
+  forceFlush() {
+    return this._innerProcessor.forceFlush();
+  }
+  onEmit(logRecord, context2) {
+    if (taskContext.ctx) {
+      logRecord.setAttributes(flattenAttributes({
+        [SemanticInternalAttributes.ATTEMPT_ID]: taskContext.ctx.attempt.id,
+        [SemanticInternalAttributes.ATTEMPT_NUMBER]: taskContext.ctx.attempt.number
+      }, SemanticInternalAttributes.METADATA));
+    }
+    this._innerProcessor.onEmit(logRecord, context2);
+  }
+  shutdown() {
+    return this._innerProcessor.shutdown();
+  }
+};
+__name(_TaskContextLogProcessor, "TaskContextLogProcessor");
+var TaskContextLogProcessor = _TaskContextLogProcessor;
 
 // src/v3/utils/getEnv.ts
 function getEnvVar(name) {
@@ -276,6 +344,137 @@ function getEnvVar(name) {
 }
 __name(getEnvVar, "getEnvVar");
 
+// src/v3/otel/tracingSDK.ts
+var _a;
+var AsyncResourceDetector = (_a = class {
+  constructor() {
+    __publicField(this, "_resolved", false);
+    this._promise = new Promise((resolver) => {
+      this._resolver = resolver;
+    });
+  }
+  detect(_config) {
+    return new resources.Resource({}, this._promise);
+  }
+  resolveWithAttributes(attributes) {
+    if (!this._resolver) {
+      throw new Error("Resolver not available");
+    }
+    if (this._resolved) {
+      return;
+    }
+    this._resolved = true;
+    this._resolver(attributes);
+  }
+}, __name(_a, "AsyncResourceDetector"), _a);
+var _TracingSDK = class _TracingSDK {
+  constructor(config) {
+    this.config = config;
+    this.asyncResourceDetector = new AsyncResourceDetector();
+    setLogLevel(config.diagLogLevel ?? "none");
+    const envResourceAttributesSerialized = getEnvVar("OTEL_RESOURCE_ATTRIBUTES");
+    const envResourceAttributes = envResourceAttributesSerialized ? JSON.parse(envResourceAttributesSerialized) : {};
+    const commonResources = resources.detectResourcesSync({
+      detectors: [
+        this.asyncResourceDetector,
+        resources.processDetectorSync
+      ]
+    }).merge(new resources.Resource({
+      [semanticConventions.SemanticResourceAttributes.CLOUD_PROVIDER]: "trigger.dev",
+      [SemanticInternalAttributes.TRIGGER]: true
+    })).merge(config.resource ?? new resources.Resource({})).merge(new resources.Resource(envResourceAttributes));
+    const traceProvider = new sdkTraceNode.NodeTracerProvider({
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
+      resource: commonResources,
+      spanLimits: {
+        attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+        eventCountLimit: OTEL_SPAN_EVENT_COUNT_LIMIT,
+        attributePerEventCountLimit: OTEL_ATTRIBUTE_PER_EVENT_COUNT_LIMIT,
+        linkCountLimit: OTEL_LINK_COUNT_LIMIT,
+        attributePerLinkCountLimit: OTEL_ATTRIBUTE_PER_LINK_COUNT_LIMIT
+      }
+    });
+    const spanExporter = new exporterTraceOtlpHttp.OTLPTraceExporter({
+      url: `${config.url}/v1/traces`,
+      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
+    });
+    traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkTraceNode.BatchSpanProcessor(spanExporter, {
+      maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
+      scheduledDelayMillis: parseInt(getEnvVar("OTEL_SPAN_SCHEDULED_DELAY_MILLIS") ?? "200"),
+      exportTimeoutMillis: parseInt(getEnvVar("OTEL_SPAN_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
+      maxQueueSize: parseInt(getEnvVar("OTEL_SPAN_MAX_QUEUE_SIZE") ?? "512")
+    }) : new sdkTraceNode.SimpleSpanProcessor(spanExporter)));
+    traceProvider.register();
+    instrumentation.registerInstrumentations({
+      instrumentations: config.instrumentations ?? [],
+      tracerProvider: traceProvider
+    });
+    const logExporter = new exporterLogsOtlpHttp.OTLPLogExporter({
+      url: `${config.url}/v1/logs`
+    });
+    const loggerProvider = new sdkLogs.LoggerProvider({
+      resource: commonResources,
+      logRecordLimits: {
+        attributeCountLimit: OTEL_LOG_ATTRIBUTE_COUNT_LIMIT,
+        attributeValueLengthLimit: OTEL_LOG_ATTRIBUTE_VALUE_LENGTH_LIMIT
+      }
+    });
+    loggerProvider.addLogRecordProcessor(new TaskContextLogProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new sdkLogs.BatchLogRecordProcessor(logExporter, {
+      maxExportBatchSize: parseInt(getEnvVar("OTEL_LOG_MAX_EXPORT_BATCH_SIZE") ?? "64"),
+      scheduledDelayMillis: parseInt(getEnvVar("OTEL_LOG_SCHEDULED_DELAY_MILLIS") ?? "200"),
+      exportTimeoutMillis: parseInt(getEnvVar("OTEL_LOG_EXPORT_TIMEOUT_MILLIS") ?? "30000"),
+      maxQueueSize: parseInt(getEnvVar("OTEL_LOG_MAX_QUEUE_SIZE") ?? "512")
+    }) : new sdkLogs.SimpleLogRecordProcessor(logExporter)));
+    this._logProvider = loggerProvider;
+    this._spanExporter = spanExporter;
+    this._traceProvider = traceProvider;
+    apiLogs.logs.setGlobalLoggerProvider(loggerProvider);
+    this.getLogger = loggerProvider.getLogger.bind(loggerProvider);
+    this.getTracer = traceProvider.getTracer.bind(traceProvider);
+  }
+  async flush() {
+    await this._traceProvider.forceFlush();
+    await this._logProvider.forceFlush();
+  }
+  async shutdown() {
+    await this._traceProvider.shutdown();
+    await this._logProvider.shutdown();
+  }
+};
+__name(_TracingSDK, "TracingSDK");
+var TracingSDK = _TracingSDK;
+function setLogLevel(level) {
+  let diagLogLevel;
+  switch (level) {
+    case "none":
+      diagLogLevel = api.DiagLogLevel.NONE;
+      break;
+    case "error":
+      diagLogLevel = api.DiagLogLevel.ERROR;
+      break;
+    case "warn":
+      diagLogLevel = api.DiagLogLevel.WARN;
+      break;
+    case "info":
+      diagLogLevel = api.DiagLogLevel.INFO;
+      break;
+    case "debug":
+      diagLogLevel = api.DiagLogLevel.DEBUG;
+      break;
+    case "verbose":
+      diagLogLevel = api.DiagLogLevel.VERBOSE;
+      break;
+    case "all":
+      diagLogLevel = api.DiagLogLevel.ALL;
+      break;
+    default:
+      diagLogLevel = api.DiagLogLevel.NONE;
+  }
+  api.diag.setLogger(new api.DiagConsoleLogger(), diagLogLevel);
+}
+__name(setLogLevel, "setLogLevel");
+
 // src/v3/otel/index.ts
 function recordSpanException(span, error) {
   if (error instanceof Error) {
@@ -1360,6 +1559,19 @@ function requestInitWithCache(requestInit) {
   }
 }
 __name(requestInitWithCache, "requestInitWithCache");
+var _SafeAsyncLocalStorage = class _SafeAsyncLocalStorage {
+  constructor() {
+    this.storage = new async_hooks.AsyncLocalStorage();
+  }
+  runWith(context2, fn) {
+    return this.storage.run(context2, fn);
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+};
+__name(_SafeAsyncLocalStorage, "SafeAsyncLocalStorage");
+var SafeAsyncLocalStorage = _SafeAsyncLocalStorage;
 
 // src/v3/apiClient/index.ts
 var zodFetchOptions = {
@@ -1495,7 +1707,7 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
     "Content-Type": "application/json",
     Authorization: `Bearer ${this.accessToken}`
   };
-  if (taskContextManager.isInsideTask) {
+  if (taskContext.isInsideTask) {
     api.propagation.inject(api.context.active(), headers);
     if (spanParentAsLink) {
       headers["x-trigger-span-parent-as-link"] = "1";
@@ -1505,18 +1717,18 @@ getHeaders_fn = /* @__PURE__ */ __name(function(spanParentAsLink) {
 }, "#getHeaders");
 __name(_ApiClient, "ApiClient");
 var ApiClient = _ApiClient;
-var _getStore2, getStore_fn2;
+var _getStore, getStore_fn;
 var _ApiClientManager = class _ApiClientManager {
   constructor() {
-    __privateAdd(this, _getStore2);
+    __privateAdd(this, _getStore);
     __publicField(this, "_storage", new SafeAsyncLocalStorage());
   }
   get baseURL() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.baseURL ?? getEnvVar("TRIGGER_API_URL") ?? "https://api.trigger.dev";
   }
   get accessToken() {
-    const store = __privateMethod(this, _getStore2, getStore_fn2).call(this);
+    const store = __privateMethod(this, _getStore, getStore_fn).call(this);
     return store?.accessToken ?? getEnvVar("TRIGGER_SECRET_KEY");
   }
   get client() {
@@ -1529,8 +1741,8 @@ var _ApiClientManager = class _ApiClientManager {
     return this._storage.runWith(context2, fn);
   }
 };
-_getStore2 = new WeakSet();
-getStore_fn2 = /* @__PURE__ */ __name(function() {
+_getStore = new WeakSet();
+getStore_fn = /* @__PURE__ */ __name(function() {
   return this._storage.getStore();
 }, "#getStore");
 __name(_ApiClientManager, "ApiClientManager");
@@ -1784,94 +1996,93 @@ var _TaskExecutor = class _TaskExecutor {
       data: execution.run.payload,
       dataType: execution.run.payloadType
     };
-    const result = await taskContextManager.runWith({
+    taskContext.setGlobalTaskContext({
       ctx,
       worker
-    }, async () => {
-      this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
-        ...taskContextManager.attributes,
-        [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
-        [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
-      });
-      return await this._tracer.startActiveSpan(attemptMessage, async (span) => {
-        return await this._consoleInterceptor.intercept(console, async () => {
-          let parsedPayload;
-          let initOutput;
+    });
+    this._tracingSDK.asyncResourceDetector.resolveWithAttributes({
+      ...taskContext.attributes,
+      [SemanticInternalAttributes.SDK_VERSION]: this.task.packageVersion,
+      [SemanticInternalAttributes.SDK_LANGUAGE]: "typescript"
+    });
+    const result = await this._tracer.startActiveSpan(attemptMessage, async (span) => {
+      return await this._consoleInterceptor.intercept(console, async () => {
+        let parsedPayload;
+        let initOutput;
+        try {
+          const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
+          parsedPayload = await parsePacket(payloadPacket);
+          initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
+          const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
           try {
-            const payloadPacket = await conditionallyImportPacket(originalPacket, this._tracer);
-            parsedPayload = await parsePacket(payloadPacket);
-            initOutput = await __privateMethod(this, _callTaskInit, callTaskInit_fn).call(this, parsedPayload, ctx);
-            const output = await __privateMethod(this, _callRun, callRun_fn).call(this, parsedPayload, ctx, initOutput);
-            try {
-              const stringifiedOutput = await stringifyIO(output);
-              const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
-              const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
-              if (attributes) {
-                span.setAttributes(attributes);
-              }
-              return {
-                ok: true,
-                id: execution.run.id,
-                output: finalOutput.data,
-                outputType: finalOutput.dataType
-              };
-            } catch (stringifyError) {
-              recordSpanException(span, stringifyError);
-              return {
-                ok: false,
-                id: execution.run.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
-                  message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
-                }
-              };
+            const stringifiedOutput = await stringifyIO(output);
+            const finalOutput = await conditionallyExportPacket(stringifiedOutput, `${execution.attempt.id}/output`, this._tracer);
+            const attributes = await createPacketAttributes(finalOutput, SemanticInternalAttributes.OUTPUT, SemanticInternalAttributes.OUTPUT_TYPE);
+            if (attributes) {
+              span.setAttributes(attributes);
             }
-          } catch (runError) {
-            try {
-              const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
-              recordSpanException(span, handleErrorResult.error ?? runError);
-              return {
-                id: execution.run.id,
-                ok: false,
-                error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
-                retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
-                skippedRetrying: handleErrorResult.status === "skipped"
-              };
-            } catch (handleErrorError) {
-              recordSpanException(span, handleErrorError);
-              return {
-                ok: false,
-                id: execution.run.id,
-                error: {
-                  type: "INTERNAL_ERROR",
-                  code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
-                  message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
-                }
-              };
-            }
-          } finally {
-            await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
+            return {
+              ok: true,
+              id: execution.run.id,
+              output: finalOutput.data,
+              outputType: finalOutput.dataType
+            };
+          } catch (stringifyError) {
+            recordSpanException(span, stringifyError);
+            return {
+              ok: false,
+              id: execution.run.id,
+              error: {
+                type: "INTERNAL_ERROR",
+                code: TaskRunErrorCodes.TASK_OUTPUT_ERROR,
+                message: stringifyError instanceof Error ? stringifyError.message : typeof stringifyError === "string" ? stringifyError : void 0
+              }
+            };
           }
-        });
-      }, {
-        kind: api.SpanKind.CONSUMER,
-        attributes: {
-          [SemanticInternalAttributes.STYLE_ICON]: "attempt",
-          ...accessoryAttributes({
-            items: [
-              {
-                text: ctx.task.filePath
-              },
-              {
-                text: `${ctx.task.exportName}.run()`
+        } catch (runError) {
+          try {
+            const handleErrorResult = await __privateMethod(this, _handleError, handleError_fn).call(this, execution, runError, parsedPayload, ctx);
+            recordSpanException(span, handleErrorResult.error ?? runError);
+            return {
+              id: execution.run.id,
+              ok: false,
+              error: handleErrorResult.error ? parseError(handleErrorResult.error) : parseError(runError),
+              retry: handleErrorResult.status === "retry" ? handleErrorResult.retry : void 0,
+              skippedRetrying: handleErrorResult.status === "skipped"
+            };
+          } catch (handleErrorError) {
+            recordSpanException(span, handleErrorError);
+            return {
+              ok: false,
+              id: execution.run.id,
+              error: {
+                type: "INTERNAL_ERROR",
+                code: TaskRunErrorCodes.HANDLE_ERROR_ERROR,
+                message: handleErrorError instanceof Error ? handleErrorError.message : typeof handleErrorError === "string" ? handleErrorError : void 0
               }
-            ],
-            style: "codepath"
-          })
+            };
+          }
+        } finally {
+          await __privateMethod(this, _callTaskCleanup, callTaskCleanup_fn).call(this, parsedPayload, ctx, initOutput);
         }
-      }, this._tracer.extractContext(traceContext));
-    });
+      });
+    }, {
+      kind: api.SpanKind.CONSUMER,
+      attributes: {
+        [SemanticInternalAttributes.STYLE_ICON]: "attempt",
+        ...accessoryAttributes({
+          items: [
+            {
+              text: ctx.task.filePath
+            },
+            {
+              text: `${ctx.task.exportName}.run()`
+            }
+          ],
+          style: "codepath"
+        })
+      }
+    }, this._tracer.extractContext(traceContext));
     return result;
   }
 };
@@ -2047,10 +2258,403 @@ originPreciseDate_get = /* @__PURE__ */ __name(function() {
 }, "#originPreciseDate");
 __name(_PreciseWallClock, "PreciseWallClock");
 var PreciseWallClock = _PreciseWallClock;
+function iconStringForSeverity(severityNumber) {
+  switch (severityNumber) {
+    case apiLogs.SeverityNumber.UNSPECIFIED:
+      return void 0;
+    case apiLogs.SeverityNumber.TRACE:
+    case apiLogs.SeverityNumber.TRACE2:
+    case apiLogs.SeverityNumber.TRACE3:
+    case apiLogs.SeverityNumber.TRACE4:
+      return "trace";
+    case apiLogs.SeverityNumber.DEBUG:
+    case apiLogs.SeverityNumber.DEBUG2:
+    case apiLogs.SeverityNumber.DEBUG3:
+    case apiLogs.SeverityNumber.DEBUG4:
+      return "debug";
+    case apiLogs.SeverityNumber.INFO:
+    case apiLogs.SeverityNumber.INFO2:
+    case apiLogs.SeverityNumber.INFO3:
+    case apiLogs.SeverityNumber.INFO4:
+      return "info";
+    case apiLogs.SeverityNumber.WARN:
+    case apiLogs.SeverityNumber.WARN2:
+    case apiLogs.SeverityNumber.WARN3:
+    case apiLogs.SeverityNumber.WARN4:
+      return "warn";
+    case apiLogs.SeverityNumber.ERROR:
+    case apiLogs.SeverityNumber.ERROR2:
+    case apiLogs.SeverityNumber.ERROR3:
+    case apiLogs.SeverityNumber.ERROR4:
+      return "error";
+    case apiLogs.SeverityNumber.FATAL:
+    case apiLogs.SeverityNumber.FATAL2:
+    case apiLogs.SeverityNumber.FATAL3:
+    case apiLogs.SeverityNumber.FATAL4:
+      return "fatal";
+  }
+}
+__name(iconStringForSeverity, "iconStringForSeverity");
+var _SimpleClock = class _SimpleClock {
+  preciseNow() {
+    const now = new preciseDate.PreciseDate();
+    const nowStruct = now.toStruct();
+    return [
+      nowStruct.seconds,
+      nowStruct.nanos
+    ];
+  }
+  reset() {
+  }
+};
+__name(_SimpleClock, "SimpleClock");
+var SimpleClock = _SimpleClock;
+
+// src/v3/clock/index.ts
+var API_NAME2 = "clock";
+var SIMPLE_CLOCK = new SimpleClock();
+var _getClock, getClock_fn;
+var _ClockAPI = class _ClockAPI {
+  constructor() {
+    __privateAdd(this, _getClock);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ClockAPI();
+    }
+    return this._instance;
+  }
+  setGlobalClock(clock2) {
+    return registerGlobal(API_NAME2, clock2);
+  }
+  preciseNow() {
+    return __privateMethod(this, _getClock, getClock_fn).call(this).preciseNow();
+  }
+  reset() {
+    __privateMethod(this, _getClock, getClock_fn).call(this).reset();
+  }
+};
+_getClock = new WeakSet();
+getClock_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME2) ?? SIMPLE_CLOCK;
+}, "#getClock");
+__name(_ClockAPI, "ClockAPI");
+var ClockAPI = _ClockAPI;
+
+// src/v3/clock-api.ts
+var clock = ClockAPI.getInstance();
+
+// src/v3/logger/taskLogger.ts
+var logLevels = [
+  "none",
+  "error",
+  "warn",
+  "log",
+  "info",
+  "debug"
+];
+var _emitLog, emitLog_fn, _getTimestampInHrTime, getTimestampInHrTime_fn;
+var _OtelTaskLogger = class _OtelTaskLogger {
+  constructor(_config) {
+    __privateAdd(this, _emitLog);
+    __privateAdd(this, _getTimestampInHrTime);
+    this._config = _config;
+    this._level = logLevels.indexOf(_config.level);
+  }
+  debug(message, properties) {
+    if (this._level < 5)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "debug", apiLogs.SeverityNumber.DEBUG, properties);
+  }
+  log(message, properties) {
+    if (this._level < 3)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "log", apiLogs.SeverityNumber.INFO, properties);
+  }
+  info(message, properties) {
+    if (this._level < 4)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "info", apiLogs.SeverityNumber.INFO, properties);
+  }
+  warn(message, properties) {
+    if (this._level < 2)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "warn", apiLogs.SeverityNumber.WARN, properties);
+  }
+  error(message, properties) {
+    if (this._level < 1)
+      return;
+    __privateMethod(this, _emitLog, emitLog_fn).call(this, message, __privateMethod(this, _getTimestampInHrTime, getTimestampInHrTime_fn).call(this), "error", apiLogs.SeverityNumber.ERROR, properties);
+  }
+  trace(name, fn, options) {
+    return this._config.tracer.startActiveSpan(name, fn, options);
+  }
+};
+_emitLog = new WeakSet();
+emitLog_fn = /* @__PURE__ */ __name(function(message, timestamp, severityText, severityNumber, properties) {
+  let attributes = {
+    ...flattenAttributes(safeJsonProcess(properties))
+  };
+  const icon = iconStringForSeverity(severityNumber);
+  if (icon !== void 0) {
+    attributes[SemanticInternalAttributes.STYLE_ICON] = icon;
+  }
+  this._config.logger.emit({
+    severityNumber,
+    severityText,
+    body: message,
+    attributes,
+    timestamp
+  });
+}, "#emitLog");
+_getTimestampInHrTime = new WeakSet();
+getTimestampInHrTime_fn = /* @__PURE__ */ __name(function() {
+  return clock.preciseNow();
+}, "#getTimestampInHrTime");
+__name(_OtelTaskLogger, "OtelTaskLogger");
+var OtelTaskLogger = _OtelTaskLogger;
+function safeJsonProcess(value) {
+  try {
+    return JSON.parse(JSON.stringify(value, jsonErrorReplacer));
+  } catch {
+    return value;
+  }
+}
+__name(safeJsonProcess, "safeJsonProcess");
+function jsonErrorReplacer(key, value) {
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    };
+  }
+  return value;
+}
+__name(jsonErrorReplacer, "jsonErrorReplacer");
+var _handleLog, handleLog_fn, _getTimestampInHrTime2, getTimestampInHrTime_fn2, _getAttributes, getAttributes_fn;
+var _ConsoleInterceptor = class _ConsoleInterceptor {
+  constructor(logger, sendToStdIO) {
+    __privateAdd(this, _handleLog);
+    __privateAdd(this, _getTimestampInHrTime2);
+    __privateAdd(this, _getAttributes);
+    this.logger = logger;
+    this.sendToStdIO = sendToStdIO;
+  }
+  // Intercept the console and send logs to the OpenTelemetry logger
+  // during the execution of the callback
+  async intercept(console2, callback) {
+    const originalConsole = {
+      log: console2.log,
+      info: console2.info,
+      warn: console2.warn,
+      error: console2.error,
+      debug: console2.debug
+    };
+    console2.log = this.log.bind(this);
+    console2.info = this.info.bind(this);
+    console2.warn = this.warn.bind(this);
+    console2.error = this.error.bind(this);
+    console2.debug = this.debug.bind(this);
+    try {
+      return await callback();
+    } finally {
+      console2.log = originalConsole.log;
+      console2.info = originalConsole.info;
+      console2.warn = originalConsole.warn;
+      console2.error = originalConsole.error;
+      console2.debug = originalConsole.debug;
+    }
+  }
+  debug(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.DEBUG, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Debug", ...args);
+  }
+  log(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Log", ...args);
+  }
+  info(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.INFO, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Info", ...args);
+  }
+  warn(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.WARN, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Warn", ...args);
+  }
+  error(...args) {
+    __privateMethod(this, _handleLog, handleLog_fn).call(this, apiLogs.SeverityNumber.ERROR, __privateMethod(this, _getTimestampInHrTime2, getTimestampInHrTime_fn2).call(this), "Error", ...args);
+  }
+};
+_handleLog = new WeakSet();
+handleLog_fn = /* @__PURE__ */ __name(function(severityNumber, timestamp, severityText, ...args) {
+  const body = util__default.default.format(...args);
+  if (this.sendToStdIO) {
+    if (severityNumber === apiLogs.SeverityNumber.ERROR) {
+      process.stderr.write(body);
+    } else {
+      process.stdout.write(body);
+    }
+  }
+  const parsed = tryParseJSON(body);
+  if (parsed.ok) {
+    this.logger.emit({
+      severityNumber,
+      severityText,
+      body: getLogMessage(parsed.value, severityText),
+      attributes: {
+        ...__privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
+        ...flattenAttributes(parsed.value)
+      },
+      timestamp
+    });
+    return;
+  }
+  this.logger.emit({
+    severityNumber,
+    severityText,
+    body,
+    attributes: __privateMethod(this, _getAttributes, getAttributes_fn).call(this, severityNumber),
+    timestamp
+  });
+}, "#handleLog");
+_getTimestampInHrTime2 = new WeakSet();
+getTimestampInHrTime_fn2 = /* @__PURE__ */ __name(function() {
+  return clock.preciseNow();
+}, "#getTimestampInHrTime");
+_getAttributes = new WeakSet();
+getAttributes_fn = /* @__PURE__ */ __name(function(severityNumber1) {
+  const icon = iconStringForSeverity(severityNumber1);
+  let result = {};
+  if (icon !== void 0) {
+    result[SemanticInternalAttributes.STYLE_ICON] = icon;
+  }
+  return result;
+}, "#getAttributes");
+__name(_ConsoleInterceptor, "ConsoleInterceptor");
+var ConsoleInterceptor = _ConsoleInterceptor;
+function getLogMessage(value, fallback) {
+  if (typeof value["message"] === "string") {
+    return value["message"];
+  }
+  if (typeof value["msg"] === "string") {
+    return value["msg"];
+  }
+  if (typeof value["body"] === "string") {
+    return value["body"];
+  }
+  if (typeof value["error"] === "string") {
+    return value["error"];
+  }
+  return fallback;
+}
+__name(getLogMessage, "getLogMessage");
+function tryParseJSON(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return {
+        ok: true,
+        value: parsed
+      };
+    }
+    return {
+      ok: false,
+      value
+    };
+  } catch (e) {
+    return {
+      ok: false,
+      value
+    };
+  }
+}
+__name(tryParseJSON, "tryParseJSON");
+
+// src/v3/task-catalog/standardTaskCatalog.ts
+var _StandardTaskCatalog = class _StandardTaskCatalog {
+  constructor() {
+    __publicField(this, "_taskMetadata", /* @__PURE__ */ new Map());
+    __publicField(this, "_taskFunctions", /* @__PURE__ */ new Map());
+    __publicField(this, "_taskFileMetadata", /* @__PURE__ */ new Map());
+  }
+  registerTaskMetadata(task) {
+    const { fns, ...metadata } = task;
+    this._taskMetadata.set(task.id, metadata);
+    this._taskFunctions.set(task.id, fns);
+  }
+  updateTaskMetadata(id, updates) {
+    const existingMetadata = this._taskMetadata.get(id);
+    if (existingMetadata) {
+      this._taskMetadata.set(id, {
+        ...existingMetadata,
+        ...updates
+      });
+    }
+    if (updates.fns) {
+      const existingFunctions = this._taskFunctions.get(id);
+      if (existingFunctions) {
+        this._taskFunctions.set(id, {
+          ...existingFunctions,
+          ...updates.fns
+        });
+      }
+    }
+  }
+  registerTaskFileMetadata(id, metadata) {
+    this._taskFileMetadata.set(id, metadata);
+  }
+  // Return all the tasks, without the functions
+  getAllTaskMetadata() {
+    const result = [];
+    for (const [id, metadata] of this._taskMetadata) {
+      const fileMetadata = this._taskFileMetadata.get(id);
+      if (!fileMetadata) {
+        continue;
+      }
+      result.push({
+        ...metadata,
+        ...fileMetadata
+      });
+    }
+    return result;
+  }
+  getTaskMetadata(id) {
+    const metadata = this._taskMetadata.get(id);
+    const fileMetadata = this._taskFileMetadata.get(id);
+    if (!metadata || !fileMetadata) {
+      return void 0;
+    }
+    return {
+      ...metadata,
+      ...fileMetadata
+    };
+  }
+  getTask(id) {
+    const metadata = this._taskMetadata.get(id);
+    const fileMetadata = this._taskFileMetadata.get(id);
+    const fns = this._taskFunctions.get(id);
+    if (!metadata || !fns || !fileMetadata) {
+      return void 0;
+    }
+    return {
+      ...metadata,
+      ...fileMetadata,
+      fns
+    };
+  }
+  disable() {
+  }
+};
+__name(_StandardTaskCatalog, "StandardTaskCatalog");
+var StandardTaskCatalog = _StandardTaskCatalog;
 
+exports.ConsoleInterceptor = ConsoleInterceptor;
 exports.DurableClock = PreciseWallClock;
+exports.OtelTaskLogger = OtelTaskLogger;
+exports.StandardTaskCatalog = StandardTaskCatalog;
+exports.TaskContextLogProcessor = TaskContextLogProcessor;
 exports.TaskContextSpanProcessor = TaskContextSpanProcessor;
 exports.TaskExecutor = TaskExecutor;
-exports.taskContextManager = taskContextManager;
+exports.TracingSDK = TracingSDK;
+exports.getEnvVar = getEnvVar;
+exports.logLevels = logLevels;
+exports.recordSpanException = recordSpanException;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map