@trigger.dev/core 3.0.0-beta.37 → 3.0.0-beta.39

package/dist/v3/workers/index.mjs

@@ -13,6 +13,7 @@ import { FormDataEncoder } from 'form-data-encoder';
 import { Readable } from 'node:stream';
 import { PreciseDate } from '@google-cloud/precise-date';
 import util from 'node:util';
+import { setInterval } from 'node:timers/promises';
 
 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;
@@ -104,6 +105,10 @@ var SemanticInternalAttributes = {
   TASK_EXPORT_NAME: "ctx.task.exportName",
   QUEUE_NAME: "ctx.queue.name",
   QUEUE_ID: "ctx.queue.id",
+  MACHINE_PRESET_NAME: "ctx.machine.name",
+  MACHINE_PRESET_CPU: "ctx.machine.cpu",
+  MACHINE_PRESET_MEMORY: "ctx.machine.memory",
+  MACHINE_PRESET_CENTS_PER_MS: "ctx.machine.centsPerMs",
   SPAN_PARTIAL: "$span.partial",
   SPAN_ID: "$span.span_id",
   OUTPUT: "$output",
@@ -127,7 +132,9 @@ var SemanticInternalAttributes = {
   RETRY_DELAY: "retry.delay",
   RETRY_COUNT: "retry.count",
   LINK_TITLE: "$link.title",
-  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey"
+  IDEMPOTENCY_KEY: "ctx.run.idempotencyKey",
+  USAGE_DURATION_MS: "$usage.durationMs",
+  USAGE_COST_IN_CENTS: "$usage.costInCents"
 };
 
 // src/v3/utils/flattenAttributes.ts
@@ -273,7 +280,11 @@ var _TaskContextAPI = class _TaskContextAPI {
         [SemanticInternalAttributes.ORGANIZATION_SLUG]: this.ctx.organization.slug,
         [SemanticInternalAttributes.ORGANIZATION_NAME]: this.ctx.organization.name,
         [SemanticInternalAttributes.BATCH_ID]: this.ctx.batch?.id,
-        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey
+        [SemanticInternalAttributes.IDEMPOTENCY_KEY]: this.ctx.run.idempotencyKey,
+        [SemanticInternalAttributes.MACHINE_PRESET_NAME]: this.ctx.machine?.name,
+        [SemanticInternalAttributes.MACHINE_PRESET_CPU]: this.ctx.machine?.cpu,
+        [SemanticInternalAttributes.MACHINE_PRESET_MEMORY]: this.ctx.machine?.memory,
+        [SemanticInternalAttributes.MACHINE_PRESET_CENTS_PER_MS]: this.ctx.machine?.centsPerMs
       };
     }
     return {};
