autotel 3.6.0 → 4.0.0

package/dist/chunk-66YJ66GG.js

@@ -1,1021 +0,0 @@
-import { recordStructuredError } from './chunk-LVIPBYFE.js';
-import { getValidationConfig, isInitialized, warnIfNotInitialized, getConfig, getEventsConfig, getLogger } from './chunk-ALPYR2GC.js';
-import { getConfig as getConfig$1 } from './chunk-J5QENANM.js';
-import { trace, context, propagation } from '@opentelemetry/api';
-import { AsyncLocalStorage } from 'async_hooks';
-
-// src/rate-limiter.ts
-var TokenBucketRateLimiter = class {
-  tokens;
-  maxTokens;
-  refillRate;
-  // tokens per millisecond
-  lastRefill;
-  constructor(config) {
-    this.maxTokens = config.burstCapacity || config.maxEventsPerSecond * 2;
-    this.tokens = this.maxTokens;
-    this.refillRate = config.maxEventsPerSecond / 1e3;
-    this.lastRefill = Date.now();
-  }
-  /**
-   * Try to consume a token (allow an event)
-   * Returns true if allowed, false if rate limit exceeded
-   */
-  tryConsume(count = 1) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Wait until a token is available (async rate limiting)
-   * Returns a promise that resolves when the event can be processed
-   */
-  async waitForToken(count = 1) {
-    this.refill();
-    if (this.tokens >= count) {
-      this.tokens -= count;
-      return;
-    }
-    const tokensNeeded = count - this.tokens;
-    const waitMs = Math.ceil(tokensNeeded / this.refillRate);
-    await new Promise((resolve) => setTimeout(resolve, waitMs));
-    return this.waitForToken(count);
-  }
-  /**
-   * Refill tokens based on elapsed time
-   */
-  refill() {
-    const now = Date.now();
-    const elapsed = now - this.lastRefill;
-    const tokensToAdd = elapsed * this.refillRate;
-    this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
-    this.lastRefill = now;
-  }
-  /**
-   * Get current available tokens (for testing/debugging)
-   */
-  getAvailableTokens() {
-    this.refill();
-    return Math.floor(this.tokens);
-  }
-  /**
-   * Reset the rate limiter (for testing)
-   */
-  reset() {
-    this.tokens = this.maxTokens;
-    this.lastRefill = Date.now();
-  }
-};
-
-// src/event-queue.ts
-var DEFAULT_CONFIG = {
-  maxSize: 5e4,
-  batchSize: 100,
-  flushInterval: 1e4,
-  maxRetries: 3,
-  rateLimit: {
-    maxEventsPerSecond: 100,
-    burstCapacity: 200
-  }
-};
-function getSubscriberName(subscriber) {
-  if (subscriber.name) {
-    return subscriber.name.toLowerCase();
-  }
-  const className = subscriber.constructor?.name || "unknown";
-  return className.replace(/Subscriber$/i, "").toLowerCase();
-}
-var EventQueue = class {
-  queue = [];
-  flushTimer = null;
-  config;
-  subscribers;
-  rateLimiter;
-  flushPromise = null;
-  isShuttingDown = false;
-  // Metrics
-  metrics = null;
-  // Observable callback cleanup functions
-  observableCleanups = [];
-  // Subscriber health tracking (for observable gauges)
-  subscriberHealthy = /* @__PURE__ */ new Map();
-  constructor(subscribers, config) {
-    this.subscribers = subscribers;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.rateLimiter = this.config.rateLimit ? new TokenBucketRateLimiter(this.config.rateLimit) : null;
-    for (const subscriber of subscribers) {
-      const name = getSubscriberName(subscriber);
-      this.subscriberHealthy.set(name, true);
-    }
-    this.initMetrics();
-  }
-  /**
-   * Initialize OTel metrics for queue observability
-   */
-  initMetrics() {
-    const runtimeConfig = getConfig$1();
-    const meter = runtimeConfig.meter;
-    const queueSize = meter.createObservableGauge(
-      "autotel.event_delivery.queue.size",
-      {
-        description: "Current number of events in the delivery queue",
-        unit: "count"
-      }
-    );
-    const queueSizeCallback = (observableResult) => {
-      observableResult.observe(this.queue.length);
-    };
-    queueSize.addCallback(queueSizeCallback);
-    this.observableCleanups.push(
-      () => queueSize.removeCallback(queueSizeCallback)
-    );
-    const oldestAge = meter.createObservableGauge(
-      "autotel.event_delivery.queue.oldest_age_ms",
-      {
-        description: "Age of the oldest event in the queue in milliseconds",
-        unit: "ms"
-      }
-    );
-    const oldestAgeCallback = (observableResult) => {
-      if (this.queue.length > 0) {
-        const oldest = this.queue[0];
-        const ageMs = Date.now() - oldest.timestamp;
-        observableResult.observe(ageMs);
-      } else {
-        observableResult.observe(0);
-      }
-    };
-    oldestAge.addCallback(oldestAgeCallback);
-    this.observableCleanups.push(
-      () => oldestAge.removeCallback(oldestAgeCallback)
-    );
-    const delivered = meter.createCounter(
-      "autotel.event_delivery.queue.delivered",
-      {
-        description: "Number of events successfully delivered to subscribers",
-        unit: "count"
-      }
-    );
-    const failed = meter.createCounter("autotel.event_delivery.queue.failed", {
-      description: "Number of events that failed delivery after all retry attempts",
-      unit: "count"
-    });
-    const dropped = meter.createCounter(
-      "autotel.event_delivery.queue.dropped",
-      {
-        description: "Number of events dropped from the queue",
-        unit: "count"
-      }
-    );
-    const latency = meter.createHistogram(
-      "autotel.event_delivery.queue.latency_ms",
-      {
-        description: "Event delivery latency from enqueue to successful send",
-        unit: "ms"
-      }
-    );
-    const subscriberHealth = meter.createObservableGauge(
-      "autotel.event_delivery.subscriber.health",
-      {
-        description: "Subscriber health status (1=healthy, 0=unhealthy)",
-        unit: "1"
-      }
-    );
-    const subscriberHealthCallback = (observableResult) => {
-      for (const [subscriberName, isHealthy] of this.subscriberHealthy) {
-        observableResult.observe(isHealthy ? 1 : 0, {
-          subscriber: subscriberName
-        });
-      }
-    };
-    subscriberHealth.addCallback(subscriberHealthCallback);
-    this.observableCleanups.push(
-      () => subscriberHealth.removeCallback(subscriberHealthCallback)
-    );
-    this.metrics = {
-      queueSize,
-      oldestAge,
-      delivered,
-      failed,
-      dropped,
-      latency,
-      subscriberHealth
-    };
-  }
-  /**
-   * Record a dropped event with reason and emit debug breadcrumb
-   */
-  recordDropped(reason, event, subscriberName) {
-    const attrs = { reason };
-    if (subscriberName) {
-      attrs.subscriber = subscriberName;
-    }
-    this.metrics?.dropped.add(1, attrs);
-    const logLevel = reason === "payload_invalid" ? "error" : "warn";
-    const logger = getLogger();
-    if (logLevel === "error") {
-      logger.error(
-        {
-          eventName: event?.name,
-          subscriber: subscriberName,
-          reason,
-          correlationId: event?._correlationId,
-          traceId: event?._traceId
-        },
-        `[autotel] Event dropped: ${reason}`
-      );
-    } else {
-      logger.warn(
-        {
-          eventName: event?.name,
-          subscriber: subscriberName,
-          reason,
-          correlationId: event?._correlationId,
-          traceId: event?._traceId
-        },
-        `[autotel] Event dropped: ${reason}`
-      );
-    }
-  }
-  /**
-   * Record permanent delivery failure (after all retries exhausted)
-   * Increments failed counter and logs error
-   */
-  recordFailed(event, subscriberName, error) {
-    this.metrics?.failed.add(1, { subscriber: subscriberName });
-    this.subscriberHealthy.set(subscriberName, false);
-    getLogger().error(
-      {
-        eventName: event.name,
-        subscriber: subscriberName,
-        correlationId: event._correlationId,
-        traceId: event._traceId,
-        err: error
-      },
-      `[autotel] Event delivery failed after all retries`
-    );
-  }
-  /**
-   * Mark subscriber as unhealthy on transient failure (without incrementing failed counter)
-   * Used during retry attempts - only recordFailed should increment the counter
-   */
-  markSubscriberUnhealthy(subscriberName) {
-    this.subscriberHealthy.set(subscriberName, false);
-  }
-  /**
-   * Record successful delivery
-   */
-  recordDelivered(event, subscriberName, startTime) {
-    const latencyMs = Date.now() - startTime;
-    this.metrics?.delivered.add(1, { subscriber: subscriberName });
-    this.metrics?.latency.record(latencyMs, { subscriber: subscriberName });
-    this.subscriberHealthy.set(subscriberName, true);
-  }
-  /**
-   * Enqueue an event for sending
-   *
-   * Backpressure policy:
-   * - Drops oldest event and logs warning if queue is full (same behavior in all environments)
-   */
-  enqueue(event) {
-    if (this.isShuttingDown) {
-      this.recordDropped("shutdown", event);
-      return;
-    }
-    if (this.queue.length >= this.config.maxSize) {
-      const droppedEvent = this.queue.shift();
-      this.recordDropped("rate_limit", droppedEvent);
-      getLogger().warn(
-        {
-          droppedEvent: droppedEvent?.name
-        },
-        `[autotel] Events queue full (${this.config.maxSize} events). Dropping oldest event. Events are being produced faster than they can be sent. Check your subscribers or reduce tracking frequency.`
-      );
-    }
-    const enrichedEvent = {
-      ...event,
-      _correlationId: event._correlationId || getOrCreateCorrelationId()
-    };
-    this.queue.push(enrichedEvent);
-    this.scheduleBatchFlush();
-  }
-  /**
-   * Schedule a batch flush if not already scheduled
-   */
-  scheduleBatchFlush() {
-    if (this.flushTimer || this.flushPromise) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      void this.flushBatch();
-    }, this.config.flushInterval);
-  }
-  /**
-   * Flush a batch of events
-   * Uses promise-based concurrency control to prevent race conditions
-   */
-  async flushBatch() {
-    if (this.queue.length === 0) return;
-    if (this.flushPromise) {
-      await this.flushPromise;
-      return;
-    }
-    this.flushPromise = this.doFlushBatch();
-    try {
-      await this.flushPromise;
-    } finally {
-      this.flushPromise = null;
-      if (this.queue.length > 0) {
-        this.scheduleBatchFlush();
-      }
-    }
-  }
-  /**
-   * Internal flush implementation
-   */
-  async doFlushBatch() {
-    const batch = this.queue.splice(0, this.config.batchSize);
-    await this.sendWithRetry(batch, this.config.maxRetries);
-  }
-  /**
-   * Send events with exponential backoff retry
-   * Tracks per-event, per-subscriber failures so failed counter reflects actual failed deliveries.
-   * On retry, only failed (event, subscriber) pairs are re-sent to avoid double-counting delivered.
-   */
-  async sendWithRetry(events, retriesLeft, subscribersByEventIndex) {
-    const failedDeliveries = await this.sendToSubscribers(
-      events,
-      subscribersByEventIndex
-    );
-    if (failedDeliveries.length > 0) {
-      if (retriesLeft > 0) {
-        const failedEventIndices = new Set(
-          failedDeliveries.map((f) => f.eventIndex)
-        );
-        const failedEventIndicesOrdered = [...failedEventIndices].sort(
-          (a, b) => a - b
-        );
-        const eventsToRetry = failedEventIndicesOrdered.map(
-          (i) => events[i]
-        );
-        const failedSubscribersByRetryIndex = /* @__PURE__ */ new Map();
-        for (let j = 0; j < failedEventIndicesOrdered.length; j++) {
-          const origIndex = failedEventIndicesOrdered[j];
-          const set = /* @__PURE__ */ new Set();
-          for (const { eventIndex, subscriberName } of failedDeliveries) {
-            if (eventIndex === origIndex) set.add(subscriberName);
-          }
-          failedSubscribersByRetryIndex.set(j, set);
-        }
-        const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1e3;
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return this.sendWithRetry(
-          eventsToRetry,
-          retriesLeft - 1,
-          failedSubscribersByRetryIndex
-        );
-      } else {
-        for (const { eventIndex, subscriberName, error } of failedDeliveries) {
-          const event = events[eventIndex];
-          if (event) this.recordFailed(event, subscriberName, error);
-        }
-        const failedSubscriberNames = [
-          ...new Set(failedDeliveries.map((f) => f.subscriberName))
-        ];
-        getLogger().error(
-          {
-            failedSubscribers: failedSubscriberNames,
-            retriesAttempted: this.config.maxRetries
-          },
-          "[autotel] Failed to send events after retries"
-        );
-      }
-    }
-  }
-  /**
-   * Send events to configured subscribers with rate limiting and metrics.
-   * When subscribersByEventIndex is provided (retry path), only those subscribers are tried per event.
-   * Returns per-event, per-subscriber failures (empty if all succeeded).
-   */
-  async sendToSubscribers(events, subscribersByEventIndex) {
-    const failedDeliveries = [];
-    const sendOne = async (event, eventIndex) => {
-      const subscriberNames = subscribersByEventIndex?.get(eventIndex);
-      const failures = await this.sendEventToSubscribers(
-        event,
-        subscriberNames ?? void 0
-      );
-      for (const failure of failures) {
-        failedDeliveries.push({
-          eventIndex,
-          subscriberName: failure.subscriberName,
-          error: failure.error
-        });
-      }
-    };
-    if (!this.rateLimiter) {
-      for (let i = 0; i < events.length; i++) {
-        const event = events[i];
-        if (event) await sendOne(event, i);
-      }
-      return failedDeliveries;
-    }
-    for (let i = 0; i < events.length; i++) {
-      await this.rateLimiter.waitForToken();
-      const event = events[i];
-      if (event) await sendOne(event, i);
-    }
-    return failedDeliveries;
-  }
-  /**
-   * Send a single event to subscribers.
-   * - When subscriberNames is undefined (initial attempt): send to all subscribers.
-   * - When subscriberNames is provided (retry): send only to those subscribers (never re-send to healthy ones).
-   * Returns list of subscribers that failed (empty if all succeeded).
-   */
-  async sendEventToSubscribers(event, subscriberNames) {
-    const startTime = event.timestamp;
-    const failures = [];
-    const subscribersToTry = subscriberNames === void 0 ? this.subscribers : this.subscribers.filter(
-      (s) => subscriberNames.has(getSubscriberName(s))
-    );
-    const results = await Promise.allSettled(
-      subscribersToTry.map(async (subscriber) => {
-        const subscriberName = getSubscriberName(subscriber);
-        try {
-          await subscriber.trackEvent(event.name, event.attributes, {
-            autotel: event.autotel,
-            schema: event.schema
-          });
-          this.recordDelivered(event, subscriberName, startTime);
-          return { subscriberName, success: true };
-        } catch (error) {
-          this.markSubscriberUnhealthy(subscriberName);
-          return {
-            subscriberName,
-            success: false,
-            error: error instanceof Error ? error : void 0
-          };
-        }
-      })
-    );
-    for (const result of results) {
-      if (result.status === "fulfilled" && !result.value.success) {
-        failures.push({
-          subscriberName: result.value.subscriberName,
-          error: result.value.error
-        });
-      }
-    }
-    return failures;
-  }
-  /**
-   * Flush all remaining events. Queue remains usable after flush (e.g. for
-   * auto-flush at root span end). Use shutdown() when tearing down the queue.
-   */
-  async flush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (this.flushPromise) {
-      await this.flushPromise;
-    }
-    while (this.queue.length > 0) {
-      await this.doFlushBatch();
-    }
-  }
-  /**
-   * Flush remaining events and permanently disable the queue (reject new events).
-   * Use for process/SDK shutdown; use flush() for periodic or span-end drain.
-   */
-  async shutdown() {
-    this.isShuttingDown = true;
-    await this.flush();
-  }
-  /**
-   * Cleanup observable metric callbacks to prevent memory leaks
-   * Call this when destroying the EventQueue instance
-   */
-  cleanup() {
-    for (const cleanupFn of this.observableCleanups) {
-      try {
-        cleanupFn();
-      } catch {
-      }
-    }
-    this.observableCleanups = [];
-  }
-  /**
-   * Get queue size (for testing/debugging)
-   */
-  size() {
-    return this.queue.length;
-  }
-  /**
-   * Get subscriber health status (for testing/debugging)
-   */
-  getSubscriberHealth() {
-    return new Map(this.subscriberHealthy);
-  }
-  /**
-   * Check if a specific subscriber is healthy
-   */
-  isSubscriberHealthy(subscriberName) {
-    return this.subscriberHealthy.get(subscriberName.toLowerCase()) ?? true;
-  }
-  /**
-   * Manually mark a subscriber as healthy or unhealthy
-   * (used for circuit breaker integration)
-   */
-  setSubscriberHealth(subscriberName, healthy) {
-    this.subscriberHealthy.set(subscriberName.toLowerCase(), healthy);
-  }
-};
-
-// src/validation.ts
-var DEFAULT_CONFIG2 = {
-  maxEventNameLength: 100,
-  maxAttributeKeyLength: 100,
-  maxAttributeValueLength: 1e3,
-  maxAttributeCount: 50,
-  maxNestingDepth: 3,
-  sensitivePatterns: [
-    /password/i,
-    /secret/i,
-    /token/i,
-    /api[_-]?key/i,
-    /access[_-]?key/i,
-    /private[_-]?key/i,
-    /auth/i,
-    /credential/i,
-    /ssn/i,
-    /credit[_-]?card/i
-  ]
-};
-var ValidationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ValidationError";
-  }
-};
-function validateEventName(eventName, config = DEFAULT_CONFIG2) {
-  if (typeof eventName !== "string") {
-    throw new ValidationError(
-      `Event name must be a string, got ${typeof eventName}`
-    );
-  }
-  const trimmed = eventName.trim();
-  if (trimmed.length === 0) {
-    throw new ValidationError("Event name cannot be empty");
-  }
-  if (trimmed.length > config.maxEventNameLength) {
-    throw new ValidationError(
-      `Event name too long (${trimmed.length} chars). Max: ${config.maxEventNameLength}`
-    );
-  }
-  if (!/^[a-zA-Z0-9._-]+$/.test(trimmed)) {
-    throw new ValidationError(
-      `Event name contains invalid characters: "${trimmed}". Use only letters, numbers, dots, underscores, and hyphens.`
-    );
-  }
-  return trimmed;
-}
-function validateAttributes(attributes, config = DEFAULT_CONFIG2) {
-  if (attributes === void 0 || attributes === null) {
-    return void 0;
-  }
-  if (typeof attributes !== "object" || Array.isArray(attributes)) {
-    throw new ValidationError("Attributes must be an object");
-  }
-  const keys = Object.keys(attributes);
-  if (keys.length > config.maxAttributeCount) {
-    throw new ValidationError(
-      `Too many attributes (${keys.length}). Max: ${config.maxAttributeCount}`
-    );
-  }
-  const sanitized = {};
-  for (const key of keys) {
-    if (key.length > config.maxAttributeKeyLength) {
-      throw new ValidationError(
-        `Attribute key too long: "${key.slice(0, 20)}..." (${key.length} chars). Max: ${config.maxAttributeKeyLength}`
-      );
-    }
-    const value = attributes[key];
-    const isSensitive = typeof value === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key));
-    if (isSensitive) {
-      sanitized[key] = "[REDACTED]";
-      continue;
-    }
-    sanitized[key] = sanitizeValue(value, config, 1);
-  }
-  return sanitized;
-}
-function sanitizeValue(value, config, depth) {
-  if (depth > config.maxNestingDepth) {
-    return "[MAX_DEPTH_EXCEEDED]";
-  }
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string") {
-    if (value.length > config.maxAttributeValueLength) {
-      return value.slice(0, config.maxAttributeValueLength) + "...";
-    }
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => sanitizeValue(item, config, depth + 1));
-  }
-  if (typeof value === "object") {
-    try {
-      JSON.stringify(value);
-      const sanitized = {};
-      for (const key in value) {
-        if (Object.prototype.hasOwnProperty.call(value, key)) {
-          const nested = value[key];
-          const isSensitive = typeof nested === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key));
-          sanitized[key] = isSensitive ? "[REDACTED]" : sanitizeValue(nested, config, depth + 1);
-        }
-      }
-      return sanitized;
-    } catch {
-      return "[CIRCULAR]";
-    }
-  }
-  return `[${typeof value}]`;
-}
-function validateEvent(eventName, attributes, config) {
-  const fullConfig = { ...DEFAULT_CONFIG2, ...config };
-  return {
-    eventName: validateEventName(eventName, fullConfig),
-    attributes: validateAttributes(attributes, fullConfig)
-  };
-}
-
-// src/track.ts
-var eventsQueue = null;
-function buildAutotelContext(span) {
-  const eventsConfig = getEventsConfig();
-  const config = getConfig();
-  const correlationId = getOrCreateCorrelationId();
-  if (!eventsConfig?.includeTraceContext) {
-    return {
-      correlation_id: correlationId
-    };
-  }
-  const autotelContext = {
-    correlation_id: correlationId
-  };
-  const spanContext = span?.spanContext();
-  if (spanContext) {
-    autotelContext.trace_id = spanContext.traceId;
-    autotelContext.span_id = spanContext.spanId;
-    autotelContext.trace_flags = spanContext.traceFlags.toString(16).padStart(2, "0");
-    const traceState = spanContext.traceState;
-    if (traceState) {
-      try {
-        if (typeof traceState.serialize === "function") {
-          const traceStateStr = traceState.serialize();
-          if (traceStateStr) {
-            autotelContext.trace_state = traceStateStr;
-          }
-        }
-      } catch {
-      }
-    }
-    if (eventsConfig.traceUrl && config) {
-      const traceUrl = eventsConfig.traceUrl({
-        traceId: spanContext.traceId,
-        spanId: spanContext.spanId,
-        correlationId,
-        serviceName: config.service,
-        environment: config.environment
-      });
-      if (traceUrl) {
-        autotelContext.trace_url = traceUrl;
-      }
-    }
-  } else {
-    if (eventsConfig.traceUrl && config) {
-      const traceUrl = eventsConfig.traceUrl({
-        correlationId,
-        serviceName: config.service,
-        environment: config.environment
-      });
-      if (traceUrl) {
-        autotelContext.trace_url = traceUrl;
-      }
-    }
-  }
-  return autotelContext;
-}
-function getOrCreateQueue() {
-  if (!isInitialized()) {
-    warnIfNotInitialized("track()");
-    return null;
-  }
-  if (!eventsQueue) {
-    const config = getConfig();
-    if (!config?.subscribers || config.subscribers.length === 0) {
-      return null;
-    }
-    eventsQueue = new EventQueue(config.subscribers);
-  }
-  return eventsQueue;
-}
-function track(event, data, options) {
-  const queue = getOrCreateQueue();
-  if (!queue) return;
-  const validationConfig = getValidationConfig();
-  const validated = validateEvent(event, data, validationConfig || void 0);
-  const span = trace.getActiveSpan();
-  const enrichedData = span ? {
-    ...validated.attributes,
-    traceId: span.spanContext().traceId,
-    spanId: span.spanContext().spanId
-  } : validated.attributes;
-  const autotelContext = buildAutotelContext(span);
-  queue.enqueue({
-    name: validated.eventName,
-    attributes: enrichedData,
-    timestamp: Date.now(),
-    autotel: autotelContext,
-    schema: options?.schema
-  });
-}
-function getEventQueue() {
-  return eventsQueue;
-}
-function resetEventQueue() {
-  eventsQueue = null;
-}
-
-// src/trace-context.ts
-var contextStorage = new AsyncLocalStorage();
-function getContextStorage() {
-  return contextStorage;
-}
-function getActiveContextWithBaggage() {
-  const stored = contextStorage.getStore()?.value;
-  return stored ?? context.active();
-}
-function enterOrRun(storage, value) {
-  const existingStore = storage.getStore();
-  if (existingStore) {
-    existingStore.value = value;
-    return;
-  }
-  const boxedValue = { value };
-  try {
-    storage.enterWith(boxedValue);
-  } catch {
-    storage.run(boxedValue, () => {
-    });
-  }
-}
-function updateActiveContext(newContext) {
-  enterOrRun(contextStorage, newContext);
-  const contextWithManager = context;
-  const manager = contextWithManager._getContextManager?.();
-  if (!manager) return;
-  const asyncLocal = manager._asyncLocalStorage ?? void 0;
-  if (asyncLocal?.enterWith) {
-    asyncLocal.enterWith(newContext);
-    return;
-  }
-  if (typeof manager.with === "function") {
-    manager.with(newContext, () => {
-    });
-  }
-}
-function createTraceContext(span) {
-  const spanContext = span.spanContext();
-  const existingStored = contextStorage.getStore()?.value;
-  if (!existingStored) {
-    const activeContext = context.active();
-    enterOrRun(contextStorage, activeContext);
-  }
-  const baggageHelpers = {
-    getBaggage(key) {
-      const activeCtx = context.active();
-      let baggage = propagation.getBaggage(activeCtx);
-      if (!baggage) {
-        const storedContext = contextStorage.getStore()?.value;
-        if (storedContext) {
-          baggage = propagation.getBaggage(storedContext);
-        }
-      }
-      return baggage?.getEntry(key)?.value;
-    },
-    setBaggage(key, value) {
-      const activeCtx = context.active();
-      const storedContext = contextStorage.getStore()?.value;
-      const currentContext = storedContext ?? activeCtx;
-      const baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
-      const updated = baggage.setEntry(key, { value });
-      const newContext = propagation.setBaggage(currentContext, updated);
-      updateActiveContext(newContext);
-      return value;
-    },
-    deleteBaggage(key) {
-      const activeCtx = context.active();
-      const storedContext = contextStorage.getStore()?.value;
-      const currentContext = storedContext ?? activeCtx;
-      const baggage = propagation.getBaggage(currentContext);
-      if (baggage) {
-        const updated = baggage.removeEntry(key);
-        const newContext = propagation.setBaggage(currentContext, updated);
-        updateActiveContext(newContext);
-      }
-    },
-    getAllBaggage() {
-      const activeCtx = context.active();
-      let baggage = propagation.getBaggage(activeCtx);
-      if (!baggage) {
-        const storedContext = contextStorage.getStore()?.value;
-        if (storedContext) {
-          baggage = propagation.getBaggage(storedContext);
-        }
-      }
-      if (!baggage) {
-        return /* @__PURE__ */ new Map();
-      }
-      const entries = /* @__PURE__ */ new Map();
-      for (const [key, entry] of baggage.getAllEntries()) {
-        entries.set(key, entry);
-      }
-      return entries;
-    },
-    // Typed baggage helpers (used by defineBaggageSchema)
-    getTypedBaggage: ((namespace) => {
-      const activeCtx = context.active();
-      let baggage = propagation.getBaggage(activeCtx);
-      if (!baggage) {
-        const storedContext = contextStorage.getStore()?.value;
-        if (storedContext) {
-          baggage = propagation.getBaggage(storedContext);
-        }
-      }
-      if (!baggage) return;
-      const prefix = namespace ? `${namespace}.` : "";
-      const result = {};
-      for (const [key, entry] of baggage.getAllEntries()) {
-        if (namespace && key.startsWith(prefix)) {
-          const fieldName = key.slice(prefix.length);
-          result[fieldName] = entry.value;
-        } else if (!namespace) {
-          result[key] = entry.value;
-        }
-      }
-      return Object.keys(result).length > 0 ? result : void 0;
-    }),
-    setTypedBaggage: ((namespace, value) => {
-      const activeCtx = context.active();
-      const storedContext = contextStorage.getStore()?.value;
-      const currentContext = storedContext ?? activeCtx;
-      let baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
-      const prefix = namespace ? `${namespace}.` : "";
-      for (const [key, val] of Object.entries(value)) {
-        if (val !== void 0) {
-          const baggageKey = `${prefix}${key}`;
-          baggage = baggage.setEntry(baggageKey, { value: String(val) });
-        }
-      }
-      const newContext = propagation.setBaggage(currentContext, baggage);
-      updateActiveContext(newContext);
-    })
-  };
-  const traceCtx = {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    correlationId: spanContext.traceId.slice(0, 16),
-    setAttribute: span.setAttribute.bind(span),
-    setAttributes: span.setAttributes.bind(span),
-    setStatus: span.setStatus.bind(span),
-    recordException: span.recordException.bind(span),
-    addEvent: span.addEvent.bind(span),
-    addLink: span.addLink.bind(span),
-    addLinks: span.addLinks.bind(span),
-    updateName: span.updateName.bind(span),
-    isRecording: span.isRecording.bind(span),
-    recordError: (error) => {
-      const err = error instanceof Error ? error : new Error(String(error));
-      recordStructuredError(traceCtx, err);
-    },
-    track: (event, data) => {
-      track(event, data);
-    },
-    ...baggageHelpers
-  };
-  return traceCtx;
-}
-function defineBaggageSchema(namespace) {
-  return {
-    /**
-     * Get typed baggage from context
-     * @param ctx - Trace context
-     * @returns Partial baggage object or undefined if no baggage is set
-     */
-    get: (ctx) => {
-      if (!ctx.getTypedBaggage) return void 0;
-      return ctx.getTypedBaggage(namespace);
-    },
-    /**
-     * Set typed baggage in context
-     *
-     * Note: For proper scoping across async boundaries, use the `with` method instead
-     *
-     * @param ctx - Trace context
-     * @param value - Partial baggage object to set
-     */
-    set: (ctx, value) => {
-      if (!ctx.setTypedBaggage) return;
-      ctx.setTypedBaggage(namespace, value);
-    },
-    /**
-     * Run a function with typed baggage properly scoped
-     *
-     * This is the recommended way to set baggage as it ensures proper
-     * scoping across async boundaries.
-     *
-     * @param ctx - Trace context (can be omitted, will use active context)
-     * @param value - Partial baggage object to set
-     * @param fn - Function to execute with the baggage
-     */
-    with: (ctxOrValue, valueOrFn, maybeFn) => {
-      const value = maybeFn ? valueOrFn : ctxOrValue;
-      const fn = maybeFn || valueOrFn;
-      const prefix = namespace ? `${namespace}.` : "";
-      const flatBaggage = {};
-      for (const [key, val] of Object.entries(value)) {
-        if (val !== void 0) {
-          flatBaggage[`${prefix}${key}`] = String(val);
-        }
-      }
-      const currentContext = context.active();
-      let baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
-      for (const [key, val] of Object.entries(flatBaggage)) {
-        baggage = baggage.setEntry(key, { value: val });
-      }
-      const newContext = propagation.setBaggage(currentContext, baggage);
-      return context.with(newContext, fn);
-    }
-  };
-}
-
-// src/correlation-id.ts
-var correlationStorage = new AsyncLocalStorage();
-var CORRELATION_ID_BAGGAGE_KEY = "autotel.correlation_id";
-function generateCorrelationId() {
-  const bytes = new Uint8Array(8);
-  crypto.getRandomValues(bytes);
-  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function getCorrelationId() {
-  const storedId = correlationStorage.getStore()?.value;
-  if (storedId) {
-    return storedId;
-  }
-  const activeContext = context.active();
-  const baggage = propagation.getBaggage(activeContext);
-  const baggageEntry = baggage?.getEntry(CORRELATION_ID_BAGGAGE_KEY);
-  if (baggageEntry?.value) {
-    return baggageEntry.value;
-  }
-  const span = trace.getActiveSpan();
-  if (span) {
-    const spanContext = span.spanContext();
-    return spanContext.traceId.slice(0, 16);
-  }
-  return void 0;
-}
-function getOrCreateCorrelationId() {
-  return getCorrelationId() ?? generateCorrelationId();
-}
-function runWithCorrelationId(correlationId, fn) {
-  return correlationStorage.run({ value: correlationId }, fn);
-}
-function setCorrelationId(correlationId) {
-  enterOrRun(correlationStorage, correlationId);
-}
-function setCorrelationIdInBaggage(correlationId) {
-  const activeContext = context.active();
-  let baggage = propagation.getBaggage(activeContext) ?? propagation.createBaggage();
-  baggage = baggage.setEntry(CORRELATION_ID_BAGGAGE_KEY, {
-    value: correlationId
-  });
-  return propagation.setBaggage(activeContext, baggage);
-}
-function getCorrelationStorage() {
-  return correlationStorage;
-}
-
-export { CORRELATION_ID_BAGGAGE_KEY, createTraceContext, defineBaggageSchema, enterOrRun, generateCorrelationId, getActiveContextWithBaggage, getContextStorage, getCorrelationId, getCorrelationStorage, getEventQueue, getOrCreateCorrelationId, resetEventQueue, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage, track, validateEvent };
-//# sourceMappingURL=chunk-66YJ66GG.js.map
-//# sourceMappingURL=chunk-66YJ66GG.js.map