autotel 3.5.0 → 3.7.0

package/dist/tracer-provider.cjs

@@ -1,20 +1,231 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _opentelemetry_api = require("@opentelemetry/api");
 
-var chunkYREV3LGG_cjs = require('./chunk-YREV3LGG.cjs');
+//#region src/tracer-provider.ts
+/**
+* Isolated tracer provider support for Autotel
+*
+* Allows Autotel to use a separate TracerProvider instance, avoiding conflicts
+* with other OpenTelemetry instrumentation in the application.
+*
+* **Use Case:** Library authors who want to use Autotel without interfering
+* with the application's global OpenTelemetry setup.
+*
+* **Limitation:** While this isolates span processing and export, OpenTelemetry
+* context (trace IDs, parent spans) is still shared globally. Spans created with
+* the isolated provider may inherit trace context from global spans.
+*/
+/**
+* Symbol for storing isolated tracer provider in global scope
+* Using Symbol.for() ensures the same symbol across module boundaries
+*/
+const AUTOTEL_GLOBAL_SYMBOL = Symbol.for("autotel");
+/**
+* Create initial state
+*/
+function createState() {
+	return { isolatedTracerProvider: null };
+}
+/**
+* Get the global state, creating it if it doesn't exist
+* Handles edge cases like missing globalThis
+*/
+function getGlobalState() {
+	const initialState = createState();
+	try {
+		const g = globalThis;
+		if (typeof g !== "object" || g === null) {
+			console.warn("[autotel] globalThis is not available, using fallback state");
+			return initialState;
+		}
+		if (!g[AUTOTEL_GLOBAL_SYMBOL]) Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {
+			value: initialState,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+		return g[AUTOTEL_GLOBAL_SYMBOL];
+	} catch (error) {
+		if (error instanceof Error) console.error(`[autotel] Failed to access global state: ${error.message}`);
+		else console.error(`[autotel] Failed to access global state: ${String(error)}`);
+		return initialState;
+	}
+}
+/**
+* Sets an isolated TracerProvider for Autotel tracing operations.
+*
+* This allows Autotel to use its own TracerProvider instance, separate from
+* the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts
+* with other OpenTelemetry instrumentation in the application.
+*
+* **Limitation: Span Context Sharing**
+*
+* While this function isolates span processing and export, it does NOT provide
+* complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is
+* still shared between the global and isolated providers. This means:
+*
+* - Spans created with the isolated provider inherit trace IDs from global spans
+* - Spans created with the isolated provider inherit parent relationships from global spans
+* - This can result in spans from different providers being part of the same logical trace
+*
+* **Why this happens:**
+* OpenTelemetry uses a global context propagation mechanism that operates at the
+* JavaScript runtime level, independent of individual TracerProvider instances.
+* The context (containing trace ID, span ID) flows through async boundaries and
+* is inherited by all spans created within that context, regardless of which
+* TracerProvider creates them.
+*
+* **When to use this:**
+* - Library code that ships with embedded Autotel
+* - SDKs that want observability without requiring users to set up OpenTelemetry
+* - Applications that need separate span processing for different subsystems
+* - Testing scenarios where you want to isolate trace collection
+*
+* @param provider - The TracerProvider instance to use, or null to clear the isolated provider
+*
+* @example Library with embedded Autotel
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
+* import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
+* import { setAutolem
 
+etryTracerProvider } from 'autotel/tracer-provider'
+*
+* // Create provider with span processors in constructor
+* const exporter = new OTLPTraceExporter({
+*   url: 'https://your-backend.com/v1/traces'
+* })
+*
+* const provider = new NodeTracerProvider()
+* provider.addSpanProcessor(new BatchSpanProcessor(exporter))
+*
+* // Set as Autotel's isolated provider (doesn't call provider.register())
+* setAutotelTracerProvider(provider)
+*
+* // Now all Autotel trace() calls use this provider
+* // But won't interfere with the application's global OpenTelemetry setup
+* ```
+*
+* @example Testing with isolated provider
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'
+* import { setAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* // Test setup
+* const exporter = new InMemorySpanExporter()
+* const provider = new NodeTracerProvider()
+* provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
+*
+* setAutotelTracerProvider(provider)
+*
+* // Run tests...
+* const spans = exporter.getFinishedSpans()
+*
+* // Cleanup
+* setAutotelTracerProvider(null)
+* ```
+*
+* @example Multiple subsystems with different exporters
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { setAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* // Payment subsystem - send to payment team's backend
+* const paymentProvider = new NodeTracerProvider()
+* paymentProvider.addSpanProcessor(new BatchSpanProcessor(
+*   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })
+* ))
+*
+* // In payment module initialization
+* setAutotelTracerProvider(paymentProvider)
+* ```
+*
+* @public
+*/
+function setAutotelTracerProvider(provider) {
+	getGlobalState().isolatedTracerProvider = provider;
+}
+/**
+* Gets the TracerProvider for Autotel tracing operations.
+*
+* Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),
+* otherwise falls back to the global OpenTelemetry TracerProvider.
+*
+* This function is used internally by Autotel's trace functions. Most users
+* will not need to call this directly.
+*
+* @returns The TracerProvider instance to use for Autotel tracing
+*
+* @example Getting the current provider
+* ```typescript
+* import { getAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* const provider = getAutotelTracerProvider()
+* const tracer = provider.getTracer('my-service', '1.0.0')
+* ```
+*
+* @example Checking if isolated provider is active
+* ```typescript
+* import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'
+* import { trace } from '@opentelemetry/api'
+*
+* const currentProvider = getAutotelTracerProvider()
+* const globalProvider = trace.getTracerProvider()
+*
+* if (currentProvider === globalProvider) {
+*   console.log('Using global provider')
+* } else {
+*   console.log('Using isolated provider')
+* }
+* ```
+*
+* @public
+*/
+function getAutotelTracerProvider() {
+	const { isolatedTracerProvider } = getGlobalState();
+	if (isolatedTracerProvider) return isolatedTracerProvider;
+	return _opentelemetry_api.trace.getTracerProvider();
+}
+/**
+* Gets the OpenTelemetry tracer instance for Autotel.
+*
+* This function returns a tracer specifically configured for Autotel
+* with the correct tracer name and version. Used internally by all
+* Autotel tracing functions to ensure consistent trace creation.
+*
+* Uses the isolated provider if set, otherwise uses the global provider.
+*
+* @param name - Tracer name (default: 'autotel')
+* @param version - Optional version string
+* @returns The Autotel OpenTelemetry tracer instance
+*
+* @example Basic usage
+* ```typescript
+* import { getAutotelTracer } from 'autotel/tracer-provider'
+*
+* const tracer = getAutotelTracer()
+* const span = tracer.startSpan('my-operation')
+* // ... use span
+* span.end()
+* ```
+*
+* @example Custom tracer name
+* ```typescript
+* import { getAutotelTracer } from 'autotel/tracer-provider'
+*
+* const tracer = getAutotelTracer('my-library', '2.1.0')
+* ```
+*
+* @public
+*/
+function getAutotelTracer(name = "autotel", version) {
+	return getAutotelTracerProvider().getTracer(name, version);
+}
 
-
-Object.defineProperty(exports, "getAutotelTracer", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.getAutotelTracer; }
-});
-Object.defineProperty(exports, "getAutotelTracerProvider", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.getAutotelTracerProvider; }
-});
-Object.defineProperty(exports, "setAutotelTracerProvider", {
-  enumerable: true,
-  get: function () { return chunkYREV3LGG_cjs.setAutotelTracerProvider; }
-});
-//# sourceMappingURL=tracer-provider.cjs.map
+//#endregion
+exports.getAutotelTracer = getAutotelTracer;
+exports.getAutotelTracerProvider = getAutotelTracerProvider;
+exports.setAutotelTracerProvider = setAutotelTracerProvider;
 //# sourceMappingURL=tracer-provider.cjs.map

