autotel 4.2.5 → 5.0.0

package/dist/trace-helpers.js

@@ -482,9 +482,9 @@ async function createDeterministicTraceId(seed) {
 * @example Basic metadata flattening
 * ```typescript
 * import { flattenMetadata } from 'autotel/trace-helpers'
-* import { trace } from 'autotel'
+* import { trace, withTracing } from 'autotel'
 *
-* export const processOrder = trace(ctx => async (orderId: string) => {
+* export const processOrder = withTracing({})(ctx => async (orderId: string) => {
 *   const order = await getOrder(orderId)
 *
 *   // Flatten complex order metadata
@@ -509,9 +509,9 @@ async function createDeterministicTraceId(seed) {
 * @example Custom prefix for semantic conventions
 * ```typescript
 * import { flattenMetadata } from 'autotel/trace-helpers'
-* import { trace } from 'autotel'
+* import { trace, withTracing } from 'autotel'
 *
-* export const fetchUser = trace(ctx => async (userId: string) => {
+* export const fetchUser = withTracing({})(ctx => async (userId: string) => {
 *   const user = await db.users.findOne({ id: userId })
 *
 *   // Use semantic convention prefix
@@ -537,9 +537,9 @@ async function createDeterministicTraceId(seed) {
 * @example With complex objects (auto-serialized)
 * ```typescript
 * import { flattenMetadata } from 'autotel/trace-helpers'
-* import { trace } from 'autotel'
+* import { trace, withTracing } from 'autotel'
 *
-* export const analyzeRequest = trace(ctx => async (req: Request) => {
+* export const analyzeRequest = withTracing({})(ctx => async (req: Request) => {
 *   const metadata = flattenMetadata({
 *     headers: req.headers,  // Object - will be JSON serialized
 *     query: req.query,       // Object - will be JSON serialized
@@ -583,7 +583,7 @@ async function createDeterministicTraceId(seed) {
 function resolveTraceUrl(template, traceId) {
 	const t = template ?? process.env.OTEL_TRACE_URL_TEMPLATE;
 	if (!t) return void 0;
-	return t.replace(/\{traceId\}/g, traceId);
+	return t.replaceAll("{traceId}", traceId);
 }
 function flattenMetadata(metadata, prefix = "metadata") {
 	const flattened = {};

package/dist/trace-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"trace-helpers.js","names":[],"sources":["../src/trace-helpers.ts"],"sourcesContent":["/**\n * Trace context helpers - Core primitives for trace correlation\n *\n * These are the building blocks that allow users to bring their own logger\n * (bunyan, log4js, custom, etc.) and add trace correlation.\n *\n * @example Using with bunyan\n * ```typescript\n * import bunyan from 'bunyan';\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n *\n * const logger = {\n *   info: (msg: string, extra?: object) => {\n *     bunyanLogger.info(enrichWithTraceContext(extra || {}), msg);\n *   }\n * };\n * ```\n *\n * @example Using with log4js\n * ```typescript\n * import log4js from 'log4js';\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const log4jsLogger = log4js.getLogger();\n *\n * function logWithTrace(level: string, msg: string, extra?: object) {\n *   const context = getTraceContext();\n *   log4jsLogger[level](msg, { ...extra, ...context });\n * }\n * ```\n */\n\nimport { trace, context, SpanStatusCode } from '@opentelemetry/api';\nimport type { Span, Tracer, Context } from '@opentelemetry/api';\nimport { requireModule } from './node-require';\n\n/**\n * WeakMap to store span names for active spans\n * This allows us to retrieve the span name even though OpenTelemetry\n * doesn't expose it through the public API\n */\nconst spanNameMap = new WeakMap<Span, string>();\n\n/**\n * Store span name for a given span\n * Called internally when spans are created\n */\nexport function setSpanName(span: Span, name: string): void {\n  spanNameMap.set(span, name);\n}\n\n/**\n * Trace context extracted from active span\n */\nexport interface TraceContext {\n  /** Full 32-character hex trace ID */\n  traceId: string;\n  /** 16-character hex span ID */\n  spanId: string;\n  /** First 16 characters of trace ID (for log grouping/correlation) */\n  correlationId: string;\n  /** Function/operation name (OpenTelemetry semantic convention: code.function) */\n  'code.function'?: string;\n  /** Datadog trace ID in decimal format (lower 64 bits) for log-trace correlation */\n  'dd.trace_id'?: string;\n  /** Datadog span ID in decimal format for log-trace correlation */\n  'dd.span_id'?: string;\n}\n\n/**\n * Convert hex string to decimal string representation\n * Handles 64-bit unsigned integers for Datadog correlation\n *\n * @param hex - Hex string (up to 16 characters for 64-bit)\n * @returns Decimal string representation\n */\nfunction hexToDecimal(hex: string): string {\n  // For 64-bit values, use BigInt to avoid precision loss\n  return BigInt('0x' + hex).toString(10);\n}\n\n/**\n * Get current trace context from active span\n *\n * Returns null if no span is active (e.g., outside of trace operation)\n *\n * Includes both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility.\n *\n * @returns Trace context with traceId, spanId, correlationId, and Datadog decimal IDs, or null\n *\n * @example\n * ```typescript\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const context = getTraceContext();\n * if (context) {\n *   console.log('Current trace:', context.traceId);\n *   // Current trace: 4bf92f3577b34da6a3ce929d0e0e4736\n *   console.log('Datadog trace ID:', context['dd.trace_id']);\n *   // Datadog trace ID: 12007117331170166582 (decimal for log correlation)\n * }\n * ```\n */\nexport function getTraceContext(): TraceContext | null {\n  const span = trace.getActiveSpan();\n  if (!span) return null;\n\n  const spanContext = span.spanContext();\n  const traceId = spanContext.traceId;\n  const spanId = spanContext.spanId;\n\n  // Get span name from WeakMap (set when span is created)\n  // Map to OpenTelemetry semantic convention: code.function\n  const spanName = spanNameMap.get(span);\n\n  // Datadog uses the lower 64 bits of the 128-bit OpenTelemetry trace ID\n  // Convert from hex to decimal for Datadog's log-trace correlation\n  const traceIdLower64 = traceId.slice(-16); // Last 16 hex chars = lower 64 bits\n  const ddTraceId = hexToDecimal(traceIdLower64);\n  const ddSpanId = hexToDecimal(spanId);\n\n  return {\n    traceId,\n    spanId,\n    correlationId: traceId.slice(0, 16),\n    ...(spanName && { 'code.function': spanName }),\n    // Datadog-specific fields for log-trace correlation\n    'dd.trace_id': ddTraceId,\n    'dd.span_id': ddSpanId,\n  };\n}\n\n/**\n * Enrich object with trace context (traceId, spanId, correlationId, and Datadog fields)\n *\n * If no span is active, returns the object unchanged.\n * This prevents \"undefined\" or \"null\" values in logs.\n *\n * Automatically adds both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility with observability backends.\n *\n * @param obj - Object to enrich (e.g., log metadata)\n * @returns Object with trace context merged in, or unchanged if no active span\n *\n * @example\n * ```typescript\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * // Inside a trace operation:\n * const enriched = enrichWithTraceContext({ userId: '123' });\n * // {\n * //   userId: '123',\n * //   traceId: '4bf92f3577b34da6a3ce929d0e0e4736',\n * //   spanId: '00f067aa0ba902b7',\n * //   correlationId: '4bf92f3577b34da6',\n * //   'dd.trace_id': '12007117331170166582',  // Datadog decimal format\n * //   'dd.span_id': '67667974448284583'       // Datadog decimal format\n * // }\n *\n * // Outside trace operation:\n * const unchanged = enrichWithTraceContext({ userId: '123' });\n * // { userId: '123' } - no trace fields added\n * ```\n */\nexport function enrichWithTraceContext<T extends Record<string, unknown>>(\n  obj: T,\n): T {\n  const context = getTraceContext();\n  return context ? ({ ...obj, ...context } as T) : obj;\n}\n\n/**\n * Check if currently in a trace context\n *\n * Useful for conditional logic based on trace presence\n *\n * @returns true if active span exists, false otherwise\n *\n * @example\n * ```typescript\n * import { isTracing } from 'autotel/trace-helpers';\n *\n * if (isTracing()) {\n *   // Add expensive debug metadata only when tracing\n *   logger.debug('Detailed context', expensiveDebugData());\n * }\n * ```\n */\nexport function isTracing(): boolean {\n  return trace.getActiveSpan() !== undefined;\n}\n\n/**\n * Get a tracer instance for creating custom spans\n *\n * Use this when you need low-level control over span lifecycle.\n * For most use cases, prefer trace(), span(), or instrument() instead.\n *\n * @param name - Tracer name (usually your service or module name)\n * @param version - Optional version string\n * @returns OpenTelemetry Tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getTracer } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('custom.operation');\n * try {\n *   // Your logic\n *   span.setAttribute('key', 'value');\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example With AI SDK\n * ```typescript\n * import { getTracer } from 'autotel';\n * import { generateText } from 'ai';\n *\n * const tracer = getTracer('ai-agent');\n * const result = await generateText({\n *   model: myModel,\n *   prompt: 'Hello',\n *   experimental_telemetry: {\n *     isEnabled: true,\n *     tracer,\n *   },\n * });\n * ```\n */\nexport function getTracer(name: string, version?: string): Tracer {\n  return trace.getTracer(name, version);\n}\n\n/**\n * Get the currently active span\n *\n * Returns undefined if no span is currently active.\n * Useful for adding attributes to the current span.\n *\n * @returns Active span or undefined\n *\n * @example Adding attributes to active span\n * ```typescript\n * import { getActiveSpan } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span) {\n *   span.setAttribute('user.id', userId);\n *   span.setAttribute('user.action', 'click');\n * }\n * ```\n *\n * @example Checking span status\n * ```typescript\n * import { getActiveSpan, SpanStatusCode } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span?.isRecording()) {\n *   span.setStatus({ code: SpanStatusCode.OK });\n * }\n * ```\n */\nexport function getActiveSpan(): Span | undefined {\n  return trace.getActiveSpan();\n}\n\n/**\n * Get the currently active OpenTelemetry context\n *\n * The context contains the active span and any baggage.\n * Useful for context propagation and custom instrumentation.\n *\n * @returns Current active context\n *\n * @example Propagating context\n * ```typescript\n * import { getActiveContext } from 'autotel';\n *\n * const currentContext = getActiveContext();\n * // Pass context to another function or service\n * ```\n *\n * @example With context injection\n * ```typescript\n * import { getActiveContext, injectTraceContext } from 'autotel';\n *\n * const headers = {};\n * injectTraceContext(headers);\n * // Headers now contain trace propagation data\n * ```\n */\nexport function getActiveContext(): Context {\n  // Check stored context first (from baggage setters), then fall back to active context\n  // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations\n  try {\n    const { getActiveContextWithBaggage } = requireModule<{\n      getActiveContextWithBaggage: () => Context;\n    }>('./trace-context');\n    return getActiveContextWithBaggage();\n  } catch {\n    // Fallback if trace-context isn't available\n    return context.active();\n  }\n}\n\n/**\n * Run a function with a specific span set as active\n *\n * This is a convenience wrapper around the two-step process of\n * setting a span in context and running code within that context.\n *\n * @param span - The span to set as active\n * @param fn - Function to execute with the span active\n * @returns The return value of the function\n *\n * @example Running code with a custom span\n * ```typescript\n * import { getTracer, runWithSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('background.job');\n *\n * try {\n *   const result = await runWithSpan(span, async () => {\n *     // Any spans created here will be children of 'background.job'\n *     await processData();\n *     return { success: true };\n *   });\n *   console.log(result);\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example Testing with custom spans\n * ```typescript\n * import { runWithSpan, otelTrace } from 'autotel';\n *\n * const tracer = otelTrace.getTracer('test');\n * const span = tracer.startSpan('test.operation');\n *\n * const result = runWithSpan(span, () => {\n *   // Code under test runs with this span as active\n *   return myFunction();\n * });\n *\n * span.end();\n * ```\n */\nexport function runWithSpan<T>(span: Span, fn: () => T): T {\n  const ctx = trace.setSpan(context.active(), span);\n  return context.with(ctx, fn);\n}\n\n/**\n * Finalize a span with appropriate status and optional error recording\n *\n * This is a convenience function that:\n * - Records exceptions if an error is provided\n * - Sets span status to ERROR if error exists, OK otherwise\n * - Ends the span\n *\n * @param span - The span to finalize\n * @param error - Optional error to record\n *\n * @example Without error (success case)\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await doWork();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error);\n *   throw error;\n * }\n * ```\n *\n * @example With error\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await riskyOperation();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error); // Records exception and sets ERROR status\n *   throw error;\n * }\n * ```\n *\n * @example In instrumentation\n * ```typescript\n * import { getTracer, runWithSpan, finalizeSpan } from 'autotel';\n *\n * function instrumentedQuery(query: string) {\n *   const tracer = getTracer('db');\n *   const span = tracer.startSpan('db.query');\n *\n *   return runWithSpan(span, () => {\n *     try {\n *       const result = executeQuery(query);\n *       finalizeSpan(span);\n *       return result;\n *     } catch (error) {\n *       finalizeSpan(span, error);\n *       throw error;\n *     }\n *   });\n * }\n * ```\n */\nexport function finalizeSpan(span: Span, error?: unknown): void {\n  if (error) {\n    if (error instanceof Error) {\n      span.recordException(error);\n    } else {\n      span.recordException(new Error(String(error)));\n    }\n    span.setStatus({ code: SpanStatusCode.ERROR });\n  } else {\n    span.setStatus({ code: SpanStatusCode.OK });\n  }\n  span.end();\n}\n\n/**\n * Creates a deterministic trace ID from a seed string.\n *\n * Generates a consistent 128-bit trace ID (32 hex characters) from an input seed\n * using SHA-256 hashing. Useful for correlating external system IDs (request IDs,\n * order IDs, session IDs) with OpenTelemetry trace IDs.\n *\n * **Use Cases:**\n * - Correlate external request IDs with traces\n * - Link customer support tickets to trace data\n * - Associate business entities (orders, sessions) with observability data\n * - Debug specific user flows by deterministic trace lookup\n *\n * **Important:** Only use this when you need deterministic trace IDs for correlation.\n * For normal tracing, let OpenTelemetry generate random trace IDs automatically.\n *\n * **Runtime Support:**\n * - Node.js 15+ (native crypto.subtle)\n * - All modern browsers\n * - Edge runtimes (Cloudflare Workers, Deno, etc.)\n *\n * @param seed - Input string to generate trace ID from (e.g., request ID, order ID)\n * @returns Promise resolving to a 32-character hex trace ID (128 bits)\n *\n * @example Correlate external request ID with trace\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n * import { trace, context } from '@opentelemetry/api'\n *\n * // In middleware or request handler\n * const requestId = req.headers['x-request-id']\n * const traceId = await createDeterministicTraceId(requestId)\n *\n * // Use with manual span creation (advanced - not needed with trace/span functions)\n * const tracer = trace.getTracer('my-service')\n * const spanContext = {\n *   traceId,\n *   spanId: '0123456789abcdef', // Still random\n *   traceFlags: 1\n * }\n * ```\n *\n * @example Link customer support tickets to traces\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Support dashboard integration\n * const ticketId = 'TICKET-12345'\n * const traceId = await createDeterministicTraceId(ticketId)\n *\n * // Generate direct link to traces in observability backend\n * const traceUrl = `https://your-otel-backend.com/traces/${traceId}`\n * console.log(`View related traces: ${traceUrl}`)\n * ```\n *\n * @example Session-based correlation\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Track all operations for a user session\n * const sessionId = req.session.id\n * const traceId = await createDeterministicTraceId(sessionId)\n *\n * // All operations in this session share the same trace ID\n * // Makes it easy to find all activity for a specific session\n * ```\n *\n * @public\n */\nexport async function createDeterministicTraceId(\n  seed: string,\n): Promise<string> {\n  // Encode seed string to bytes\n  const encoder = new TextEncoder();\n  const data = encoder.encode(seed);\n\n  // Generate SHA-256 hash (256 bits)\n  const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n\n  // Convert to hex string and truncate to 32 characters (128 bits)\n  // OpenTelemetry trace IDs are 128 bits (16 bytes, 32 hex characters)\n  const hashArray = new Uint8Array(hashBuffer);\n  return [...hashArray]\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('')\n    .slice(0, 32);\n}\n\n/**\n * Flattens nested metadata objects into dot-notation span attributes.\n *\n * Converts complex nested objects into flat key-value pairs suitable for\n * OpenTelemetry span attributes. Non-string values are JSON serialized.\n * Handles serialization failures gracefully with a fallback value.\n *\n * **Use Cases:**\n * - Structured metadata with nested objects\n * - User context with multiple properties\n * - Request/response metadata\n * - Business entity attributes\n *\n * **Note:** Filters out null/undefined values automatically to keep spans clean.\n *\n * @param metadata - Nested metadata object to flatten\n * @param prefix - Prefix for all attribute keys (default: 'metadata')\n * @returns Flattened attributes as { [key: string]: string }\n *\n * @example Basic metadata flattening\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace } from 'autotel'\n *\n * export const processOrder = trace(ctx => async (orderId: string) => {\n *   const order = await getOrder(orderId)\n *\n *   // Flatten complex order metadata\n *   const flattened = flattenMetadata({\n *     user: { id: order.userId, tier: 'premium' },\n *     payment: { method: 'card', processor: 'stripe' },\n *     items: order.items.length\n *   })\n *\n *   ctx.setAttributes(flattened)\n *   // Results in:\n *   // {\n *   //   'metadata.user.id': 'user-123',\n *   //   'metadata.user.tier': 'premium',\n *   //   'metadata.payment.method': 'card',\n *   //   'metadata.payment.processor': 'stripe',\n *   //   'metadata.items': '5'\n *   // }\n * })\n * ```\n *\n * @example Custom prefix for semantic conventions\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace } from 'autotel'\n *\n * export const fetchUser = trace(ctx => async (userId: string) => {\n *   const user = await db.users.findOne({ id: userId })\n *\n *   // Use semantic convention prefix\n *   const userAttrs = flattenMetadata(\n *     {\n *       id: user.id,\n *       email: user.email,\n *       plan: user.subscription.plan\n *     },\n *     'user'  // Custom prefix\n *   )\n *\n *   ctx.setAttributes(userAttrs)\n *   // Results in:\n *   // {\n *   //   'user.id': 'user-123',\n *   //   'user.email': 'user@example.com',\n *   //   'user.plan': 'enterprise'\n *   // }\n * })\n * ```\n *\n * @example With complex objects (auto-serialized)\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace } from 'autotel'\n *\n * export const analyzeRequest = trace(ctx => async (req: Request) => {\n *   const metadata = flattenMetadata({\n *     headers: req.headers,  // Object - will be JSON serialized\n *     query: req.query,       // Object - will be JSON serialized\n *     timestamp: new Date()   // Non-string - will be JSON serialized\n *   })\n *\n *   ctx.setAttributes(metadata)\n *   // Results in:\n *   // {\n *   //   'metadata.headers': '{\"accept\":\"application/json\",...}',\n *   //   'metadata.query': '{\"page\":\"1\",\"limit\":\"10\"}',\n *   //   'metadata.timestamp': '\"2024-01-15T12:00:00.000Z\"'\n *   // }\n * })\n * ```\n *\n * @example Error handling\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n *\n * // Objects with circular references are handled gracefully\n * const circular: any = { a: 1 }\n * circular.self = circular\n *\n * const flattened = flattenMetadata({ data: circular })\n * // Results in:\n * // { 'metadata.data': '<serialization-failed>' }\n * ```\n *\n * @public\n */\n/**\n * Resolve a trace URL from a template string and trace ID.\n *\n * Templates use `{traceId}` as placeholder. Falls back to `OTEL_TRACE_URL_TEMPLATE` env var.\n *\n * @example\n * resolveTraceUrl('https://grafana.example.com/explore?traceId={traceId}', 'abc123')\n * // => 'https://grafana.example.com/explore?traceId=abc123'\n */\nexport function resolveTraceUrl(\n  template: string | undefined,\n  traceId: string,\n): string | undefined {\n  const t = template ?? process.env.OTEL_TRACE_URL_TEMPLATE;\n  if (!t) return undefined;\n  return t.replace(/\\{traceId\\}/g, traceId);\n}\n\nexport function flattenMetadata(\n  metadata: Record<string, unknown>,\n  prefix = 'metadata',\n): Record<string, string> {\n  const flattened: Record<string, string> = {};\n  const seen = new WeakSet<object>(); // Track visited objects to detect cycles\n\n  function flatten(obj: Record<string, unknown>, currentPrefix: string): void {\n    for (const [key, value] of Object.entries(obj)) {\n      // Skip null/undefined values\n      if (value == null) continue;\n\n      const attributeKey = `${currentPrefix}.${key}`;\n\n      // Handle primitives directly (string, number, boolean)\n      if (typeof value === 'string') {\n        flattened[attributeKey] = value;\n        continue;\n      }\n      if (typeof value === 'number' || typeof value === 'boolean') {\n        flattened[attributeKey] = String(value);\n        continue;\n      }\n\n      // Recursively flatten plain objects (with cycle detection)\n      if (\n        typeof value === 'object' &&\n        value !== null &&\n        value.constructor === Object\n      ) {\n        // Detect circular references\n        if (seen.has(value)) {\n          flattened[attributeKey] = '<circular-reference>';\n          continue;\n        }\n\n        // Mark as visited and recursively flatten\n        seen.add(value);\n        flatten(value as Record<string, unknown>, attributeKey);\n        continue;\n      }\n\n      // Serialize arrays and other non-plain objects to JSON\n      try {\n        flattened[attributeKey] = JSON.stringify(value);\n      } catch {\n        // Handle circular references or non-serializable objects\n        flattened[attributeKey] = '<serialization-failed>';\n      }\n    }\n  }\n\n  flatten(metadata, prefix);\n  return flattened;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAM,8BAAc,IAAI,QAAsB;;;;;AAM9C,SAAgB,YAAY,MAAY,MAAoB;CAC1D,YAAY,IAAI,MAAM,IAAI;AAC5B;;;;;;;;AA2BA,SAAS,aAAa,KAAqB;CAEzC,OAAO,OAAO,OAAO,GAAG,CAAC,CAAC,SAAS,EAAE;AACvC;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,kBAAuC;CACrD,MAAM,OAAO,MAAM,cAAc;CACjC,IAAI,CAAC,MAAM,OAAO;CAElB,MAAM,cAAc,KAAK,YAAY;CACrC,MAAM,UAAU,YAAY;CAC5B,MAAM,SAAS,YAAY;CAI3B,MAAM,WAAW,YAAY,IAAI,IAAI;CAKrC,MAAM,YAAY,aADK,QAAQ,MAAM,GACO,CAAC;CAC7C,MAAM,WAAW,aAAa,MAAM;CAEpC,OAAO;EACL;EACA;EACA,eAAe,QAAQ,MAAM,GAAG,EAAE;EAClC,GAAI,YAAY,EAAE,iBAAiB,SAAS;EAE5C,eAAe;EACf,cAAc;CAChB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,uBACd,KACG;CACH,MAAM,UAAU,gBAAgB;CAChC,OAAO,UAAW;EAAE,GAAG;EAAK,GAAG;CAAQ,IAAU;AACnD;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,YAAqB;CACnC,OAAO,MAAM,cAAc,MAAM;AACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,SAAgB,UAAU,MAAc,SAA0B;CAChE,OAAO,MAAM,UAAU,MAAM,OAAO;AACtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,gBAAkC;CAChD,OAAO,MAAM,cAAc;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,mBAA4B;CAG1C,IAAI;EACF,MAAM,EAAE,gCAAgC,cAErC,iBAAiB;EACpB,OAAO,4BAA4B;CACrC,QAAQ;EAEN,OAAO,QAAQ,OAAO;CACxB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,YAAe,MAAY,IAAgB;CACzD,MAAM,MAAM,MAAM,QAAQ,QAAQ,OAAO,GAAG,IAAI;CAChD,OAAO,QAAQ,KAAK,KAAK,EAAE;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,SAAgB,aAAa,MAAY,OAAuB;CAC9D,IAAI,OAAO;EACT,IAAI,iBAAiB,OACnB,KAAK,gBAAgB,KAAK;OAE1B,KAAK,gBAAgB,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;EAE/C,KAAK,UAAU,EAAE,MAAM,eAAe,MAAM,CAAC;CAC/C,OACE,KAAK,UAAU,EAAE,MAAM,eAAe,GAAG,CAAC;CAE5C,KAAK,IAAI;AACX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,eAAsB,2BACpB,MACiB;CAGjB,MAAM,OAAO,IADO,YACD,CAAC,CAAC,OAAO,IAAI;CAGhC,MAAM,aAAa,MAAM,OAAO,OAAO,OAAO,WAAW,IAAI;CAK7D,OAAO,CAAC,GAAG,IADW,WAAW,UACd,CAAC,CAAC,CAClB,KAAK,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CACjD,KAAK,EAAE,CAAC,CACR,MAAM,GAAG,EAAE;AAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0HA,SAAgB,gBACd,UACA,SACoB;CACpB,MAAM,IAAI,YAAY,QAAQ,IAAI;CAClC,IAAI,CAAC,GAAG,OAAO;CACf,OAAO,EAAE,QAAQ,gBAAgB,OAAO;AAC1C;AAEA,SAAgB,gBACd,UACA,SAAS,YACe;CACxB,MAAM,YAAoC,CAAC;CAC3C,MAAM,uBAAO,IAAI,QAAgB;CAEjC,SAAS,QAAQ,KAA8B,eAA6B;EAC1E,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,GAAG,GAAG;GAE9C,IAAI,SAAS,MAAM;GAEnB,MAAM,eAAe,GAAG,cAAc,GAAG;GAGzC,IAAI,OAAO,UAAU,UAAU;IAC7B,UAAU,gBAAgB;IAC1B;GACF;GACA,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW;IAC3D,UAAU,gBAAgB,OAAO,KAAK;IACtC;GACF;GAGA,IACE,OAAO,UAAU,YACjB,UAAU,QACV,MAAM,gBAAgB,QACtB;IAEA,IAAI,KAAK,IAAI,KAAK,GAAG;KACnB,UAAU,gBAAgB;KAC1B;IACF;IAGA,KAAK,IAAI,KAAK;IACd,QAAQ,OAAkC,YAAY;IACtD;GACF;GAGA,IAAI;IACF,UAAU,gBAAgB,KAAK,UAAU,KAAK;GAChD,QAAQ;IAEN,UAAU,gBAAgB;GAC5B;EACF;CACF;CAEA,QAAQ,UAAU,MAAM;CACxB,OAAO;AACT"}
+{"version":3,"file":"trace-helpers.js","names":[],"sources":["../src/trace-helpers.ts"],"sourcesContent":["/**\n * Trace context helpers - Core primitives for trace correlation\n *\n * These are the building blocks that allow users to bring their own logger\n * (bunyan, log4js, custom, etc.) and add trace correlation.\n *\n * @example Using with bunyan\n * ```typescript\n * import bunyan from 'bunyan';\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * const bunyanLogger = bunyan.createLogger({ name: 'myapp' });\n *\n * const logger = {\n *   info: (msg: string, extra?: object) => {\n *     bunyanLogger.info(enrichWithTraceContext(extra || {}), msg);\n *   }\n * };\n * ```\n *\n * @example Using with log4js\n * ```typescript\n * import log4js from 'log4js';\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const log4jsLogger = log4js.getLogger();\n *\n * function logWithTrace(level: string, msg: string, extra?: object) {\n *   const context = getTraceContext();\n *   log4jsLogger[level](msg, { ...extra, ...context });\n * }\n * ```\n */\n\nimport { trace, context, SpanStatusCode } from '@opentelemetry/api';\nimport type { Span, Tracer, Context } from '@opentelemetry/api';\nimport { requireModule } from './node-require';\n\n/**\n * WeakMap to store span names for active spans\n * This allows us to retrieve the span name even though OpenTelemetry\n * doesn't expose it through the public API\n */\nconst spanNameMap = new WeakMap<Span, string>();\n\n/**\n * Store span name for a given span\n * Called internally when spans are created\n */\nexport function setSpanName(span: Span, name: string): void {\n  spanNameMap.set(span, name);\n}\n\n/**\n * Trace context extracted from active span\n */\nexport interface TraceContext {\n  /** Full 32-character hex trace ID */\n  traceId: string;\n  /** 16-character hex span ID */\n  spanId: string;\n  /** First 16 characters of trace ID (for log grouping/correlation) */\n  correlationId: string;\n  /** Function/operation name (OpenTelemetry semantic convention: code.function) */\n  'code.function'?: string;\n  /** Datadog trace ID in decimal format (lower 64 bits) for log-trace correlation */\n  'dd.trace_id'?: string;\n  /** Datadog span ID in decimal format for log-trace correlation */\n  'dd.span_id'?: string;\n}\n\n/**\n * Convert hex string to decimal string representation\n * Handles 64-bit unsigned integers for Datadog correlation\n *\n * @param hex - Hex string (up to 16 characters for 64-bit)\n * @returns Decimal string representation\n */\nfunction hexToDecimal(hex: string): string {\n  // For 64-bit values, use BigInt to avoid precision loss\n  return BigInt('0x' + hex).toString(10);\n}\n\n/**\n * Get current trace context from active span\n *\n * Returns null if no span is active (e.g., outside of trace operation)\n *\n * Includes both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility.\n *\n * @returns Trace context with traceId, spanId, correlationId, and Datadog decimal IDs, or null\n *\n * @example\n * ```typescript\n * import { getTraceContext } from 'autotel/trace-helpers';\n *\n * const context = getTraceContext();\n * if (context) {\n *   console.log('Current trace:', context.traceId);\n *   // Current trace: 4bf92f3577b34da6a3ce929d0e0e4736\n *   console.log('Datadog trace ID:', context['dd.trace_id']);\n *   // Datadog trace ID: 12007117331170166582 (decimal for log correlation)\n * }\n * ```\n */\nexport function getTraceContext(): TraceContext | null {\n  const span = trace.getActiveSpan();\n  if (!span) return null;\n\n  const spanContext = span.spanContext();\n  const traceId = spanContext.traceId;\n  const spanId = spanContext.spanId;\n\n  // Get span name from WeakMap (set when span is created)\n  // Map to OpenTelemetry semantic convention: code.function\n  const spanName = spanNameMap.get(span);\n\n  // Datadog uses the lower 64 bits of the 128-bit OpenTelemetry trace ID\n  // Convert from hex to decimal for Datadog's log-trace correlation\n  const traceIdLower64 = traceId.slice(-16); // Last 16 hex chars = lower 64 bits\n  const ddTraceId = hexToDecimal(traceIdLower64);\n  const ddSpanId = hexToDecimal(spanId);\n\n  return {\n    traceId,\n    spanId,\n    correlationId: traceId.slice(0, 16),\n    ...(spanName && { 'code.function': spanName }),\n    // Datadog-specific fields for log-trace correlation\n    'dd.trace_id': ddTraceId,\n    'dd.span_id': ddSpanId,\n  };\n}\n\n/**\n * Enrich object with trace context (traceId, spanId, correlationId, and Datadog fields)\n *\n * If no span is active, returns the object unchanged.\n * This prevents \"undefined\" or \"null\" values in logs.\n *\n * Automatically adds both OpenTelemetry standard fields (hex) and Datadog-specific\n * fields (decimal) for maximum compatibility with observability backends.\n *\n * @param obj - Object to enrich (e.g., log metadata)\n * @returns Object with trace context merged in, or unchanged if no active span\n *\n * @example\n * ```typescript\n * import { enrichWithTraceContext } from 'autotel/trace-helpers';\n *\n * // Inside a trace operation:\n * const enriched = enrichWithTraceContext({ userId: '123' });\n * // {\n * //   userId: '123',\n * //   traceId: '4bf92f3577b34da6a3ce929d0e0e4736',\n * //   spanId: '00f067aa0ba902b7',\n * //   correlationId: '4bf92f3577b34da6',\n * //   'dd.trace_id': '12007117331170166582',  // Datadog decimal format\n * //   'dd.span_id': '67667974448284583'       // Datadog decimal format\n * // }\n *\n * // Outside trace operation:\n * const unchanged = enrichWithTraceContext({ userId: '123' });\n * // { userId: '123' } - no trace fields added\n * ```\n */\nexport function enrichWithTraceContext<T extends Record<string, unknown>>(\n  obj: T,\n): T {\n  const context = getTraceContext();\n  return context ? ({ ...obj, ...context } as T) : obj;\n}\n\n/**\n * Check if currently in a trace context\n *\n * Useful for conditional logic based on trace presence\n *\n * @returns true if active span exists, false otherwise\n *\n * @example\n * ```typescript\n * import { isTracing } from 'autotel/trace-helpers';\n *\n * if (isTracing()) {\n *   // Add expensive debug metadata only when tracing\n *   logger.debug('Detailed context', expensiveDebugData());\n * }\n * ```\n */\nexport function isTracing(): boolean {\n  return trace.getActiveSpan() !== undefined;\n}\n\n/**\n * Get a tracer instance for creating custom spans\n *\n * Use this when you need low-level control over span lifecycle.\n * For most use cases, prefer trace(), span(), or instrument() instead.\n *\n * @param name - Tracer name (usually your service or module name)\n * @param version - Optional version string\n * @returns OpenTelemetry Tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getTracer } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('custom.operation');\n * try {\n *   // Your logic\n *   span.setAttribute('key', 'value');\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example With AI SDK\n * ```typescript\n * import { getTracer } from 'autotel';\n * import { generateText } from 'ai';\n *\n * const tracer = getTracer('ai-agent');\n * const result = await generateText({\n *   model: myModel,\n *   prompt: 'Hello',\n *   experimental_telemetry: {\n *     isEnabled: true,\n *     tracer,\n *   },\n * });\n * ```\n */\nexport function getTracer(name: string, version?: string): Tracer {\n  return trace.getTracer(name, version);\n}\n\n/**\n * Get the currently active span\n *\n * Returns undefined if no span is currently active.\n * Useful for adding attributes to the current span.\n *\n * @returns Active span or undefined\n *\n * @example Adding attributes to active span\n * ```typescript\n * import { getActiveSpan } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span) {\n *   span.setAttribute('user.id', userId);\n *   span.setAttribute('user.action', 'click');\n * }\n * ```\n *\n * @example Checking span status\n * ```typescript\n * import { getActiveSpan, SpanStatusCode } from 'autotel';\n *\n * const span = getActiveSpan();\n * if (span?.isRecording()) {\n *   span.setStatus({ code: SpanStatusCode.OK });\n * }\n * ```\n */\nexport function getActiveSpan(): Span | undefined {\n  return trace.getActiveSpan();\n}\n\n/**\n * Get the currently active OpenTelemetry context\n *\n * The context contains the active span and any baggage.\n * Useful for context propagation and custom instrumentation.\n *\n * @returns Current active context\n *\n * @example Propagating context\n * ```typescript\n * import { getActiveContext } from 'autotel';\n *\n * const currentContext = getActiveContext();\n * // Pass context to another function or service\n * ```\n *\n * @example With context injection\n * ```typescript\n * import { getActiveContext, injectTraceContext } from 'autotel';\n *\n * const headers = {};\n * injectTraceContext(headers);\n * // Headers now contain trace propagation data\n * ```\n */\nexport function getActiveContext(): Context {\n  // Check stored context first (from baggage setters), then fall back to active context\n  // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations\n  try {\n    const { getActiveContextWithBaggage } = requireModule<{\n      getActiveContextWithBaggage: () => Context;\n    }>('./trace-context');\n    return getActiveContextWithBaggage();\n  } catch {\n    // Fallback if trace-context isn't available\n    return context.active();\n  }\n}\n\n/**\n * Run a function with a specific span set as active\n *\n * This is a convenience wrapper around the two-step process of\n * setting a span in context and running code within that context.\n *\n * @param span - The span to set as active\n * @param fn - Function to execute with the span active\n * @returns The return value of the function\n *\n * @example Running code with a custom span\n * ```typescript\n * import { getTracer, runWithSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('background.job');\n *\n * try {\n *   const result = await runWithSpan(span, async () => {\n *     // Any spans created here will be children of 'background.job'\n *     await processData();\n *     return { success: true };\n *   });\n *   console.log(result);\n * } finally {\n *   span.end();\n * }\n * ```\n *\n * @example Testing with custom spans\n * ```typescript\n * import { runWithSpan, otelTrace } from 'autotel';\n *\n * const tracer = otelTrace.getTracer('test');\n * const span = tracer.startSpan('test.operation');\n *\n * const result = runWithSpan(span, () => {\n *   // Code under test runs with this span as active\n *   return myFunction();\n * });\n *\n * span.end();\n * ```\n */\nexport function runWithSpan<T>(span: Span, fn: () => T): T {\n  const ctx = trace.setSpan(context.active(), span);\n  return context.with(ctx, fn);\n}\n\n/**\n * Finalize a span with appropriate status and optional error recording\n *\n * This is a convenience function that:\n * - Records exceptions if an error is provided\n * - Sets span status to ERROR if error exists, OK otherwise\n * - Ends the span\n *\n * @param span - The span to finalize\n * @param error - Optional error to record\n *\n * @example Without error (success case)\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await doWork();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error);\n *   throw error;\n * }\n * ```\n *\n * @example With error\n * ```typescript\n * import { getTracer, finalizeSpan } from 'autotel';\n *\n * const tracer = getTracer('my-service');\n * const span = tracer.startSpan('operation');\n *\n * try {\n *   await riskyOperation();\n *   finalizeSpan(span);\n * } catch (error) {\n *   finalizeSpan(span, error); // Records exception and sets ERROR status\n *   throw error;\n * }\n * ```\n *\n * @example In instrumentation\n * ```typescript\n * import { getTracer, runWithSpan, finalizeSpan } from 'autotel';\n *\n * function instrumentedQuery(query: string) {\n *   const tracer = getTracer('db');\n *   const span = tracer.startSpan('db.query');\n *\n *   return runWithSpan(span, () => {\n *     try {\n *       const result = executeQuery(query);\n *       finalizeSpan(span);\n *       return result;\n *     } catch (error) {\n *       finalizeSpan(span, error);\n *       throw error;\n *     }\n *   });\n * }\n * ```\n */\nexport function finalizeSpan(span: Span, error?: unknown): void {\n  if (error) {\n    if (error instanceof Error) {\n      span.recordException(error);\n    } else {\n      span.recordException(new Error(String(error)));\n    }\n    span.setStatus({ code: SpanStatusCode.ERROR });\n  } else {\n    span.setStatus({ code: SpanStatusCode.OK });\n  }\n  span.end();\n}\n\n/**\n * Creates a deterministic trace ID from a seed string.\n *\n * Generates a consistent 128-bit trace ID (32 hex characters) from an input seed\n * using SHA-256 hashing. Useful for correlating external system IDs (request IDs,\n * order IDs, session IDs) with OpenTelemetry trace IDs.\n *\n * **Use Cases:**\n * - Correlate external request IDs with traces\n * - Link customer support tickets to trace data\n * - Associate business entities (orders, sessions) with observability data\n * - Debug specific user flows by deterministic trace lookup\n *\n * **Important:** Only use this when you need deterministic trace IDs for correlation.\n * For normal tracing, let OpenTelemetry generate random trace IDs automatically.\n *\n * **Runtime Support:**\n * - Node.js 15+ (native crypto.subtle)\n * - All modern browsers\n * - Edge runtimes (Cloudflare Workers, Deno, etc.)\n *\n * @param seed - Input string to generate trace ID from (e.g., request ID, order ID)\n * @returns Promise resolving to a 32-character hex trace ID (128 bits)\n *\n * @example Correlate external request ID with trace\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n * import { trace, context } from '@opentelemetry/api'\n *\n * // In middleware or request handler\n * const requestId = req.headers['x-request-id']\n * const traceId = await createDeterministicTraceId(requestId)\n *\n * // Use with manual span creation (advanced - not needed with trace/span functions)\n * const tracer = trace.getTracer('my-service')\n * const spanContext = {\n *   traceId,\n *   spanId: '0123456789abcdef', // Still random\n *   traceFlags: 1\n * }\n * ```\n *\n * @example Link customer support tickets to traces\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Support dashboard integration\n * const ticketId = 'TICKET-12345'\n * const traceId = await createDeterministicTraceId(ticketId)\n *\n * // Generate direct link to traces in observability backend\n * const traceUrl = `https://your-otel-backend.com/traces/${traceId}`\n * console.log(`View related traces: ${traceUrl}`)\n * ```\n *\n * @example Session-based correlation\n * ```typescript\n * import { createDeterministicTraceId } from 'autotel/trace-helpers'\n *\n * // Track all operations for a user session\n * const sessionId = req.session.id\n * const traceId = await createDeterministicTraceId(sessionId)\n *\n * // All operations in this session share the same trace ID\n * // Makes it easy to find all activity for a specific session\n * ```\n *\n * @public\n */\nexport async function createDeterministicTraceId(\n  seed: string,\n): Promise<string> {\n  // Encode seed string to bytes\n  const encoder = new TextEncoder();\n  const data = encoder.encode(seed);\n\n  // Generate SHA-256 hash (256 bits)\n  const hashBuffer = await crypto.subtle.digest('SHA-256', data);\n\n  // Convert to hex string and truncate to 32 characters (128 bits)\n  // OpenTelemetry trace IDs are 128 bits (16 bytes, 32 hex characters)\n  const hashArray = new Uint8Array(hashBuffer);\n  return [...hashArray]\n    .map((byte) => byte.toString(16).padStart(2, '0'))\n    .join('')\n    .slice(0, 32);\n}\n\n/**\n * Flattens nested metadata objects into dot-notation span attributes.\n *\n * Converts complex nested objects into flat key-value pairs suitable for\n * OpenTelemetry span attributes. Non-string values are JSON serialized.\n * Handles serialization failures gracefully with a fallback value.\n *\n * **Use Cases:**\n * - Structured metadata with nested objects\n * - User context with multiple properties\n * - Request/response metadata\n * - Business entity attributes\n *\n * **Note:** Filters out null/undefined values automatically to keep spans clean.\n *\n * @param metadata - Nested metadata object to flatten\n * @param prefix - Prefix for all attribute keys (default: 'metadata')\n * @returns Flattened attributes as { [key: string]: string }\n *\n * @example Basic metadata flattening\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const processOrder = withTracing({})(ctx => async (orderId: string) => {\n *   const order = await getOrder(orderId)\n *\n *   // Flatten complex order metadata\n *   const flattened = flattenMetadata({\n *     user: { id: order.userId, tier: 'premium' },\n *     payment: { method: 'card', processor: 'stripe' },\n *     items: order.items.length\n *   })\n *\n *   ctx.setAttributes(flattened)\n *   // Results in:\n *   // {\n *   //   'metadata.user.id': 'user-123',\n *   //   'metadata.user.tier': 'premium',\n *   //   'metadata.payment.method': 'card',\n *   //   'metadata.payment.processor': 'stripe',\n *   //   'metadata.items': '5'\n *   // }\n * })\n * ```\n *\n * @example Custom prefix for semantic conventions\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const fetchUser = withTracing({})(ctx => async (userId: string) => {\n *   const user = await db.users.findOne({ id: userId })\n *\n *   // Use semantic convention prefix\n *   const userAttrs = flattenMetadata(\n *     {\n *       id: user.id,\n *       email: user.email,\n *       plan: user.subscription.plan\n *     },\n *     'user'  // Custom prefix\n *   )\n *\n *   ctx.setAttributes(userAttrs)\n *   // Results in:\n *   // {\n *   //   'user.id': 'user-123',\n *   //   'user.email': 'user@example.com',\n *   //   'user.plan': 'enterprise'\n *   // }\n * })\n * ```\n *\n * @example With complex objects (auto-serialized)\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n * import { trace, withTracing } from 'autotel'\n *\n * export const analyzeRequest = withTracing({})(ctx => async (req: Request) => {\n *   const metadata = flattenMetadata({\n *     headers: req.headers,  // Object - will be JSON serialized\n *     query: req.query,       // Object - will be JSON serialized\n *     timestamp: new Date()   // Non-string - will be JSON serialized\n *   })\n *\n *   ctx.setAttributes(metadata)\n *   // Results in:\n *   // {\n *   //   'metadata.headers': '{\"accept\":\"application/json\",...}',\n *   //   'metadata.query': '{\"page\":\"1\",\"limit\":\"10\"}',\n *   //   'metadata.timestamp': '\"2024-01-15T12:00:00.000Z\"'\n *   // }\n * })\n * ```\n *\n * @example Error handling\n * ```typescript\n * import { flattenMetadata } from 'autotel/trace-helpers'\n *\n * // Objects with circular references are handled gracefully\n * const circular: any = { a: 1 }\n * circular.self = circular\n *\n * const flattened = flattenMetadata({ data: circular })\n * // Results in:\n * // { 'metadata.data': '<serialization-failed>' }\n * ```\n *\n * @public\n */\n/**\n * Resolve a trace URL from a template string and trace ID.\n *\n * Templates use `{traceId}` as placeholder. Falls back to `OTEL_TRACE_URL_TEMPLATE` env var.\n *\n * @example\n * resolveTraceUrl('https://grafana.example.com/explore?traceId={traceId}', 'abc123')\n * // => 'https://grafana.example.com/explore?traceId=abc123'\n */\nexport function resolveTraceUrl(\n  template: string | undefined,\n  traceId: string,\n): string | undefined {\n  const t = template ?? process.env.OTEL_TRACE_URL_TEMPLATE;\n  if (!t) return undefined;\n  return t.replaceAll('{traceId}', traceId);\n}\n\nexport function flattenMetadata(\n  metadata: Record<string, unknown>,\n  prefix = 'metadata',\n): Record<string, string> {\n  const flattened: Record<string, string> = {};\n  const seen = new WeakSet<object>(); // Track visited objects to detect cycles\n\n  function flatten(obj: Record<string, unknown>, currentPrefix: string): void {\n    for (const [key, value] of Object.entries(obj)) {\n      // Skip null/undefined values\n      if (value == null) continue;\n\n      const attributeKey = `${currentPrefix}.${key}`;\n\n      // Handle primitives directly (string, number, boolean)\n      if (typeof value === 'string') {\n        flattened[attributeKey] = value;\n        continue;\n      }\n      if (typeof value === 'number' || typeof value === 'boolean') {\n        flattened[attributeKey] = String(value);\n        continue;\n      }\n\n      // Recursively flatten plain objects (with cycle detection)\n      if (\n        typeof value === 'object' &&\n        value !== null &&\n        value.constructor === Object\n      ) {\n        // Detect circular references\n        if (seen.has(value)) {\n          flattened[attributeKey] = '<circular-reference>';\n          continue;\n        }\n\n        // Mark as visited and recursively flatten\n        seen.add(value);\n        flatten(value as Record<string, unknown>, attributeKey);\n        continue;\n      }\n\n      // Serialize arrays and other non-plain objects to JSON\n      try {\n        flattened[attributeKey] = JSON.stringify(value);\n      } catch {\n        // Handle circular references or non-serializable objects\n        flattened[attributeKey] = '<serialization-failed>';\n      }\n    }\n  }\n\n  flatten(metadata, prefix);\n  return flattened;\n}\n"],"mappings":"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"}

package/dist/tracer-provider.cjs

@@ -188,6 +188,32 @@ function getAutotelTracerProvider() {
 	if (isolatedTracerProvider) return isolatedTracerProvider;
 	return _opentelemetry_api.trace.getTracerProvider();
 }
+function isForceFlushable(value) {
+	return typeof value === "object" && value !== null && typeof value.forceFlush === "function";
+}
+/**
+* Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and
+* flush-on-shutdown actually export pending spans.
+*
+* `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`
+* 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK
+* handle silently exports nothing. This falls back to the globally registered
+* provider and unwraps the API's `ProxyTracerProvider` to reach the real
+* delegate, which is where `forceFlush` actually lives.
+*
+* @param sdk - Optional NodeSDK handle to try first.
+* @returns Something with `forceFlush()`, or `undefined` if none is registered.
+*/
+function getForceFlushableProvider(sdk) {
+	const candidates = [];
+	const sdkAny = sdk;
+	if (sdkAny && typeof sdkAny.getTracerProvider === "function") candidates.push(sdkAny.getTracerProvider());
+	const globalProvider = _opentelemetry_api.trace.getTracerProvider();
+	candidates.push(globalProvider);
+	const proxy = globalProvider;
+	if (proxy && typeof proxy.getDelegate === "function") candidates.push(proxy.getDelegate());
+	return candidates.find(isForceFlushable);
+}
 /**
 * Gets the OpenTelemetry tracer instance for Autotel.
 *
@@ -227,5 +253,6 @@ function getAutotelTracer(name = "autotel", version) {
 //#endregion
 exports.getAutotelTracer = getAutotelTracer;
 exports.getAutotelTracerProvider = getAutotelTracerProvider;
+exports.getForceFlushableProvider = getForceFlushableProvider;
 exports.setAutotelTracerProvider = setAutotelTracerProvider;
 //# sourceMappingURL=tracer-provider.cjs.map

package/dist/tracer-provider.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"tracer-provider.cjs","names":["trace"],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAOA,yBAAM,kBAAkB;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}
+{"version":3,"file":"tracer-provider.cjs","names":["trace"],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/** A tracer provider that can be force-flushed (SDK providers implement this). */\ninterface ForceFlushable {\n  forceFlush(): Promise<void>;\n}\n\nfunction isForceFlushable(value: unknown): value is ForceFlushable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as ForceFlushable).forceFlush === 'function'\n  );\n}\n\n/**\n * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and\n * flush-on-shutdown actually export pending spans.\n *\n * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`\n * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK\n * handle silently exports nothing. This falls back to the globally registered\n * provider and unwraps the API's `ProxyTracerProvider` to reach the real\n * delegate, which is where `forceFlush` actually lives.\n *\n * @param sdk - Optional NodeSDK handle to try first.\n * @returns Something with `forceFlush()`, or `undefined` if none is registered.\n */\nexport function getForceFlushableProvider(\n  sdk?: unknown,\n): ForceFlushable | undefined {\n  const candidates: unknown[] = [];\n\n  const sdkAny = sdk as { getTracerProvider?: () => unknown } | undefined;\n  if (sdkAny && typeof sdkAny.getTracerProvider === 'function') {\n    candidates.push(sdkAny.getTracerProvider());\n  }\n\n  const globalProvider = trace.getTracerProvider() as unknown;\n  candidates.push(globalProvider);\n  // The API hands back a ProxyTracerProvider; the real provider (with\n  // forceFlush) sits behind getDelegate().\n  const proxy = globalProvider as { getDelegate?: () => unknown };\n  if (proxy && typeof proxy.getDelegate === 'function') {\n    candidates.push(proxy.getDelegate());\n  }\n\n  return candidates.find(isForceFlushable);\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAOA,yBAAM,kBAAkB;AACjC;AAOA,SAAS,iBAAiB,OAAyC;CACjE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAyB,eAAe;AAEpD;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,KAC4B;CAC5B,MAAM,aAAwB,CAAC;CAE/B,MAAM,SAAS;CACf,IAAI,UAAU,OAAO,OAAO,sBAAsB,YAChD,WAAW,KAAK,OAAO,kBAAkB,CAAC;CAG5C,MAAM,iBAAiBA,yBAAM,kBAAkB;CAC/C,WAAW,KAAK,cAAc;CAG9B,MAAM,QAAQ;CACd,IAAI,SAAS,OAAO,MAAM,gBAAgB,YACxC,WAAW,KAAK,MAAM,YAAY,CAAC;CAGrC,OAAO,WAAW,KAAK,gBAAgB;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}

package/dist/tracer-provider.d.cts

@@ -1,5 +1,4 @@
 import { TracerProvider } from "@opentelemetry/api";
-
 //#region src/tracer-provider.d.ts
 /**
  * Sets an isolated TracerProvider for Autotel tracing operations.
@@ -132,6 +131,24 @@ declare function setAutotelTracerProvider(provider: TracerProvider | null): void
  * @public
  */
 declare function getAutotelTracerProvider(): TracerProvider;
+/** A tracer provider that can be force-flushed (SDK providers implement this). */
+interface ForceFlushable {
+  forceFlush(): Promise<void>;
+}
+/**
+ * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and
+ * flush-on-shutdown actually export pending spans.
+ *
+ * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`
+ * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK
+ * handle silently exports nothing. This falls back to the globally registered
+ * provider and unwraps the API's `ProxyTracerProvider` to reach the real
+ * delegate, which is where `forceFlush` actually lives.
+ *
+ * @param sdk - Optional NodeSDK handle to try first.
+ * @returns Something with `forceFlush()`, or `undefined` if none is registered.
+ */
+declare function getForceFlushableProvider(sdk?: unknown): ForceFlushable | undefined;
 /**
  * Gets the OpenTelemetry tracer instance for Autotel.
  *
@@ -166,5 +183,5 @@ declare function getAutotelTracerProvider(): TracerProvider;
  */
 declare function getAutotelTracer(name?: string, version?: string): import("@opentelemetry/api").Tracer;
 //#endregion
-export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
+export { getAutotelTracer, getAutotelTracerProvider, getForceFlushableProvider, setAutotelTracerProvider };
 //# sourceMappingURL=tracer-provider.d.cts.map

package/dist/tracer-provider.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"tracer-provider.d.cts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;AAuQmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlFnD,wBAAA,CACd,QAA+B,EAArB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCV,wBAAA,IAA4B,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1C,gBAAA,CAAiB,IAAA,WAAkB,OAAA,yCAAgB,MAAA"}
+{"version":3,"file":"tracer-provider.d.cts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqLgB,yBACd,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCI,4BAA4B;;UASlC;EACR,cAAc;;;;;;;;;;;;;;;iBAwBA,0BACd,gBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDa,iBAAiB,eAAkB,gDAAgB"}

package/dist/tracer-provider.d.ts

@@ -1,5 +1,4 @@
 import { TracerProvider } from "@opentelemetry/api";
-
 //#region src/tracer-provider.d.ts
 /**
  * Sets an isolated TracerProvider for Autotel tracing operations.
@@ -132,6 +131,24 @@ declare function setAutotelTracerProvider(provider: TracerProvider | null): void
  * @public
  */
 declare function getAutotelTracerProvider(): TracerProvider;
+/** A tracer provider that can be force-flushed (SDK providers implement this). */
+interface ForceFlushable {
+  forceFlush(): Promise<void>;
+}
+/**
+ * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and
+ * flush-on-shutdown actually export pending spans.
+ *
+ * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`
+ * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK
+ * handle silently exports nothing. This falls back to the globally registered
+ * provider and unwraps the API's `ProxyTracerProvider` to reach the real
+ * delegate, which is where `forceFlush` actually lives.
+ *
+ * @param sdk - Optional NodeSDK handle to try first.
+ * @returns Something with `forceFlush()`, or `undefined` if none is registered.
+ */
+declare function getForceFlushableProvider(sdk?: unknown): ForceFlushable | undefined;
 /**
  * Gets the OpenTelemetry tracer instance for Autotel.
  *
@@ -166,5 +183,5 @@ declare function getAutotelTracerProvider(): TracerProvider;
  */
 declare function getAutotelTracer(name?: string, version?: string): import("@opentelemetry/api").Tracer;
 //#endregion
-export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
+export { getAutotelTracer, getAutotelTracerProvider, getForceFlushableProvider, setAutotelTracerProvider };
 //# sourceMappingURL=tracer-provider.d.ts.map

package/dist/tracer-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracer-provider.d.ts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;AAuQmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlFnD,wBAAA,CACd,QAA+B,EAArB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCV,wBAAA,IAA4B,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1C,gBAAA,CAAiB,IAAA,WAAkB,OAAA,yCAAgB,MAAA"}
+{"version":3,"file":"tracer-provider.d.ts","names":[],"sources":["../src/tracer-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqLgB,yBACd,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCI,4BAA4B;;UASlC;EACR,cAAc;;;;;;;;;;;;;;;iBAwBA,0BACd,gBACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDa,iBAAiB,eAAkB,gDAAgB"}

package/dist/tracer-provider.js

@@ -187,6 +187,32 @@ function getAutotelTracerProvider() {
 	if (isolatedTracerProvider) return isolatedTracerProvider;
 	return trace.getTracerProvider();
 }
+function isForceFlushable(value) {
+	return typeof value === "object" && value !== null && typeof value.forceFlush === "function";
+}
+/**
+* Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and
+* flush-on-shutdown actually export pending spans.
+*
+* `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`
+* 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK
+* handle silently exports nothing. This falls back to the globally registered
+* provider and unwraps the API's `ProxyTracerProvider` to reach the real
+* delegate, which is where `forceFlush` actually lives.
+*
+* @param sdk - Optional NodeSDK handle to try first.
+* @returns Something with `forceFlush()`, or `undefined` if none is registered.
+*/
+function getForceFlushableProvider(sdk) {
+	const candidates = [];
+	const sdkAny = sdk;
+	if (sdkAny && typeof sdkAny.getTracerProvider === "function") candidates.push(sdkAny.getTracerProvider());
+	const globalProvider = trace.getTracerProvider();
+	candidates.push(globalProvider);
+	const proxy = globalProvider;
+	if (proxy && typeof proxy.getDelegate === "function") candidates.push(proxy.getDelegate());
+	return candidates.find(isForceFlushable);
+}
 /**
 * Gets the OpenTelemetry tracer instance for Autotel.
 *
@@ -224,5 +250,5 @@ function getAutotelTracer(name = "autotel", version) {
 }
 
 //#endregion
-export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
+export { getAutotelTracer, getAutotelTracerProvider, getForceFlushableProvider, setAutotelTracerProvider };
 //# sourceMappingURL=tracer-provider.js.map

package/dist/tracer-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"tracer-provider.js","names":[],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}
+{"version":3,"file":"tracer-provider.js","names":[],"sources":["../src/tracer-provider.ts"],"sourcesContent":["/**\n * Isolated tracer provider support for Autotel\n *\n * Allows Autotel to use a separate TracerProvider instance, avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Use Case:** Library authors who want to use Autotel without interfering\n * with the application's global OpenTelemetry setup.\n *\n * **Limitation:** While this isolates span processing and export, OpenTelemetry\n * context (trace IDs, parent spans) is still shared globally. Spans created with\n * the isolated provider may inherit trace context from global spans.\n */\n\nimport { trace } from '@opentelemetry/api';\nimport type { TracerProvider } from '@opentelemetry/api';\n\n/**\n * Symbol for storing isolated tracer provider in global scope\n * Using Symbol.for() ensures the same symbol across module boundaries\n */\nconst AUTOTEL_GLOBAL_SYMBOL = Symbol.for('autotel');\n\n/**\n * Global state for Autotel\n */\ntype AutotelGlobalState = {\n  isolatedTracerProvider: TracerProvider | null;\n};\n\n/**\n * Create initial state\n */\nfunction createState(): AutotelGlobalState {\n  return {\n    isolatedTracerProvider: null,\n  };\n}\n\n/**\n * Extend globalThis to include our symbol\n */\ninterface GlobalThis {\n  [AUTOTEL_GLOBAL_SYMBOL]?: AutotelGlobalState;\n}\n\n/**\n * Get the global state, creating it if it doesn't exist\n * Handles edge cases like missing globalThis\n */\nfunction getGlobalState(): AutotelGlobalState {\n  const initialState = createState();\n\n  try {\n    const g = globalThis as typeof globalThis & GlobalThis;\n\n    if (typeof g !== 'object' || g === null) {\n      console.warn(\n        '[autotel] globalThis is not available, using fallback state',\n      );\n      return initialState;\n    }\n\n    if (!g[AUTOTEL_GLOBAL_SYMBOL]) {\n      Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {\n        value: initialState,\n        writable: false, // Lock the slot (not the contents)\n        configurable: false,\n        enumerable: false,\n      });\n    }\n\n    return g[AUTOTEL_GLOBAL_SYMBOL]!;\n  } catch (error) {\n    if (error instanceof Error) {\n      console.error(\n        `[autotel] Failed to access global state: ${error.message}`,\n      );\n    } else {\n      console.error(\n        `[autotel] Failed to access global state: ${String(error)}`,\n      );\n    }\n\n    return initialState;\n  }\n}\n\n/**\n * Sets an isolated TracerProvider for Autotel tracing operations.\n *\n * This allows Autotel to use its own TracerProvider instance, separate from\n * the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts\n * with other OpenTelemetry instrumentation in the application.\n *\n * **Limitation: Span Context Sharing**\n *\n * While this function isolates span processing and export, it does NOT provide\n * complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is\n * still shared between the global and isolated providers. This means:\n *\n * - Spans created with the isolated provider inherit trace IDs from global spans\n * - Spans created with the isolated provider inherit parent relationships from global spans\n * - This can result in spans from different providers being part of the same logical trace\n *\n * **Why this happens:**\n * OpenTelemetry uses a global context propagation mechanism that operates at the\n * JavaScript runtime level, independent of individual TracerProvider instances.\n * The context (containing trace ID, span ID) flows through async boundaries and\n * is inherited by all spans created within that context, regardless of which\n * TracerProvider creates them.\n *\n * **When to use this:**\n * - Library code that ships with embedded Autotel\n * - SDKs that want observability without requiring users to set up OpenTelemetry\n * - Applications that need separate span processing for different subsystems\n * - Testing scenarios where you want to isolate trace collection\n *\n * @param provider - The TracerProvider instance to use, or null to clear the isolated provider\n *\n * @example Library with embedded Autotel\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'\n * import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'\n * import { setAutolem\n\netryTracerProvider } from 'autotel/tracer-provider'\n *\n * // Create provider with span processors in constructor\n * const exporter = new OTLPTraceExporter({\n *   url: 'https://your-backend.com/v1/traces'\n * })\n *\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new BatchSpanProcessor(exporter))\n *\n * // Set as Autotel's isolated provider (doesn't call provider.register())\n * setAutotelTracerProvider(provider)\n *\n * // Now all Autotel trace() calls use this provider\n * // But won't interfere with the application's global OpenTelemetry setup\n * ```\n *\n * @example Testing with isolated provider\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Test setup\n * const exporter = new InMemorySpanExporter()\n * const provider = new NodeTracerProvider()\n * provider.addSpanProcessor(new SimpleSpanProcessor(exporter))\n *\n * setAutotelTracerProvider(provider)\n *\n * // Run tests...\n * const spans = exporter.getFinishedSpans()\n *\n * // Cleanup\n * setAutotelTracerProvider(null)\n * ```\n *\n * @example Multiple subsystems with different exporters\n * ```typescript\n * import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'\n * import { setAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * // Payment subsystem - send to payment team's backend\n * const paymentProvider = new NodeTracerProvider()\n * paymentProvider.addSpanProcessor(new BatchSpanProcessor(\n *   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })\n * ))\n *\n * // In payment module initialization\n * setAutotelTracerProvider(paymentProvider)\n * ```\n *\n * @public\n */\nexport function setAutotelTracerProvider(\n  provider: TracerProvider | null,\n): void {\n  getGlobalState().isolatedTracerProvider = provider;\n}\n\n/**\n * Gets the TracerProvider for Autotel tracing operations.\n *\n * Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),\n * otherwise falls back to the global OpenTelemetry TracerProvider.\n *\n * This function is used internally by Autotel's trace functions. Most users\n * will not need to call this directly.\n *\n * @returns The TracerProvider instance to use for Autotel tracing\n *\n * @example Getting the current provider\n * ```typescript\n * import { getAutotelTracerProvider } from 'autotel/tracer-provider'\n *\n * const provider = getAutotelTracerProvider()\n * const tracer = provider.getTracer('my-service', '1.0.0')\n * ```\n *\n * @example Checking if isolated provider is active\n * ```typescript\n * import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'\n * import { trace } from '@opentelemetry/api'\n *\n * const currentProvider = getAutotelTracerProvider()\n * const globalProvider = trace.getTracerProvider()\n *\n * if (currentProvider === globalProvider) {\n *   console.log('Using global provider')\n * } else {\n *   console.log('Using isolated provider')\n * }\n * ```\n *\n * @public\n */\nexport function getAutotelTracerProvider(): TracerProvider {\n  const { isolatedTracerProvider } = getGlobalState();\n\n  if (isolatedTracerProvider) return isolatedTracerProvider;\n\n  return trace.getTracerProvider();\n}\n\n/** A tracer provider that can be force-flushed (SDK providers implement this). */\ninterface ForceFlushable {\n  forceFlush(): Promise<void>;\n}\n\nfunction isForceFlushable(value: unknown): value is ForceFlushable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as ForceFlushable).forceFlush === 'function'\n  );\n}\n\n/**\n * Resolve a tracer provider that can be `forceFlush()`ed, so `flush()` and\n * flush-on-shutdown actually export pending spans.\n *\n * `NodeSDK.getTracerProvider()` returns `undefined` on `@opentelemetry/sdk-node`\n * 0.220+ (OpenTelemetry 2.x), so code that force-flushes only via the SDK\n * handle silently exports nothing. This falls back to the globally registered\n * provider and unwraps the API's `ProxyTracerProvider` to reach the real\n * delegate, which is where `forceFlush` actually lives.\n *\n * @param sdk - Optional NodeSDK handle to try first.\n * @returns Something with `forceFlush()`, or `undefined` if none is registered.\n */\nexport function getForceFlushableProvider(\n  sdk?: unknown,\n): ForceFlushable | undefined {\n  const candidates: unknown[] = [];\n\n  const sdkAny = sdk as { getTracerProvider?: () => unknown } | undefined;\n  if (sdkAny && typeof sdkAny.getTracerProvider === 'function') {\n    candidates.push(sdkAny.getTracerProvider());\n  }\n\n  const globalProvider = trace.getTracerProvider() as unknown;\n  candidates.push(globalProvider);\n  // The API hands back a ProxyTracerProvider; the real provider (with\n  // forceFlush) sits behind getDelegate().\n  const proxy = globalProvider as { getDelegate?: () => unknown };\n  if (proxy && typeof proxy.getDelegate === 'function') {\n    candidates.push(proxy.getDelegate());\n  }\n\n  return candidates.find(isForceFlushable);\n}\n\n/**\n * Gets the OpenTelemetry tracer instance for Autotel.\n *\n * This function returns a tracer specifically configured for Autotel\n * with the correct tracer name and version. Used internally by all\n * Autotel tracing functions to ensure consistent trace creation.\n *\n * Uses the isolated provider if set, otherwise uses the global provider.\n *\n * @param name - Tracer name (default: 'autotel')\n * @param version - Optional version string\n * @returns The Autotel OpenTelemetry tracer instance\n *\n * @example Basic usage\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer()\n * const span = tracer.startSpan('my-operation')\n * // ... use span\n * span.end()\n * ```\n *\n * @example Custom tracer name\n * ```typescript\n * import { getAutotelTracer } from 'autotel/tracer-provider'\n *\n * const tracer = getAutotelTracer('my-library', '2.1.0')\n * ```\n *\n * @public\n */\nexport function getAutotelTracer(name = 'autotel', version?: string) {\n  return getAutotelTracerProvider().getTracer(name, version);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBA,MAAM,wBAAwB,OAAO,IAAI,SAAS;;;;AAYlD,SAAS,cAAkC;CACzC,OAAO,EACL,wBAAwB,KAC1B;AACF;;;;;AAaA,SAAS,iBAAqC;CAC5C,MAAM,eAAe,YAAY;CAEjC,IAAI;EACF,MAAM,IAAI;EAEV,IAAI,OAAO,MAAM,YAAY,MAAM,MAAM;GACvC,QAAQ,KACN,6DACF;GACA,OAAO;EACT;EAEA,IAAI,CAAC,EAAE,wBACL,OAAO,eAAe,GAAG,uBAAuB;GAC9C,OAAO;GACP,UAAU;GACV,cAAc;GACd,YAAY;EACd,CAAC;EAGH,OAAO,EAAE;CACX,SAAS,OAAO;EACd,IAAI,iBAAiB,OACnB,QAAQ,MACN,4CAA4C,MAAM,SACpD;OAEA,QAAQ,MACN,4CAA4C,OAAO,KAAK,GAC1D;EAGF,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,yBACd,UACM;CACN,eAAe,CAAC,CAAC,yBAAyB;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,2BAA2C;CACzD,MAAM,EAAE,2BAA2B,eAAe;CAElD,IAAI,wBAAwB,OAAO;CAEnC,OAAO,MAAM,kBAAkB;AACjC;AAOA,SAAS,iBAAiB,OAAyC;CACjE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAyB,eAAe;AAEpD;;;;;;;;;;;;;;AAeA,SAAgB,0BACd,KAC4B;CAC5B,MAAM,aAAwB,CAAC;CAE/B,MAAM,SAAS;CACf,IAAI,UAAU,OAAO,OAAO,sBAAsB,YAChD,WAAW,KAAK,OAAO,kBAAkB,CAAC;CAG5C,MAAM,iBAAiB,MAAM,kBAAkB;CAC/C,WAAW,KAAK,cAAc;CAG9B,MAAM,QAAQ;CACd,IAAI,SAAS,OAAO,MAAM,gBAAgB,YACxC,WAAW,KAAK,MAAM,YAAY,CAAC;CAGrC,OAAO,WAAW,KAAK,gBAAgB;AACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,OAAO,WAAW,SAAkB;CACnE,OAAO,yBAAyB,CAAC,CAAC,UAAU,MAAM,OAAO;AAC3D"}

package/dist/{track-D7O7oIZa.js → track-BBcxEJEC.js}

@@ -1,5 +1,5 @@
 import { getConfig } from "./config.js";
-import { c as isInitialized, d as warnIfNotInitialized, i as getLogger, n as getConfig$1, o as getValidationConfig, r as getEventsConfig } from "./init-BvBB45-T.js";
+import { c as isInitialized, d as warnIfNotInitialized, i as getLogger, n as getConfig$1, o as getValidationConfig, r as getEventsConfig } from "./init-CdEWjhvl.js";
 import { r as recordStructuredError } from "./structured-error-9--cxBay.js";
 import { context, propagation, trace } from "@opentelemetry/api";
 import * as nodeAsyncHooks from "node:async_hooks";
@@ -724,11 +724,10 @@ var EventQueue = class {
 	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 failedEventIndicesOrdered = [...new Set(failedDeliveries.map((f) => f.eventIndex))].toSorted((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];
+			for (const [j, origIndex] of failedEventIndicesOrdered.entries()) {
 				const set = /* @__PURE__ */ new Set();
 				for (const { eventIndex, subscriberName } of failedDeliveries) if (eventIndex === origIndex) set.add(subscriberName);
 				failedSubscribersByRetryIndex.set(j, set);
@@ -765,15 +764,11 @@ var EventQueue = class {
 			});
 		};
 		if (!this.rateLimiter) {
-			for (let i = 0; i < events.length; i++) {
-				const event = events[i];
-				if (event) await sendOne(event, i);
-			}
+			for (const [i, event] of events.entries()) if (event) await sendOne(event, i);
 			return failedDeliveries;
 		}
-		for (let i = 0; i < events.length; i++) {
+		for (const [i, event] of events.entries()) {
 			await this.rateLimiter.waitForToken();
-			const event = events[i];
 			if (event) await sendOne(event, i);
 		}
 		return failedDeliveries;
@@ -1111,5 +1106,5 @@ function resetEventQueue() {
 }
 
 //#endregion
-export { getContextStorage as _, CORRELATION_ID_BAGGAGE_KEY as a, getCorrelationStorage as c, setCorrelationId as d, setCorrelationIdInBaggage as f, getActiveContextWithBaggage as g, enterOrRun as h, validateEvent as i, getOrCreateCorrelationId as l, defineBaggageSchema as m, resetEventQueue as n, generateCorrelationId as o, createTraceContext as p, track as r, getCorrelationId as s, getEventQueue as t, runWithCorrelationId as u };
-//# sourceMappingURL=track-D7O7oIZa.js.map
+export { CORRELATION_ID_BAGGAGE_KEY as a, getCorrelationStorage as c, setCorrelationId as d, setCorrelationIdInBaggage as f, getContextStorage as g, getActiveContextWithBaggage as h, validateEvent as i, getOrCreateCorrelationId as l, defineBaggageSchema as m, resetEventQueue as n, generateCorrelationId as o, createTraceContext as p, track as r, getCorrelationId as s, getEventQueue as t, runWithCorrelationId as u };
+//# sourceMappingURL=track-BBcxEJEC.js.map