autotel 3.6.0 → 3.7.0

package/dist/track-3HY4NGV-.cjs

@@ -0,0 +1,1212 @@
+const require_init = require('./init-DvapOXCc.cjs');
+const require_config = require('./config.cjs');
+const require_structured_error = require('./structured-error-CHg7DoIQ.cjs');
+let _opentelemetry_api = require("@opentelemetry/api");
+let node_async_hooks = require("node:async_hooks");
+
+//#region src/rate-limiter.ts
+/**
+* Token bucket rate limiter
+*
+* Allows bursts up to burstCapacity, then smooths to maxEventsPerSecond.
+* Thread-safe for async operations.
+*/
+var TokenBucketRateLimiter = class {
+	tokens;
+	maxTokens;
+	refillRate;
+	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 tokensToAdd = (now - this.lastRefill) * 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();
+	}
+};
+
+//#endregion
+//#region src/trace-context.ts
+/**
+* AsyncLocalStorage for storing the active context with baggage
+* This allows setters to update the context and have it persist
+*/
+const contextStorage = new node_async_hooks.AsyncLocalStorage();
+/**
+* Get the context storage instance (for initialization in functional.ts)
+*/
+function getContextStorage() {
+	return contextStorage;
+}
+/**
+* Get the active context, checking our stored context first
+* This ensures baggage setters work with OpenTelemetry's propagation
+*/
+function getActiveContextWithBaggage() {
+	return contextStorage.getStore()?.value ?? _opentelemetry_api.context.active();
+}
+/**
+* Set a value in AsyncLocalStorage, preferring enterWith() when available
+* (Node.js) and falling back to run() for environments that only support
+* run() (e.g. Cloudflare Workers).
+*
+* On runtimes without enterWith() we mutate the existing run() scope when one
+* exists. This is what allows baggage/correlation updates to remain visible
+* for the rest of the traced callback in Workers.
+*/
+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 manager = _opentelemetry_api.context._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, () => {});
+}
+/**
+* Create a TraceContext from an OpenTelemetry Span
+*
+* This utility extracts trace context information from a span
+* and provides span manipulation methods and baggage operations in a consistent format.
+*
+* Note: Baggage methods always operate on the currently active context,
+* which may differ from the context when createTraceContext was called.
+*/
+function createTraceContext(span) {
+	const spanContext = span.spanContext();
+	if (!contextStorage.getStore()?.value) enterOrRun(contextStorage, _opentelemetry_api.context.active());
+	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) => {
+			require_structured_error.recordStructuredError(traceCtx, error instanceof Error ? error : new Error(String(error)));
+		},
+		track: (event, data) => {
+			track(event, data);
+		},
+		getBaggage(key) {
+			const activeCtx = _opentelemetry_api.context.active();
+			let baggage = _opentelemetry_api.propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = _opentelemetry_api.propagation.getBaggage(storedContext);
+			}
+			return baggage?.getEntry(key)?.value;
+		},
+		setBaggage(key, value) {
+			const activeCtx = _opentelemetry_api.context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const updated = (_opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage()).setEntry(key, { value });
+			updateActiveContext(_opentelemetry_api.propagation.setBaggage(currentContext, updated));
+			return value;
+		},
+		deleteBaggage(key) {
+			const activeCtx = _opentelemetry_api.context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const baggage = _opentelemetry_api.propagation.getBaggage(currentContext);
+			if (baggage) {
+				const updated = baggage.removeEntry(key);
+				updateActiveContext(_opentelemetry_api.propagation.setBaggage(currentContext, updated));
+			}
+		},
+		getAllBaggage() {
+			const activeCtx = _opentelemetry_api.context.active();
+			let baggage = _opentelemetry_api.propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = _opentelemetry_api.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;
+		},
+		getTypedBaggage: ((namespace) => {
+			const activeCtx = _opentelemetry_api.context.active();
+			let baggage = _opentelemetry_api.propagation.getBaggage(activeCtx);
+			if (!baggage) {
+				const storedContext = contextStorage.getStore()?.value;
+				if (storedContext) baggage = _opentelemetry_api.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 = _opentelemetry_api.context.active();
+			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			let baggage = _opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.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) });
+			}
+			updateActiveContext(_opentelemetry_api.propagation.setBaggage(currentContext, baggage));
+		})
+	};
+	return traceCtx;
+}
+/**
+* Define a typed baggage schema for type-safe baggage operations
+*
+* This helper provides a type-safe API for working with baggage entries.
+* The namespace parameter is optional and prefixes all keys to avoid collisions.
+*
+* @template T - The baggage schema type (all fields are treated as optional)
+* @param namespace - Optional namespace to prefix baggage keys
+*
+* @example Basic usage
+* ```typescript
+* type TenantBaggage = { tenantId: string; region?: string };
+* const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+*
+* export const handler = trace<TenantBaggage>((ctx) => async () => {
+*   // Get typed baggage
+*   const tenant = tenantBaggage.get(ctx);
+*   if (tenant?.tenantId) {
+*     console.log('Tenant:', tenant.tenantId);
+*   }
+*
+*   // Set typed baggage
+*   tenantBaggage.set(ctx, { tenantId: 't1', region: 'us-east-1' });
+* });
+* ```
+*
+* @example With withBaggage helper
+* ```typescript
+* const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+*
+* export const handler = trace<TenantBaggage>((ctx) => async () => {
+*   return await tenantBaggage.with(ctx, { tenantId: 't1' }, async () => {
+*     // Baggage is available here and in child spans
+*     const tenant = tenantBaggage.get(ctx);
+*   });
+* });
+* ```
+*/
+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 = _opentelemetry_api.context.active();
+			let baggage = _opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage();
+			for (const [key, val] of Object.entries(flatBaggage)) baggage = baggage.setEntry(key, { value: val });
+			const newContext = _opentelemetry_api.propagation.setBaggage(currentContext, baggage);
+			return _opentelemetry_api.context.with(newContext, fn);
+		}
+	};
+}
+
+//#endregion
+//#region src/correlation-id.ts
+/**
+* Correlation ID utilities for event-driven observability
+*
+* Provides a stable join key across events, logs, and spans even when traces fragment.
+* Format: 16 hex chars (64 bits), crypto-random, URL-safe.
+*
+* Lifecycle:
+* 1. Generated at boundary root (HTTP server span, message process span, cron job span)
+* 2. Reused within context (nested work shares it via AsyncLocalStorage)
+* 3. Propagated via baggage (optional, default OFF to avoid header bloat)
+*
+* @example Basic usage
+* ```typescript
+* import { generateCorrelationId, getCorrelationId } from 'autotel/correlation-id';
+*
+* // Generate a new correlation ID
+* const id = generateCorrelationId();
+* // Returns: 'a1b2c3d4e5f67890'
+*
+* // Get current correlation ID from context
+* const currentId = getCorrelationId();
+* ```
+*/
+/**
+* AsyncLocalStorage for storing correlation ID
+* This allows correlation IDs to persist across async boundaries
+*/
+const correlationStorage = new node_async_hooks.AsyncLocalStorage();
+/**
+* Baggage key for correlation ID propagation
+*/
+const CORRELATION_ID_BAGGAGE_KEY = "autotel.correlation_id";
+/**
+* Generate a new correlation ID
+*
+* Format: 16 hex chars (64 bits), crypto-random, URL-safe
+*
+* @returns A new correlation ID
+*
+* @example
+* ```typescript
+* const id = generateCorrelationId();
+* // Returns: 'a1b2c3d4e5f67890'
+* ```
+*/
+function generateCorrelationId() {
+	const bytes = new Uint8Array(8);
+	crypto.getRandomValues(bytes);
+	return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Get the current correlation ID from context
+*
+* Resolution order:
+* 1. AsyncLocalStorage (from explicit setCorrelationId or runWithCorrelationId)
+* 2. Baggage (if propagated from upstream)
+* 3. Active span's trace ID (first 16 chars as fallback)
+* 4. undefined (if not in any context)
+*
+* @returns Current correlation ID or undefined
+*
+* @example
+* ```typescript
+* const id = getCorrelationId();
+* if (id) {
+*   console.log('Correlation ID:', id);
+* }
+* ```
+*/
+function getCorrelationId() {
+	const storedId = correlationStorage.getStore()?.value;
+	if (storedId) return storedId;
+	const activeContext = _opentelemetry_api.context.active();
+	const baggageEntry = _opentelemetry_api.propagation.getBaggage(activeContext)?.getEntry(CORRELATION_ID_BAGGAGE_KEY);
+	if (baggageEntry?.value) return baggageEntry.value;
+	const span = _opentelemetry_api.trace.getActiveSpan();
+	if (span) return span.spanContext().traceId.slice(0, 16);
+}
+/**
+* Get or create a correlation ID
+*
+* If a correlation ID exists in the current context, returns it.
+* Otherwise, generates a new one.
+*
+* @returns Existing or new correlation ID
+*
+* @example
+* ```typescript
+* const id = getOrCreateCorrelationId();
+* // Always returns a valid correlation ID
+* ```
+*/
+function getOrCreateCorrelationId() {
+	return getCorrelationId() ?? generateCorrelationId();
+}
+/**
+* Run a function with a specific correlation ID in context
+*
+* The correlation ID will be available via getCorrelationId() throughout
+* the execution of the function and any async operations it spawns.
+*
+* @param correlationId - Correlation ID to use
+* @param fn - Function to execute
+* @returns The return value of the function
+*
+* @example
+* ```typescript
+* await runWithCorrelationId('abc123', async () => {
+*   // getCorrelationId() returns 'abc123' here
+*   await processRequest();
+* });
+* ```
+*/
+function runWithCorrelationId(correlationId, fn) {
+	return correlationStorage.run({ value: correlationId }, fn);
+}
+/**
+* Set correlation ID in the current context (mutates context)
+*
+* Note: This updates the AsyncLocalStorage context. For proper scoping
+* across async boundaries, prefer runWithCorrelationId() instead.
+*
+* @param correlationId - Correlation ID to set
+*
+* @example
+* ```typescript
+* setCorrelationId('abc123');
+* // Now getCorrelationId() returns 'abc123'
+* ```
+*/
+function setCorrelationId(correlationId) {
+	enterOrRun(correlationStorage, correlationId);
+}
+/**
+* Set correlation ID in baggage for propagation
+*
+* This adds the correlation ID to the W3C baggage header, allowing it
+* to be propagated to downstream services.
+*
+* Note: Only use this when you explicitly want cross-service propagation.
+* Default is OFF to avoid header bloat.
+*
+* @param correlationId - Correlation ID to propagate
+* @returns New context with baggage set
+*
+* @example
+* ```typescript
+* const newContext = setCorrelationIdInBaggage('abc123');
+* context.with(newContext, () => {
+*   // Baggage will be propagated in outgoing requests
+* });
+* ```
+*/
+function setCorrelationIdInBaggage(correlationId) {
+	const activeContext = _opentelemetry_api.context.active();
+	let baggage = _opentelemetry_api.propagation.getBaggage(activeContext) ?? _opentelemetry_api.propagation.createBaggage();
+	baggage = baggage.setEntry(CORRELATION_ID_BAGGAGE_KEY, { value: correlationId });
+	return _opentelemetry_api.propagation.setBaggage(activeContext, baggage);
+}
+/**
+* Get the correlation storage instance (for internal use in init/shutdown)
+*/
+function getCorrelationStorage() {
+	return correlationStorage;
+}
+
+//#endregion
+//#region src/event-queue.ts
+const DEFAULT_CONFIG$1 = {
+	maxSize: 5e4,
+	batchSize: 100,
+	flushInterval: 1e4,
+	maxRetries: 3,
+	rateLimit: {
+		maxEventsPerSecond: 100,
+		burstCapacity: 200
+	}
+};
+/**
+* Get subscriber name for metrics (stable, low-cardinality)
+*
+* Priority:
+* 1. Explicit config: subscriber.name
+* 2. Class static property (if available)
+* 3. Fallback: lowercase class name without "Subscriber" suffix
+*/
+function getSubscriberName(subscriber) {
+	if (subscriber.name) return subscriber.name.toLowerCase();
+	return (subscriber.constructor?.name || "unknown").replace(/Subscriber$/i, "").toLowerCase();
+}
+/**
+* Events queue with batching and backpressure
+*
+* Features:
+* - Batches events for efficient sending
+* - Bounded queue with drop-oldest policy (prod) or blocking (dev)
+* - Exponential backoff retry
+* - Rate limiting to prevent overwhelming subscribers
+* - Graceful flush on shutdown
+*/
+var EventQueue = class {
+	queue = [];
+	flushTimer = null;
+	config;
+	subscribers;
+	rateLimiter;
+	flushPromise = null;
+	isShuttingDown = false;
+	metrics = null;
+	observableCleanups = [];
+	subscriberHealthy = /* @__PURE__ */ new Map();
+	constructor(subscribers, config) {
+		this.subscribers = subscribers;
+		this.config = {
+			...DEFAULT_CONFIG$1,
+			...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 meter = require_config.getConfig().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 = require_init.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);
+		require_init.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);
+			require_init.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;
+			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 failedEventIndicesOrdered = [...new Set(failedDeliveries.map((f) => f.eventIndex))].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))];
+			require_init.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);
+	}
+};
+
+//#endregion
+//#region src/validation.ts
+const DEFAULT_CONFIG = {
+	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";
+	}
+};
+/**
+* Validate and sanitize event name
+* Throws ValidationError if invalid
+*/
+function validateEventName(eventName, config = DEFAULT_CONFIG) {
+	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;
+}
+/**
+* Validate and sanitize attributes
+* Returns sanitized attributes (sensitive data redacted)
+*/
+function validateAttributes(attributes, config = DEFAULT_CONFIG) {
+	if (attributes === void 0 || attributes === null) return;
+	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];
+		if (typeof value === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key))) {
+			sanitized[key] = "[REDACTED]";
+			continue;
+		}
+		sanitized[key] = sanitizeValue(value, config, 1);
+	}
+	return sanitized;
+}
+/**
+* Sanitize attribute value (recursive)
+*/
+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];
+			sanitized[key] = typeof nested === "string" && config.sensitivePatterns.some((pattern) => pattern.test(key)) ? "[REDACTED]" : sanitizeValue(nested, config, depth + 1);
+		}
+		return sanitized;
+	} catch {
+		return "[CIRCULAR]";
+	}
+	return `[${typeof value}]`;
+}
+/**
+* Validate and sanitize an events event
+* Returns { eventName, attributes } with sanitized values
+*/
+function validateEvent(eventName, attributes, config) {
+	const fullConfig = {
+		...DEFAULT_CONFIG,
+		...config
+	};
+	return {
+		eventName: validateEventName(eventName, fullConfig),
+		attributes: validateAttributes(attributes, fullConfig)
+	};
+}
+
+//#endregion
+//#region src/track.ts
+/**
+* Global track() function for business events
+*
+* Simple, no instantiation needed, auto-attaches trace context
+*/
+let eventsQueue = null;
+/**
+* Build autotel event context for trace correlation
+*
+* Works in multiple contexts:
+* 1. Inside a span → use current span's trace_id + span_id
+* 2. Outside span → use correlation_id only
+* 3. With trace URL config → include clickable trace URL
+*/
+function buildAutotelContext(span) {
+	const eventsConfig = require_init.getEventsConfig();
+	const config = require_init.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;
+}
+/**
+* Initialize events queue lazily
+*/
+function getOrCreateQueue() {
+	if (!require_init.isInitialized()) {
+		require_init.warnIfNotInitialized("track()");
+		return null;
+	}
+	if (!eventsQueue) {
+		const config = require_init.getConfig();
+		if (!config?.subscribers || config.subscribers.length === 0) return null;
+		eventsQueue = new EventQueue(config.subscribers);
+	}
+	return eventsQueue;
+}
+/**
+* Track a business events event
+*
+* Features:
+* - Auto-attaches traceId and spanId if in active span
+* - Batched sending with retry
+* - Type-safe with optional generic
+* - No-op if init() not called or no subscribers configured
+*
+* @example Basic usage
+* ```typescript
+* track('user.signup', { userId: '123', plan: 'pro' })
+* ```
+*
+* @example With type safety
+* ```typescript
+* interface EventDatas {
+*   'user.signup': { userId: string; plan: string }
+*   'plan.upgraded': { userId: string; revenue: number }
+* }
+*
+* track<EventDatas>('user.signup', { userId: '123', plan: 'pro' })
+* ```
+*
+* @example Trace correlation (automatic)
+* ```typescript
+* @Instrumented()
+* class UserService {
+*   async createUser(data: CreateUserData) {
+*     // This track call automatically includes traceId + spanId
+*     track('user.signup', { userId: data.id })
+*   }
+* }
+* ```
+*/
+function track(event, data, options) {
+	const queue = getOrCreateQueue();
+	if (!queue) return;
+	const validated = validateEvent(event, data, require_init.getValidationConfig() || void 0);
+	const span = _opentelemetry_api.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
+	});
+}
+/**
+* Get events queue (for flush/shutdown)
+* @internal
+*/
+function getEventQueue() {
+	return eventsQueue;
+}
+/**
+* Reset events queue (for shutdown/cleanup)
+* @internal
+*/
+function resetEventQueue() {
+	eventsQueue = null;
+}
+
+//#endregion
+Object.defineProperty(exports, 'CORRELATION_ID_BAGGAGE_KEY', {
+  enumerable: true,
+  get: function () {
+    return CORRELATION_ID_BAGGAGE_KEY;
+  }
+});
+Object.defineProperty(exports, 'createTraceContext', {
+  enumerable: true,
+  get: function () {
+    return createTraceContext;
+  }
+});
+Object.defineProperty(exports, 'defineBaggageSchema', {
+  enumerable: true,
+  get: function () {
+    return defineBaggageSchema;
+  }
+});
+Object.defineProperty(exports, 'enterOrRun', {
+  enumerable: true,
+  get: function () {
+    return enterOrRun;
+  }
+});
+Object.defineProperty(exports, 'generateCorrelationId', {
+  enumerable: true,
+  get: function () {
+    return generateCorrelationId;
+  }
+});
+Object.defineProperty(exports, 'getActiveContextWithBaggage', {
+  enumerable: true,
+  get: function () {
+    return getActiveContextWithBaggage;
+  }
+});
+Object.defineProperty(exports, 'getContextStorage', {
+  enumerable: true,
+  get: function () {
+    return getContextStorage;
+  }
+});
+Object.defineProperty(exports, 'getCorrelationId', {
+  enumerable: true,
+  get: function () {
+    return getCorrelationId;
+  }
+});
+Object.defineProperty(exports, 'getCorrelationStorage', {
+  enumerable: true,
+  get: function () {
+    return getCorrelationStorage;
+  }
+});
+Object.defineProperty(exports, 'getEventQueue', {
+  enumerable: true,
+  get: function () {
+    return getEventQueue;
+  }
+});
+Object.defineProperty(exports, 'getOrCreateCorrelationId', {
+  enumerable: true,
+  get: function () {
+    return getOrCreateCorrelationId;
+  }
+});
+Object.defineProperty(exports, 'resetEventQueue', {
+  enumerable: true,
+  get: function () {
+    return resetEventQueue;
+  }
+});
+Object.defineProperty(exports, 'runWithCorrelationId', {
+  enumerable: true,
+  get: function () {
+    return runWithCorrelationId;
+  }
+});
+Object.defineProperty(exports, 'setCorrelationId', {
+  enumerable: true,
+  get: function () {
+    return setCorrelationId;
+  }
+});
+Object.defineProperty(exports, 'setCorrelationIdInBaggage', {
+  enumerable: true,
+  get: function () {
+    return setCorrelationIdInBaggage;
+  }
+});
+Object.defineProperty(exports, 'track', {
+  enumerable: true,
+  get: function () {
+    return track;
+  }
+});
+Object.defineProperty(exports, 'validateEvent', {
+  enumerable: true,
+  get: function () {
+    return validateEvent;
+  }
+});
+//# sourceMappingURL=track-3HY4NGV-.cjs.map