package/dist/tracer-provider.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"tracer-provider.cjs"}
+{"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"}

package/dist/tracer-provider.d.cts

@@ -1,6 +1,6 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { TracerProvider } from '@opentelemetry/api';
+import { TracerProvider } from "@opentelemetry/api";
 
+//#region src/tracer-provider.d.ts
 /**
  * Sets an isolated TracerProvider for Autotel tracing operations.
  *
@@ -164,6 +164,7 @@ declare function getAutotelTracerProvider(): TracerProvider;
  *
  * @public
  */
-declare function getAutotelTracer(name?: string, version?: string): _opentelemetry_api.Tracer;
-
+declare function getAutotelTracer(name?: string, version?: string): import("@opentelemetry/api").Tracer;
+//#endregion
 export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
+//# sourceMappingURL=tracer-provider.d.cts.map

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

@@ -0,0 +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"}

package/dist/tracer-provider.d.ts

@@ -1,6 +1,6 @@
-import * as _opentelemetry_api from '@opentelemetry/api';
-import { TracerProvider } from '@opentelemetry/api';
+import { TracerProvider } from "@opentelemetry/api";
 
+//#region src/tracer-provider.d.ts
 /**
  * Sets an isolated TracerProvider for Autotel tracing operations.
  *
@@ -164,6 +164,7 @@ declare function getAutotelTracerProvider(): TracerProvider;
  *
  * @public
  */