@@ -355,7 +366,7 @@ function getEnvVar(name) {
 __name(getEnvVar, "getEnvVar");
 
 // package.json
-var version = "3.0.0-beta.37";
+var version = "3.0.0-beta.39";
 
 // src/v3/otel/tracingSDK.ts
 var _a;
@@ -398,7 +409,7 @@ var _TracingSDK = class _TracingSDK {
       [SemanticInternalAttributes.CLI_VERSION]: version
     })).merge(config.resource ?? new Resource({})).merge(new Resource(envResourceAttributes));
     const traceProvider = new NodeTracerProvider({
-      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis ?? 500,
+      forceFlushTimeoutMillis: config.forceFlushTimeoutMillis,
       resource: commonResources,
       spanLimits: {
         attributeCountLimit: OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
@@ -411,7 +422,7 @@ var _TracingSDK = class _TracingSDK {
     });
     const spanExporter = new OTLPTraceExporter({
       url: `${config.url}/v1/traces`,
-      timeoutMillis: config.forceFlushTimeoutMillis ?? 1e3
+      timeoutMillis: config.forceFlushTimeoutMillis
     });
     traceProvider.addSpanProcessor(new TaskContextSpanProcessor(getEnvVar("OTEL_BATCH_PROCESSING_ENABLED") === "1" ? new BatchSpanProcessor(spanExporter, {
       maxExportBatchSize: parseInt(getEnvVar("OTEL_SPAN_MAX_EXPORT_BATCH_SIZE") ?? "64"),
@@ -503,6 +514,41 @@ function recordSpanException(span, error) {
   });
 }
 __name(recordSpanException, "recordSpanException");
+var MachineCpu = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4)
+]);
+var MachineMemory = z.union([
+  z.literal(0.25),
+  z.literal(0.5),
+  z.literal(1),
+  z.literal(2),
+  z.literal(4),
+  z.literal(8)
+]);
+var MachinePresetName = z.enum([
+  "micro",
+  "small-1x",
+  "small-2x",
+  "medium-1x",
+  "medium-2x",
+  "large-1x",
+  "large-2x"
+]);
+var MachineConfig = z.object({
+  cpu: MachineCpu.optional(),
+  memory: MachineMemory.optional(),
+  preset: MachinePresetName.optional()
+});
+var MachinePreset = z.object({
+  name: MachinePresetName,
+  cpu: z.number(),
+  memory: z.number(),
+  centsPerMs: z.number()
+});
 var TaskRunBuiltInError = z.object({
   type: z.literal("BUILT_IN_ERROR"),
   name: z.string(),
@@ -564,7 +610,11 @@ var TaskRun = z.object({
   tags: z.array(z.string()),
   isTest: z.boolean().default(false),
   createdAt: z.coerce.date(),
-  idempotencyKey: z.string().optional()
+  startedAt: z.coerce.date().default(() => /* @__PURE__ */ new Date()),
+  idempotencyKey: z.string().optional(),
+  durationMs: z.number().default(0),
+  costInCents: z.number().default(0),
+  baseCostInCents: z.number().default(0)
 });
 var TaskRunExecutionTask = z.object({
   id: z.string(),
@@ -615,7 +665,8 @@ var TaskRunExecution = z.object({
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
   project: TaskRunExecutionProject,
-  batch: TaskRunExecutionBatch.optional()
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
 });
 var TaskRunContext = z.object({
   task: TaskRunExecutionTask,
@@ -631,25 +682,31 @@ var TaskRunContext = z.object({
   environment: TaskRunExecutionEnvironment,
   organization: TaskRunExecutionOrganization,
   project: TaskRunExecutionProject,
-  batch: TaskRunExecutionBatch.optional()
+  batch: TaskRunExecutionBatch.optional(),
+  machine: MachinePreset.optional()
 });
 var TaskRunExecutionRetry = z.object({
   timestamp: z.number(),
   delay: z.number(),
   error: z.unknown().optional()
 });
+var TaskRunExecutionUsage = z.object({
+  durationMs: z.number()
+});
 var TaskRunFailedExecutionResult = z.object({
   ok: z.literal(false),
   id: z.string(),
   error: TaskRunError,
   retry: TaskRunExecutionRetry.optional(),
-  skippedRetrying: z.boolean().optional()
+  skippedRetrying: z.boolean().optional(),
+  usage: TaskRunExecutionUsage.optional()
 });
 var TaskRunSuccessfulExecutionResult = z.object({
   ok: z.literal(true),
   id: z.string(),
   output: z.string().optional(),
-  outputType: z.string()
+  outputType: z.string(),
+  usage: TaskRunExecutionUsage.optional()
 });
 var TaskRunExecutionResult = z.discriminatedUnion("ok", [
   TaskRunSuccessfulExecutionResult,
@@ -667,26 +724,6 @@ z.enum([
   "DEVELOPMENT",
   "PREVIEW"
 ]);
-var MachineCpu = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4)
-]).default(0.5);
-var MachineMemory = z.union([
-  z.literal(0.25),
-  z.literal(0.5),
-  z.literal(1),
-  z.literal(2),
-  z.literal(4),
-  z.literal(8)
-]).default(1);
-var Machine = z.object({
-  version: z.literal("v1").default("v1"),
-  cpu: MachineCpu,
-  memory: MachineMemory
-});
 z.object({
   execution: TaskRunExecution,
   traceContext: z.record(z.unknown()),
@@ -697,6 +734,12 @@ var ProdTaskRunExecution = TaskRunExecution.extend({
     id: z.string(),
     contentHash: z.string(),
     version: z.string()
+  }),
+  machine: MachinePreset.default({
+    name: "small-1x",
+    cpu: 1,
+    memory: 1,
+    centsPerMs: 0
   })
 });
 z.object({
@@ -801,7 +844,7 @@ z.object({
   packageVersion: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional(),
+  machine: MachineConfig.optional(),
   triggerSource: z.string().optional()
 });
 z.object({
@@ -813,7 +856,7 @@ z.object({
   packageVersion: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional(),
+  machine: MachineConfig.optional(),
   triggerSource: z.string().optional(),
   filePath: z.string(),
   exportName: z.string()
@@ -873,7 +916,7 @@ var TaskResource = z.object({
   exportName: z.string(),
   queue: QueueOptions.optional(),
   retry: RetryOptions.optional(),
-  machine: Machine.partial().optional(),
+  machine: MachineConfig.optional(),
   triggerSource: z.string().optional()
 });
 var BackgroundWorkerMetadata = z.object({
@@ -1036,19 +1079,30 @@ z.object({
   You can use this to remove the schedule, update it, etc */
   scheduleId: z.string(),
   /** When the task was scheduled to run.
-  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task. */
+  * Note this will be slightly different from `new Date()` because it takes a few ms to run the task.
+  * 
+  * This date is UTC. To output it as a string with a timezone you would do this: 
+  * ```ts
+  * const formatted = payload.timestamp.toLocaleString("en-US", {
+       timeZone: payload.timezone,
+   });
+   ```  */
   timestamp: z.date(),
   /** When the task was last run (it has been).
-  This can be undefined if it's never been run */
+  This can be undefined if it's never been run. This date is UTC. */
   lastTimestamp: z.date().optional(),
   /** You can optionally provide an external id when creating the schedule.
   Usually you would use a userId or some other unique identifier.
   This defaults to undefined if you didn't provide one. */
   externalId: z.string().optional(),
+  /** The IANA timezone the schedule is set to. The default is UTC.
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  */
+  timezone: z.string(),
   /** The next 5 dates this task is scheduled to run */
   upcoming: z.array(z.date())
 });
-z.object({
+var CreateScheduleOptions = z.object({
   /** The id of the task you want to attach to. */
   task: z.string(),
   /**  The schedule in CRON format.
@@ -1068,15 +1122,29 @@ z.object({
   
      */
   cron: z.string(),
-  /** (Optional) You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
+  /** You can only create one schedule with this key. If you use it twice, the second call will update the schedule.
   *
-  * This is useful if you don't want to create duplicate schedules for a user. */
-  deduplicationKey: z.string().optional(),
+  * This is required to prevent you from creating duplicate schedules. */
+  deduplicationKey: z.string(),
   /** Optionally, you can specify your own IDs (like a user ID) and then use it inside the run function of your task.
   *
   * This allows you to have per-user CRON tasks.
   */
-  externalId: z.string().optional()
+  externalId: z.string().optional(),
+  /** Optionally, you can specify a timezone in the IANA format. If unset it will use UTC.
+  * If specified then the CRON will be evaluated in that timezone and will respect daylight savings.
+  *
+  * If you set the CRON to `0 0 * * *` and the timezone to `America/New_York` then the task will run at midnight in New York time, no matter whether it's daylight savings or not.
+  *
+  * You can see the full list of supported timezones here: https://cloud.trigger.dev/timezones
+  *
+  * @example "America/New_York", "Europe/London", "Asia/Tokyo", "Africa/Cairo"
+  *
+  */
+  timezone: z.string().optional()
+});
+CreateScheduleOptions.omit({
+  deduplicationKey: true
 });
 var ScheduleGenerator = z.object({
   type: z.literal("CRON"),
@@ -1090,6 +1158,7 @@ var ScheduleObject = z.object({
   deduplicationKey: z.string().nullish(),
   externalId: z.string().nullish(),
   generator: ScheduleGenerator,
+  timezone: z.string(),
   nextRun: z.coerce.date().nullish(),
   environments: z.array(z.object({
     id: z.string(),
@@ -1112,6 +1181,9 @@ z.object({
   page: z.number().optional(),
   perPage: z.number().optional()
 });
+z.object({
+  timezones: z.array(z.string())
+});
 var RunStatus = z.enum([
   /// Task hasn't been deployed yet but is waiting to be executed
   "WAITING_FOR_DEPLOY",
@@ -2466,7 +2538,7 @@ var _TaskExecutor = class _TaskExecutor {
     this._importedConfig = options.importedConfig;
     this._handleErrorFn = options.handleErrorFn;
   }
-  async execute(execution, worker, traceContext) {
+  async execute(execution, worker, traceContext, usage2) {
     const ctx = TaskRunContext.parse(execution);
     const attemptMessage = `Attempt ${execution.attempt.number}`;
     const originalPacket = {
@@ -2567,7 +2639,9 @@ var _TaskExecutor = class _TaskExecutor {
         })
       }
     }, this._tracer.extractContext(traceContext));
-    return result;
+    return {
+      result
+    };
   }
 };
 _callRun = new WeakSet();
@@ -3223,6 +3297,295 @@ var _StandardTaskCatalog = class _StandardTaskCatalog {
 __name(_StandardTaskCatalog, "StandardTaskCatalog");
 var StandardTaskCatalog = _StandardTaskCatalog;
 
-export { ConsoleInterceptor, PreciseWallClock as DurableClock, OtelTaskLogger, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, TracingSDK, getEnvVar, logLevels, recordSpanException };
+// src/v3/usage/noopUsageManager.ts
+var _NoopUsageManager = class _NoopUsageManager {
+  disable() {
+  }
+  start() {
+    return {
+      sample: () => ({
+        cpuTime: 0,
+        wallTime: 0
+      })
+    };
+  }
+  stop(measurement) {
+    return measurement.sample();
+  }
+  pauseAsync(cb) {
+    return cb();
+  }
+  sample() {
+    return void 0;
+  }
+};
+__name(_NoopUsageManager, "NoopUsageManager");
+var NoopUsageManager = _NoopUsageManager;
+
+// src/v3/usage/api.ts
+var API_NAME4 = "usage";
+var NOOP_USAGE_MANAGER = new NoopUsageManager();
+var _getUsageManager, getUsageManager_fn;
+var _UsageAPI = class _UsageAPI {
+  constructor() {
+    __privateAdd(this, _getUsageManager);
+  }
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _UsageAPI();
+    }
+    return this._instance;
+  }
+  setGlobalUsageManager(manager) {
+    return registerGlobal(API_NAME4, manager);
+  }
+  disable() {
+    __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).disable();
+    unregisterGlobal(API_NAME4);
+  }
+  start() {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).start();
+  }
+  stop(measurement) {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).stop(measurement);
+  }
+  pauseAsync(cb) {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).pauseAsync(cb);
+  }
+  sample() {
+    return __privateMethod(this, _getUsageManager, getUsageManager_fn).call(this).sample();
+  }
+};
+_getUsageManager = new WeakSet();
+getUsageManager_fn = /* @__PURE__ */ __name(function() {
+  return getGlobal(API_NAME4) ?? NOOP_USAGE_MANAGER;
+}, "#getUsageManager");
+__name(_UsageAPI, "UsageAPI");
+var UsageAPI = _UsageAPI;
+
+// src/v3/usage-api.ts
+var usage = UsageAPI.getInstance();
+
+// src/v3/clock/clock.ts
+function calculateDurationInMs(start, end) {
+  const [startSeconds, startNanoseconds] = start;
+  const [endSeconds, endNanoseconds] = end;
+  const seconds = endSeconds - startSeconds;
+  const nanoseconds = endNanoseconds - startNanoseconds;
+  return Math.floor(seconds * 1e3 + nanoseconds / 1e6);
+}
+__name(calculateDurationInMs, "calculateDurationInMs");
+
+// src/v3/usage/devUsageManager.ts
+var _a2;
+var DevUsageMeasurement = (_a2 = class {
+  constructor(id, startedAt = clock.preciseNow()) {
+    this.id = id;
+    this.startedAt = startedAt;
+    this._pauses = /* @__PURE__ */ new Map();
+  }
+  stop() {
+    this._endedAt = clock.preciseNow();
+  }
+  sample() {
+    const endedAt = this._endedAt ?? clock.preciseNow();
+    const wallTime = this.startedAt ? calculateDurationInMs(this.startedAt, endedAt) : 0;
+    if (wallTime === 0) {
+      return {
+        cpuTime: 0,
+        wallTime: 0
+      };
+    }
+    const totalPauses = Array.from(this._pauses.values()).reduce((total, pause) => {
+      return total + calculateDurationInMs(pause.start, pause.end ?? endedAt);
+    }, 0);
+    const cpuTime = wallTime - totalPauses;
+    return {
+      wallTime,
+      cpuTime
+    };
+  }
+  registerPause(pauseId, start, end) {
+    this._pauses.set(pauseId, {
+      start,
+      end
+    });
+  }
+}, __name(_a2, "DevUsageMeasurement"), _a2);
+var _DevUsageManager = class _DevUsageManager {
+  constructor() {
+    __publicField(this, "_currentMeasurements", /* @__PURE__ */ new Map());
+    __publicField(this, "_pauses", /* @__PURE__ */ new Map());
+  }
+  disable() {
+  }
+  sample() {
+    return this._firstMeasurement?.sample();
+  }
+  start() {
+    const id = generateRandomString();
+    const measurement = new DevUsageMeasurement(id);
+    if (!this._firstMeasurement) {
+      this._firstMeasurement = measurement;
+    }
+    this._currentMeasurements.set(id, measurement);
+    return measurement;
+  }
+  stop(measurement) {
+    measurement.stop();
+    const sample = measurement.sample();
+    this._currentMeasurements.delete(measurement.id);
+    return sample;
+  }
+  async pauseAsync(cb) {
+    const pauseId = generateRandomString();
+    const pauseStart = clock.preciseNow();
+    try {
+      this._pauses.set(pauseId, {
+        start: pauseStart
+      });
+      for (const measurement of this._currentMeasurements.values()) {
+        measurement.registerPause(pauseId, pauseStart);
+      }
+      return await cb();
+    } finally {
+      const pauseEnd = clock.preciseNow();
+      this._pauses.set(pauseId, {
+        start: pauseStart,
+        end: pauseEnd
+      });
+      for (const measurement of this._currentMeasurements.values()) {
+        measurement.registerPause(pauseId, pauseStart, pauseEnd);
+      }
+    }
+  }
+};
+__name(_DevUsageManager, "DevUsageManager");
+var DevUsageManager = _DevUsageManager;
+function generateRandomString() {
+  let result = "";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const charactersLength = characters.length;
+  for (var i = 0; i < 16; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+__name(generateRandomString, "generateRandomString");
+
+// src/v3/usage/usageClient.ts
+var _UsageClient = class _UsageClient {
+  constructor(url, jwt) {
+    this.url = url;
+    this.jwt = jwt;
+  }
+  async sendUsageEvent(event) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        body: JSON.stringify(event),
+        headers: {
+          "content-type": "application/json",
+          "x-trigger-jwt": this.jwt,
+          accept: "application/json",
+          authorization: `Bearer ${apiClientManager.accessToken}`
+        }
+      });
+      if (response.ok) {
+        const renewedJwt = response.headers.get("x-trigger-jwt");
+        if (renewedJwt) {
+          this.jwt = renewedJwt;
+        }
+      }
+    } catch (error) {
+      console.error(`Failed to send usage event: ${error}`);
+    }
+  }
+};
+__name(_UsageClient, "UsageClient");
+var UsageClient = _UsageClient;
+
+// src/v3/usage/prodUsageManager.ts
+var _startReportingHeartbeat, startReportingHeartbeat_fn, _reportUsage, reportUsage_fn;
+var _ProdUsageManager = class _ProdUsageManager {
+  constructor(delegageUsageManager, options) {
+    __privateAdd(this, _startReportingHeartbeat);
+    __privateAdd(this, _reportUsage);
+    this.delegageUsageManager = delegageUsageManager;
+    this.options = options;
+    if (this.options.url && this.options.jwt) {
+      this._usageClient = new UsageClient(this.options.url, this.options.jwt);
+    }
+  }
+  get isReportingEnabled() {
+    return typeof this._usageClient !== "undefined";
+  }
+  disable() {
+    this.delegageUsageManager.disable();
+    this._abortController?.abort();
+  }
+  sample() {
+    return this._measurement?.sample();
+  }
+  start() {
+    if (!this.isReportingEnabled || !this.options.heartbeatIntervalMs) {
+      return this.delegageUsageManager.start();
+    }
+    if (!this._measurement) {
+      this._measurement = this.delegageUsageManager.start();
+      __privateMethod(this, _startReportingHeartbeat, startReportingHeartbeat_fn).call(this).catch(console.error);
+      return this._measurement;
+    }
+    return this.delegageUsageManager.start();
+  }
+  stop(measurement) {
+    return this.delegageUsageManager.stop(measurement);
+  }
+  async pauseAsync(cb) {
+    return this.delegageUsageManager.pauseAsync(cb);
+  }
+  async flush() {
+    return await __privateMethod(this, _reportUsage, reportUsage_fn).call(this);
+  }
+};
+_startReportingHeartbeat = new WeakSet();
+startReportingHeartbeat_fn = /* @__PURE__ */ __name(async function() {
+  if (!this._measurement || !this.isReportingEnabled || !this.options.heartbeatIntervalMs) {
+    return;
+  }
+  this._abortController = new AbortController();
+  for await (const _ of setInterval(this.options.heartbeatIntervalMs)) {
+    if (this._abortController.signal.aborted) {
+      break;
+    }
+    await __privateMethod(this, _reportUsage, reportUsage_fn).call(this);
+  }
+}, "#startReportingHeartbeat");
+_reportUsage = new WeakSet();
+reportUsage_fn = /* @__PURE__ */ __name(async function() {
+  if (!this._measurement) {
+    return;
+  }
+  if (!this.isReportingEnabled) {
+    return;
+  }
+  const client = this._usageClient;
+  if (!client) {
+    return;
+  }
+  const sample = this._measurement.sample();
+  const cpuTimeSinceLastSample = this._lastSample ? sample.cpuTime - this._lastSample.cpuTime : sample.cpuTime;
+  this._lastSample = sample;
+  if (cpuTimeSinceLastSample <= 0) {
+    return;
+  }
+  await client.sendUsageEvent({
+    durationMs: cpuTimeSinceLastSample
+  });
+}, "#reportUsage");
+__name(_ProdUsageManager, "ProdUsageManager");
+var ProdUsageManager = _ProdUsageManager;
+
+export { ConsoleInterceptor, DevUsageManager, PreciseWallClock as DurableClock, OtelTaskLogger, ProdUsageManager, StandardTaskCatalog, TaskContextLogProcessor, TaskContextSpanProcessor, TaskExecutor, TracingSDK, getEnvVar, logLevels, recordSpanException, usage };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.mjs.map