-declare function getAutotelTracer(name?: string, version?: string): _opentelemetry_api.Tracer;
-
+declare function getAutotelTracer(name?: string, version?: string): import("@opentelemetry/api").Tracer;
+//#endregion
 export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
+//# sourceMappingURL=tracer-provider.d.ts.map

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

@@ -0,0 +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"}

package/dist/tracer-provider.js

@@ -1,3 +1,228 @@
-export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from './chunk-HA2WBOGQ.js';
-//# sourceMappingURL=tracer-provider.js.map
+import { trace } from "@opentelemetry/api";
+
+//#region src/tracer-provider.ts
+/**
+* Isolated tracer provider support for Autotel
+*
+* Allows Autotel to use a separate TracerProvider instance, avoiding conflicts
+* with other OpenTelemetry instrumentation in the application.
+*
+* **Use Case:** Library authors who want to use Autotel without interfering
+* with the application's global OpenTelemetry setup.
+*
+* **Limitation:** While this isolates span processing and export, OpenTelemetry
+* context (trace IDs, parent spans) is still shared globally. Spans created with
+* the isolated provider may inherit trace context from global spans.
+*/
+/**
+* Symbol for storing isolated tracer provider in global scope
+* Using Symbol.for() ensures the same symbol across module boundaries
+*/
+const AUTOTEL_GLOBAL_SYMBOL = Symbol.for("autotel");
+/**
+* Create initial state
+*/
+function createState() {
+	return { isolatedTracerProvider: null };
+}
+/**
+* Get the global state, creating it if it doesn't exist
+* Handles edge cases like missing globalThis
+*/
+function getGlobalState() {
+	const initialState = createState();
+	try {
+		const g = globalThis;
+		if (typeof g !== "object" || g === null) {
+			console.warn("[autotel] globalThis is not available, using fallback state");
+			return initialState;
+		}
+		if (!g[AUTOTEL_GLOBAL_SYMBOL]) Object.defineProperty(g, AUTOTEL_GLOBAL_SYMBOL, {
+			value: initialState,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+		return g[AUTOTEL_GLOBAL_SYMBOL];
+	} catch (error) {
+		if (error instanceof Error) console.error(`[autotel] Failed to access global state: ${error.message}`);
+		else console.error(`[autotel] Failed to access global state: ${String(error)}`);
+		return initialState;
+	}
+}
+/**
+* Sets an isolated TracerProvider for Autotel tracing operations.
+*
+* This allows Autotel to use its own TracerProvider instance, separate from
+* the global OpenTelemetry TracerProvider. This is useful for avoiding conflicts
+* with other OpenTelemetry instrumentation in the application.
+*
+* **Limitation: Span Context Sharing**
+*
+* While this function isolates span processing and export, it does NOT provide
+* complete trace isolation. OpenTelemetry context (trace IDs, parent spans) is
+* still shared between the global and isolated providers. This means:
+*
+* - Spans created with the isolated provider inherit trace IDs from global spans
+* - Spans created with the isolated provider inherit parent relationships from global spans
+* - This can result in spans from different providers being part of the same logical trace
+*
+* **Why this happens:**
+* OpenTelemetry uses a global context propagation mechanism that operates at the
+* JavaScript runtime level, independent of individual TracerProvider instances.
+* The context (containing trace ID, span ID) flows through async boundaries and
+* is inherited by all spans created within that context, regardless of which
+* TracerProvider creates them.
+*
+* **When to use this:**
+* - Library code that ships with embedded Autotel
+* - SDKs that want observability without requiring users to set up OpenTelemetry
+* - Applications that need separate span processing for different subsystems
+* - Testing scenarios where you want to isolate trace collection
+*
+* @param provider - The TracerProvider instance to use, or null to clear the isolated provider
+*
+* @example Library with embedded Autotel
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
+* import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
+* import { setAutolem
+
+etryTracerProvider } from 'autotel/tracer-provider'
+*
+* // Create provider with span processors in constructor
+* const exporter = new OTLPTraceExporter({
+*   url: 'https://your-backend.com/v1/traces'
+* })
+*
+* const provider = new NodeTracerProvider()
+* provider.addSpanProcessor(new BatchSpanProcessor(exporter))
+*
+* // Set as Autotel's isolated provider (doesn't call provider.register())
+* setAutotelTracerProvider(provider)
+*
+* // Now all Autotel trace() calls use this provider
+* // But won't interfere with the application's global OpenTelemetry setup
+* ```
+*
+* @example Testing with isolated provider
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base'
+* import { setAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* // Test setup
+* const exporter = new InMemorySpanExporter()
+* const provider = new NodeTracerProvider()
+* provider.addSpanProcessor(new SimpleSpanProcessor(exporter))
+*
+* setAutotelTracerProvider(provider)
+*
+* // Run tests...
+* const spans = exporter.getFinishedSpans()
+*
+* // Cleanup
+* setAutotelTracerProvider(null)
+* ```
+*
+* @example Multiple subsystems with different exporters
+* ```typescript
+* import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
+* import { setAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* // Payment subsystem - send to payment team's backend
+* const paymentProvider = new NodeTracerProvider()
+* paymentProvider.addSpanProcessor(new BatchSpanProcessor(
+*   new OTLPTraceExporter({ url: 'https://payment-team-backend.com/v1/traces' })
+* ))
+*
+* // In payment module initialization
+* setAutotelTracerProvider(paymentProvider)
+* ```
+*
+* @public
+*/
+function setAutotelTracerProvider(provider) {
+	getGlobalState().isolatedTracerProvider = provider;
+}
+/**
+* Gets the TracerProvider for Autotel tracing operations.
+*
+* Returns the isolated TracerProvider if one has been set via setAutotelTracerProvider(),
+* otherwise falls back to the global OpenTelemetry TracerProvider.
+*
+* This function is used internally by Autotel's trace functions. Most users
+* will not need to call this directly.
+*
+* @returns The TracerProvider instance to use for Autotel tracing
+*
+* @example Getting the current provider
+* ```typescript
+* import { getAutotelTracerProvider } from 'autotel/tracer-provider'
+*
+* const provider = getAutotelTracerProvider()
+* const tracer = provider.getTracer('my-service', '1.0.0')
+* ```
+*
+* @example Checking if isolated provider is active
+* ```typescript
+* import { getAutotelTracerProvider, setAutotelTracerProvider } from 'autotel/tracer-provider'
+* import { trace } from '@opentelemetry/api'
+*
+* const currentProvider = getAutotelTracerProvider()
+* const globalProvider = trace.getTracerProvider()
+*
+* if (currentProvider === globalProvider) {
+*   console.log('Using global provider')
+* } else {
+*   console.log('Using isolated provider')
+* }
+* ```
+*
+* @public
+*/
+function getAutotelTracerProvider() {
+	const { isolatedTracerProvider } = getGlobalState();
+	if (isolatedTracerProvider) return isolatedTracerProvider;
+	return trace.getTracerProvider();
+}
+/**
+* Gets the OpenTelemetry tracer instance for Autotel.
+*
+* This function returns a tracer specifically configured for Autotel
+* with the correct tracer name and version. Used internally by all
+* Autotel tracing functions to ensure consistent trace creation.
+*
+* Uses the isolated provider if set, otherwise uses the global provider.
+*
+* @param name - Tracer name (default: 'autotel')
+* @param version - Optional version string
+* @returns The Autotel OpenTelemetry tracer instance
+*
+* @example Basic usage
+* ```typescript
+* import { getAutotelTracer } from 'autotel/tracer-provider'
+*
+* const tracer = getAutotelTracer()
+* const span = tracer.startSpan('my-operation')
+* // ... use span
+* span.end()
+* ```
+*
+* @example Custom tracer name
+* ```typescript
+* import { getAutotelTracer } from 'autotel/tracer-provider'
+*
+* const tracer = getAutotelTracer('my-library', '2.1.0')
+* ```
+*
+* @public
+*/
+function getAutotelTracer(name = "autotel", version) {
+	return getAutotelTracerProvider().getTracer(name, version);
+}
+
+//#endregion
+export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider };
 //# sourceMappingURL=tracer-provider.js.map

package/dist/tracer-provider.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"tracer-provider.js"}
+{"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"}