autotel 7.7.1 → 7.8.0

package/dist/{init-Dyq6WtsO.js → init-8SISAGdE.js}

@@ -10,21 +10,170 @@ import { AttributeRedactingProcessor, REDACTOR_PRESETS, normalizeAttributeRedact
 import { t as PrettyConsoleExporter } from "./pretty-console-exporter-DqKl_q9z.js";
 import { t as CanonicalLogLineProcessor } from "./canonical-log-line-processor-BQ6NeZAk.js";
 import { resetMetrics } from "./metric.js";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { AlwaysOffSampler, AlwaysOnSampler, BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, SamplingDecision, SimpleSpanProcessor, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
-import { resourceFromAttributes } from "@opentelemetry/resources";
+import { DiagConsoleLogger, DiagLogLevel, TraceFlags, context, diag, metrics, propagation, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { CompositePropagator, W3CBaggagePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { detectResources, envDetector, hostDetector, processDetector, resourceFromAttributes } from "@opentelemetry/resources";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { AlwaysOffSampler, AlwaysOnSampler, BasicTracerProvider, BatchSpanProcessor, ConsoleSpanExporter, ParentBasedSampler, SamplingDecision, SimpleSpanProcessor, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
-import { TraceFlags, context, propagation, trace } from "@opentelemetry/api";
 import * as nodeAsyncHooks from "node:async_hooks";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
 import * as nodeFs from "node:fs";
 import path from "node:path";
 import { constants } from "node:os";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 
+//#region src/sdk.ts
+/**
+* The SDK behind `init()`: builds and registers the tracer, meter and logger
+* providers from components autotel has already resolved.
+*
+* This replaces `@opentelemetry/sdk-node`'s `NodeSDK`. That class did the same
+* registration, but it statically imports every exporter the `OTEL_*_EXPORTER`
+* variables could name — OTLP over gRPC (`@grpc/grpc-js`, `protobufjs`),
+* Prometheus, the YAML file-config loader — so any bundle that contained
+* `init()` shipped ~1 MB of exporters it never used. autotel resolves its own
+* exporters up front, so all it ever needed from `NodeSDK` was `start()`.
+*
+* Kept from `NodeSDK`, because code and tests rely on them:
+*   - `OTEL_SDK_DISABLED=true` makes `start()` a no-op.
+*   - `OTEL_LOG_LEVEL` installs the console diag logger.
+*   - Resource: `envDetector`, `processDetector` and `hostDetector` are merged
+*     in, then `serviceName` is applied last so the resolved autotel value
+*     wins (`OTEL_NODE_RESOURCE_DETECTORS=none` turns detection off).
+*   - Context manager: `AsyncLocalStorageContextManager`.
+*   - Propagator: W3C trace context + baggage, or `OTEL_PROPAGATORS`.
+*   - Providers are only registered when they have something to do; an empty
+*     `spanProcessors` list still registers a tracer provider, so context keeps
+*     propagating even when nothing is exported.
+*
+* Not kept: building an exporter from `OTEL_TRACES_EXPORTER` /
+* `OTEL_LOGS_EXPORTER` / `OTEL_METRICS_EXPORTER`. autotel always passes its own
+* processors, so the traces and metrics variables never reached `NodeSDK`
+* anyway; `OTEL_LOGS_EXPORTER=none` still switches logs off, and `otlp` gets
+* the OTLP/HTTP log exporter. gRPC and Prometheus are no longer reachable from
+* the environment — pass an exporter through `init()` instead.
+*/
+const DIAG_LEVELS = {
+	ALL: DiagLogLevel.ALL,
+	VERBOSE: DiagLogLevel.VERBOSE,
+	DEBUG: DiagLogLevel.DEBUG,
+	INFO: DiagLogLevel.INFO,
+	WARN: DiagLogLevel.WARN,
+	ERROR: DiagLogLevel.ERROR,
+	NONE: DiagLogLevel.NONE
+};
+function envFlag(name) {
+	return (process.env[name] ?? "").trim().toLowerCase() === "true";
+}
+function propagatorFromEnv() {
+	const raw = process.env.OTEL_PROPAGATORS?.trim();
+	if (!raw) return void 0;
+	const names = raw.split(",").map((n) => n.trim().toLowerCase()).filter(Boolean);
+	if (names.includes("none")) return new CompositePropagator({ propagators: [] });
+	const propagators = [];
+	for (const name of names) if (name === "tracecontext") propagators.push(new W3CTraceContextPropagator());
+	else if (name === "baggage") propagators.push(new W3CBaggagePropagator());
+	else diag.warn(`[autotel] OTEL_PROPAGATORS names "${name}", which needs a propagator package autotel does not bundle; pass one via init({ propagator }).`);
+	return propagators.length > 0 ? new CompositePropagator({ propagators }) : void 0;
+}
+function defaultPropagator() {
+	return new CompositePropagator({ propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()] });
+}
+var AutotelSdk = class {
+	options;
+	disabled;
+	tracerProvider;
+	meterProvider;
+	loggerProvider;
+	constructor(options = {}) {
+		this.options = options;
+		this.disabled = envFlag("OTEL_SDK_DISABLED");
+		const level = process.env.OTEL_LOG_LEVEL?.trim().toUpperCase();
+		if (level && DIAG_LEVELS[level] !== void 0) diag.setLogger(new DiagConsoleLogger(), { logLevel: DIAG_LEVELS[level] });
+	}
+	start() {
+		if (this.disabled) return;
+		const o = this.options;
+		const instrumentations = (o.instrumentations ?? []).flat();
+		registerInstrumentations({ instrumentations });
+		context.setGlobalContextManager(new AsyncLocalStorageContextManager().enable());
+		if (o.textMapPropagator !== null) propagation.setGlobalPropagator(o.textMapPropagator ?? propagatorFromEnv() ?? defaultPropagator());
+		const resource = this.resolveResource();
+		if (o.metricReaders && o.metricReaders.length > 0) {
+			this.meterProvider = new MeterProvider({
+				resource,
+				readers: o.metricReaders
+			});
+			metrics.setGlobalMeterProvider(this.meterProvider);
+			for (const instrumentation of instrumentations) instrumentation.setMeterProvider(this.meterProvider);
+		}
+		this.tracerProvider = new BasicTracerProvider({
+			resource,
+			spanProcessors: o.spanProcessors ?? [],
+			...o.sampler && { sampler: o.sampler }
+		});
+		trace.setGlobalTracerProvider(this.tracerProvider);
+		const logProcessors = this.resolveLogProcessors();
+		if (logProcessors) {
+			this.loggerProvider = new LoggerProvider({
+				resource,
+				processors: logProcessors
+			});
+			logs.setGlobalLoggerProvider(this.loggerProvider);
+		}
+	}
+	getTracerProvider() {
+		return this.tracerProvider;
+	}
+	async shutdown() {
+		await Promise.allSettled([
+			this.tracerProvider?.forceFlush(),
+			this.loggerProvider?.forceFlush(),
+			this.meterProvider?.forceFlush()
+		]);
+		await Promise.all([
+			this.tracerProvider?.shutdown(),
+			this.loggerProvider?.shutdown(),
+			this.meterProvider?.shutdown()
+		]);
+	}
+	resolveResource() {
+		const o = this.options;
+		let resource = o.resource ?? resourceFromAttributes({});
+		const detectorsEnv = process.env.OTEL_NODE_RESOURCE_DETECTORS?.trim();
+		if (o.autoDetectResources ?? detectorsEnv?.toLowerCase() !== "none") {
+			const detectors = o.resourceDetectors ?? [
+				envDetector,
+				processDetector,
+				hostDetector
+			];
+			resource = resource.merge(detectResources({ detectors }));
+		}
+		if (o.serviceName !== void 0) resource = resource.merge(resourceFromAttributes({ [ATTR_SERVICE_NAME]: o.serviceName }));
+		return resource;
+	}
+	/**
+	* `init()` passes a list when it configured logs itself and `undefined` to
+	* defer to `OTEL_LOGS_EXPORTER`. Only `otlp` (over HTTP) and `none`/unset
+	* are honoured there; any other value is named in a warning.
+	*/
+	resolveLogProcessors() {
+		const configured = this.options.logRecordProcessors;
+		if (configured) return configured;
+		const fromEnv = process.env.OTEL_LOGS_EXPORTER?.trim().toLowerCase();
+		if (!fromEnv || fromEnv === "none") return void 0;
+		if (fromEnv === "otlp") return [new BatchLogRecordProcessor({ exporter: new OTLPLogExporter() })];
+		diag.warn(`[autotel] OTEL_LOGS_EXPORTER=${fromEnv} is not supported without sdk-node; pass a log exporter via init() instead.`);
+	}
+};
+
+//#endregion
 //#region src/rate-limiter.ts
 /**
 * Token bucket rate limiter
@@ -510,28 +659,30 @@ 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))].toSorted((a, b) => a - b);
-			const eventsToRetry = failedEventIndicesOrdered.map((i) => events[i]);
-			const failedSubscribersByRetryIndex = /* @__PURE__ */ new Map();
-			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);
-			}
-			const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1e3;
-			await new Promise((resolve) => setTimeout(resolve, delay));
-			return this.sendWithRetry(eventsToRetry, retriesLeft - 1, failedSubscribersByRetryIndex);
-		} else {
-			for (const { eventIndex, subscriberName, error } of failedDeliveries) {
-				const event = events[eventIndex];
-				if (event) this.recordFailed(event, subscriberName, error);
+		if (failedDeliveries.length > 0) {
+			if (retriesLeft > 0) {
+				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 (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);
+				}
+				const delay = Math.pow(2, this.config.maxRetries - retriesLeft) * 1e3;
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				return this.sendWithRetry(eventsToRetry, retriesLeft - 1, failedSubscribersByRetryIndex);
+			} else {
+				for (const { eventIndex, subscriberName, error } of failedDeliveries) {
+					const event = events[eventIndex];
+					if (event) this.recordFailed(event, subscriberName, error);
+				}
+				const failedSubscriberNames = [...new Set(failedDeliveries.map((f) => f.subscriberName))];
+				getLogger().error({
+					failedSubscribers: failedSubscriberNames,
+					retriesAttempted: this.config.maxRetries
+				}, "[autotel] Failed to send events after retries");
 			}
-			const failedSubscriberNames = [...new Set(failedDeliveries.map((f) => f.subscriberName))];
-			getLogger().error({
-				failedSubscribers: failedSubscriberNames,
-				retriesAttempted: this.config.maxRetries
-			}, "[autotel] Failed to send events after retries");
 		}
 	}
 	/**
@@ -888,7 +1039,8 @@ function getOrCreateQueue() {
 function track(event, data, options) {
 	const queue = getOrCreateQueue();
 	if (!queue) return;
-	const validated = validateEvent(event, data, getValidationConfig() || void 0);
+	const validationConfig = getValidationConfig();
+	const validated = validateEvent(event, data, validationConfig || void 0);
 	const span = trace.getActiveSpan();
 	const enrichedData = span ? {
 		...validated.attributes,
@@ -2990,7 +3142,8 @@ var Event = class {
 	* ```
 	*/
 	trackEvent(eventName, attributes) {
-		const validated = validateEvent(eventName, attributes, getValidationConfig() || void 0);
+		const validationConfig = getValidationConfig();
+		const validated = validateEvent(eventName, attributes, validationConfig || void 0);
 		const enrichedAttributes = this.enrichWithTelemetryContext(validated.attributes);
 		this.logger?.info({
 			event: validated.eventName,
@@ -4052,7 +4205,8 @@ function init(cfg) {
 	if (devtoolsConfig.enabled && mergedConfig.logs === void 0) mergedConfig.logs = true;
 	const silent = mergedConfig.silent ?? false;
 	const minLevel = mergedConfig.minLevel ?? "info";
-	logger = wrapLogger(mergedConfig.logger || silentLogger, silent, minLevel);
+	const baseLogger = mergedConfig.logger || silentLogger;
+	logger = wrapLogger(baseLogger, silent, minLevel);
 	if (initialized) logger.warn({}, "[autotel] init() called again - last config wins. This may cause unexpected behavior.");
 	config = mergedConfig;
 	validationConfig = mergedConfig.validation || null;
@@ -4165,10 +4319,11 @@ function init(cfg) {
 	if (logsEnabled) {
 		for (const destination of otlpDestinations) {
 			if (!destinationSupportsSignal(destination, "logs")) continue;
-			let processor = new BatchLogRecordProcessor({ exporter: createLogExporter(destination.protocol, {
+			const logExporter = createLogExporter(destination.protocol, {
 				url: formatEndpointUrl(destination.endpoint, "logs", destination.protocol),
 				headers: destination.headers
-			}) });
+			});
+			let processor = new BatchLogRecordProcessor({ exporter: logExporter });
 			if (_stringRedactor) processor = new RedactingLogRecordProcessor(processor, _stringRedactor);
 			if (!logRecordProcessors) logRecordProcessors = [];
 			logRecordProcessors.push(processor);
@@ -4210,8 +4365,8 @@ function init(cfg) {
 	if (metricReaders.length > 0) sdkOptions.metricReaders = metricReaders;
 	if (logRecordProcessors && logRecordProcessors.length > 0) sdkOptions.logRecordProcessors = logRecordProcessors;
 	else if (!process.env.OTEL_LOGS_EXPORTER) sdkOptions.logRecordProcessors = [];
-	sdk = mergedConfig.sdkFactory ? mergedConfig.sdkFactory(sdkOptions) : new NodeSDK(sdkOptions);
-	if (!sdk) throw new Error("[autotel] sdkFactory must return a NodeSDK instance");
+	sdk = mergedConfig.sdkFactory ? mergedConfig.sdkFactory(sdkOptions) : new AutotelSdk(sdkOptions);
+	if (!sdk) throw new Error("[autotel] sdkFactory must return an SDK instance");
 	sdk.start();
 	if (mergedConfig.openllmetry?.enabled) {
 		const traceloop = _optionalRequire("@traceloop/node-server-sdk");

package/dist/{init-WwjD-kQu.d.cts → init-COfMwKbc.d.cts}

@@ -1,17 +1,43 @@
 import { a as AttributeRedactorPreset, r as AttributeRedactorConfig } from "./attribute-redacting-processor-CvBE0z1p.cjs";
 import { s as Logger } from "./logger-S1Fgl0g3.cjs";
-import { g as SamplingPreset, m as Sampler } from "./sampling-Er217Mge.cjs";
+import { g as SamplingPreset, m as Sampler$1 } from "./sampling-DENUjT_8.cjs";
 import { o as EventSubscriber } from "./event-subscriber-DMACQA-1.cjs";
 import { r as SpanFilterPredicate } from "./filtering-span-processor-BpDagWNa.cjs";
 import { r as Policy } from "./policy-C4QcZnqv.cjs";
 import { r as SpanNameNormalizerConfig } from "./span-name-normalizer-CN1-8C76.cjs";
 import { t as CanonicalLogLineOptions } from "./canonical-log-line-processor-C0Z_N4oL.cjs";
-import { ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { Attributes } from "@opentelemetry/api";
-import { Resource } from "@opentelemetry/resources";
-import { NodeSDK, NodeSDKConfiguration } from "@opentelemetry/sdk-node";
-import { MetricReader } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider, ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { Attributes, Sampler, TextMapPropagator } from "@opentelemetry/api";
+import { Resource, ResourceDetector } from "@opentelemetry/resources";
+import { Instrumentation } from "@opentelemetry/instrumentation";
 import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { IMetricReader, MetricReader } from "@opentelemetry/sdk-metrics";
+//#region src/sdk.d.ts
+/**
+ * What `init()` hands the SDK. Field names match `NodeSDKConfiguration` so a
+ * `sdkFactory` written against the old shape still receives what it expects.
+ */
+interface AutotelSdkOptions {
+  resource?: Resource;
+  serviceName?: string;
+  sampler?: Sampler;
+  instrumentations?: (Instrumentation | Instrumentation[])[];
+  spanProcessors?: SpanProcessor[];
+  metricReaders?: IMetricReader[];
+  logRecordProcessors?: LogRecordProcessor[];
+  /** `null` leaves whatever propagator is already registered alone. */
+  textMapPropagator?: TextMapPropagator | null;
+  /** Off by default only via `OTEL_NODE_RESOURCE_DETECTORS=none`. */
+  autoDetectResources?: boolean;
+  resourceDetectors?: ResourceDetector[];
+}
+/** The surface autotel needs from an SDK handle; `NodeSDK` satisfies it too. */
+interface AutotelSdkLike {
+  start(): void;
+  shutdown(): Promise<void>;
+  getTracerProvider?(): BasicTracerProvider | undefined;
+}
+//#endregion
 //#region src/validation.d.ts
 interface ValidationConfig {
   /** Max event name length (default: 100) */
@@ -432,7 +458,7 @@ interface AutotelConfig {
    * })
    * ```
    */
-  instrumentations?: NodeSDKConfiguration['instrumentations'];
+  instrumentations?: AutotelSdkOptions['instrumentations'];
   /**
    * Simple names for auto-instrumentation.
    * Uses @opentelemetry/auto-instrumentations-node (peer dependency).
@@ -756,9 +782,11 @@ interface AutotelConfig {
    */
   protocol?: AutotelProtocol;
   /**
-   * Optional factory to build a customised NodeSDK instance from our defaults.
+   * Optional factory to build a customised SDK from our defaults. The options
+   * use `NodeSDKConfiguration`'s field names, so `new NodeSDK(defaults)` from
+   * `@opentelemetry/sdk-node` is a valid return value.
    */
-  sdkFactory?: (defaults: Partial<NodeSDKConfiguration>) => NodeSDK;
+  sdkFactory?: (defaults: AutotelSdkOptions) => AutotelSdkLike;
   /**
    * Infrastructure metrics configuration
    * - true: always enabled (default)
@@ -794,7 +822,7 @@ interface AutotelConfig {
    */
   logs?: boolean | 'auto';
   /** Sampling strategy - takes precedence over `sampling` preset */
-  sampler?: Sampler;
+  sampler?: Sampler$1;
   /**
    * Sampling preset shorthand — resolves to a pre-configured sampler.
    * If both `sampler` and `sampling` are provided, `sampler` takes precedence.

package/dist/{init-CKSMbJUG.d.ts → init-CnoRlJqS.d.ts}

@@ -1,17 +1,43 @@
-import { a as AttributeRedactorPreset, r as AttributeRedactorConfig } from "./attribute-redacting-processor-CvBE0z1p.js";
+import { a as AttributeRedactorPreset, r as AttributeRedactorConfig } from "./attribute-redacting-processor-rkV_WL-k.js";
 import { s as Logger } from "./logger-S1Fgl0g3.js";
-import { g as SamplingPreset, m as Sampler } from "./sampling-DBng4Foa.js";
+import { g as SamplingPreset, m as Sampler$1 } from "./sampling-CZi7OM9u.js";
 import { o as EventSubscriber } from "./event-subscriber-DMACQA-1.js";
-import { r as SpanFilterPredicate } from "./filtering-span-processor-BpDagWNa.js";
-import { r as Policy } from "./policy-C4QcZnqv.js";
-import { r as SpanNameNormalizerConfig } from "./span-name-normalizer-CN1-8C76.js";
-import { t as CanonicalLogLineOptions } from "./canonical-log-line-processor-Yq4cXcD5.js";
-import { NodeSDK, NodeSDKConfiguration } from "@opentelemetry/sdk-node";
-import { ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { Resource } from "@opentelemetry/resources";
-import { Attributes } from "@opentelemetry/api";
-import { MetricReader } from "@opentelemetry/sdk-metrics";
+import { r as SpanFilterPredicate } from "./filtering-span-processor-vkewzbqB.js";
+import { r as Policy } from "./policy-DNw_0qUq.js";
+import { r as SpanNameNormalizerConfig } from "./span-name-normalizer-DHcg1bSP.js";
+import { t as CanonicalLogLineOptions } from "./canonical-log-line-processor-Bwrt_L4c.js";
+import { Attributes, Sampler, TextMapPropagator } from "@opentelemetry/api";
+import { Instrumentation } from "@opentelemetry/instrumentation";
+import { Resource, ResourceDetector } from "@opentelemetry/resources";
 import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { IMetricReader, MetricReader } from "@opentelemetry/sdk-metrics";
+import { BasicTracerProvider, ReadableSpan, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+//#region src/sdk.d.ts
+/**
+ * What `init()` hands the SDK. Field names match `NodeSDKConfiguration` so a
+ * `sdkFactory` written against the old shape still receives what it expects.
+ */
+interface AutotelSdkOptions {
+  resource?: Resource;
+  serviceName?: string;
+  sampler?: Sampler;
+  instrumentations?: (Instrumentation | Instrumentation[])[];
+  spanProcessors?: SpanProcessor[];
+  metricReaders?: IMetricReader[];
+  logRecordProcessors?: LogRecordProcessor[];
+  /** `null` leaves whatever propagator is already registered alone. */
+  textMapPropagator?: TextMapPropagator | null;
+  /** Off by default only via `OTEL_NODE_RESOURCE_DETECTORS=none`. */
+  autoDetectResources?: boolean;
+  resourceDetectors?: ResourceDetector[];
+}
+/** The surface autotel needs from an SDK handle; `NodeSDK` satisfies it too. */
+interface AutotelSdkLike {
+  start(): void;
+  shutdown(): Promise<void>;
+  getTracerProvider?(): BasicTracerProvider | undefined;
+}
+//#endregion
 //#region src/validation.d.ts
 interface ValidationConfig {
   /** Max event name length (default: 100) */
@@ -432,7 +458,7 @@ interface AutotelConfig {
    * })
    * ```
    */
-  instrumentations?: NodeSDKConfiguration['instrumentations'];
+  instrumentations?: AutotelSdkOptions['instrumentations'];
   /**
    * Simple names for auto-instrumentation.
    * Uses @opentelemetry/auto-instrumentations-node (peer dependency).
@@ -756,9 +782,11 @@ interface AutotelConfig {
    */
   protocol?: AutotelProtocol;
   /**
-   * Optional factory to build a customised NodeSDK instance from our defaults.
+   * Optional factory to build a customised SDK from our defaults. The options
+   * use `NodeSDKConfiguration`'s field names, so `new NodeSDK(defaults)` from
+   * `@opentelemetry/sdk-node` is a valid return value.
    */
-  sdkFactory?: (defaults: Partial<NodeSDKConfiguration>) => NodeSDK;
+  sdkFactory?: (defaults: AutotelSdkOptions) => AutotelSdkLike;
   /**
    * Infrastructure metrics configuration
    * - true: always enabled (default)
@@ -794,7 +822,7 @@ interface AutotelConfig {
    */
   logs?: boolean | 'auto';
   /** Sampling strategy - takes precedence over `sampling` preset */
-  sampler?: Sampler;
+  sampler?: Sampler$1;
   /**
    * Sampling preset shorthand — resolves to a pre-configured sampler.
    * If both `sampler` and `sampling` are provided, `sampler` takes precedence.

package/dist/instrumentation.cjs

@@ -1,14 +1,14 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_init = require('./init-BYXDCfRL.cjs');
-const require_node_require = require('./node-require-B_IVapV3.cjs');
-let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
-let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+const require_init = require('./init-21HWbm7_.cjs');
+const require_node_require = require('./node-require-BPsB09eC.cjs');
 let _opentelemetry_resources = require("@opentelemetry/resources");
-let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
+let _opentelemetry_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
 let _opentelemetry_sdk_logs = require("@opentelemetry/sdk-logs");
+let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 let _opentelemetry_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
 let _opentelemetry_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
-let _opentelemetry_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
 let _opentelemetry_semantic_conventions_incubating = require("@opentelemetry/semantic-conventions/incubating");
 
 //#region src/instrumentation.ts
@@ -120,10 +120,11 @@ async function initInstrumentation(config) {
 	});
 	let instrumentations = config.instrumentations || [];
 	if (config.selectiveInstrumentation === false) instrumentations = [require_node_require.requireModule("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations()];
-	const spanProcessor = new require_init.TailSamplingSpanProcessor(new _opentelemetry_sdk_trace_base.BatchSpanProcessor(new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter({
+	const traceExporter = new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter({
 		url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/traces`,
 		headers: otlpHeaders
-	})));
+	});
+	const spanProcessor = new require_init.TailSamplingSpanProcessor(new _opentelemetry_sdk_trace_base.BatchSpanProcessor(traceExporter));
 	const sdk = new _opentelemetry_sdk_node.NodeSDK({
 		resource,
 		spanProcessor,

package/dist/instrumentation.js

@@ -1,13 +1,13 @@
-import { r as getLogger, x as TailSamplingSpanProcessor } from "./init-Dyq6WtsO.js";
+import { r as getLogger, x as TailSamplingSpanProcessor } from "./init-8SISAGdE.js";
 import { n as safeRequire, t as requireModule } from "./node-require-CkK_xzL-.js";
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { detectResources, hostDetector, processDetector, resourceFromAttributes } from "@opentelemetry/resources";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { NodeSDK } from "@opentelemetry/sdk-node";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions/incubating";
 
 //#region src/instrumentation.ts
@@ -119,10 +119,11 @@ async function initInstrumentation(config) {
 	});
 	let instrumentations = config.instrumentations || [];
 	if (config.selectiveInstrumentation === false) instrumentations = [requireModule("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations()];
-	const spanProcessor = new TailSamplingSpanProcessor(new BatchSpanProcessor(new OTLPTraceExporter({
+	const traceExporter = new OTLPTraceExporter({
 		url: `${config.otlpEndpoint || "http://localhost:4318"}/v1/traces`,
 		headers: otlpHeaders
-	})));
+	});
+	const spanProcessor = new TailSamplingSpanProcessor(new BatchSpanProcessor(traceExporter));
 	const sdk = new NodeSDK({
 		resource,
 		spanProcessor,

package/dist/{logger-CSdZkxbh.cjs → logger-DLjHQAus.cjs}

@@ -1,4 +1,4 @@
-const require_values = require('./values-tm4bi0FF.cjs');
+const require_values = require('./values-AxGpgYBA.cjs');
 const require_config = require('./config.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 

package/dist/logger.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_logger = require('./logger-CSdZkxbh.cjs');
+const require_logger = require('./logger-DLjHQAus.cjs');
 
 exports.LOG_LEVEL = require_logger.LOG_LEVEL;
 exports.LoggedOperation = require_logger.LoggedOperation;

package/dist/messaging-adapters.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_values = require('./values-tm4bi0FF.cjs');
+const require_values = require('./values-AxGpgYBA.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/messaging-adapters.ts

package/dist/messaging-testing.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
 //#region src/messaging-testing.ts
 /**
 * Generate a random hex string

package/dist/messaging.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_values = require('./values-tm4bi0FF.cjs');
-const require_init = require('./init-BYXDCfRL.cjs');
-const require_functional = require('./functional-UIJ0CaTV.cjs');
-const require_correlated_events = require('./correlated-events-9RRdfyWR.cjs');
-const require_trace_factory_validation = require('./trace-factory-validation-Dc8epn87.cjs');
+const require_init = require('./init-21HWbm7_.cjs');
+const require_values = require('./values-AxGpgYBA.cjs');
+const require_functional = require('./functional-u5Qwjray.cjs');
+const require_correlated_events = require('./correlated-events-DE_4A3oD.cjs');
+const require_trace_factory_validation = require('./trace-factory-validation-CHU1WcjK.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/messaging.ts
@@ -362,11 +362,12 @@ function extendContextForConsumer(baseCtx, config, linkStorage, orderingState, g
 				context: options.originalDLQSpanContext,
 				attributes: { "messaging.link.source": "dlq_replay" }
 			}]);
-			require_correlated_events.emitCorrelatedEvent(baseCtx, "dlq_replay", {
+			const eventAttrs = {
 				"messaging.replay": true,
 				...options?.replayAttempt !== void 0 && { "messaging.replay.attempt": options.replayAttempt },
 				...options?.dlqDwellTimeMs !== void 0 && { "messaging.replay.dwell_time_ms": options.dlqDwellTimeMs }
-			});
+			};
+			require_correlated_events.emitCorrelatedEvent(baseCtx, "dlq_replay", eventAttrs);
 		},
 		recordRetry(attemptNumber, maxAttempts) {
 			baseCtx.setAttribute("messaging.retry.count", attemptNumber);

package/dist/messaging.js

@@ -1,6 +1,6 @@
+import { F as createLinkFromHeaders, L as extractLinksFromBatch } from "./init-8SISAGdE.js";
 import { _ as readProperty, b as toAttributeValue, c as asScalar, g as nonEmptyString, h as isFunction, s as asRecord, v as resolveValue, y as splitNameOrOptions } from "./values-xBtdXtjA.js";
-import { F as createLinkFromHeaders, L as extractLinksFromBatch } from "./init-Dyq6WtsO.js";
-import { l as withTracing } from "./functional-S9IJNlBn.js";
+import { l as withTracing } from "./functional-CC2BFGAO.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-BfpH5uS-.js";
 import { t as assertTraceFactory } from "./trace-factory-validation-BjVAinz6.js";
 import { SpanKind, context, propagation } from "@opentelemetry/api";
@@ -361,11 +361,12 @@ function extendContextForConsumer(baseCtx, config, linkStorage, orderingState, g
 				context: options.originalDLQSpanContext,
 				attributes: { "messaging.link.source": "dlq_replay" }
 			}]);
-			emitCorrelatedEvent(baseCtx, "dlq_replay", {
+			const eventAttrs = {
 				"messaging.replay": true,
 				...options?.replayAttempt !== void 0 && { "messaging.replay.attempt": options.replayAttempt },
 				...options?.dlqDwellTimeMs !== void 0 && { "messaging.replay.dwell_time_ms": options.dlqDwellTimeMs }
-			});
+			};
+			emitCorrelatedEvent(baseCtx, "dlq_replay", eventAttrs);
 		},
 		recordRetry(attemptNumber, maxAttempts) {
 			baseCtx.setAttribute("messaging.retry.count", attemptNumber);

package/dist/metric-testing.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
 //#region src/metric-testing.ts
 /**
 * Create an in-memory metrics collector for testing

package/dist/{node-require-B_IVapV3.cjs → node-require-BPsB09eC.cjs}

@@ -1,5 +1,5 @@
-const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
-const require_values = require('./values-tm4bi0FF.cjs');
+const require_rolldown_runtime = require('./rolldown-runtime-C24Yb2bl.cjs');
+const require_values = require('./values-AxGpgYBA.cjs');
 let node_module = require("node:module");
 node_module = require_rolldown_runtime.__toESM(node_module, 1);
 

package/dist/parse-error.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_values = require('./values-tm4bi0FF.cjs');
+const require_values = require('./values-AxGpgYBA.cjs');
 
 //#region src/parse-error.ts
 /** An HTTP-ish status, however the library that threw chose to spell it. */

package/dist/{policy-C4QcZnqv.d.ts → policy-DNw_0qUq.d.ts}

@@ -1,6 +1,6 @@
-import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import { Context } from "@opentelemetry/api";
 import { LogRecordProcessor, SdkLogRecord } from "@opentelemetry/sdk-logs";
+import { ReadableSpan } from "@opentelemetry/sdk-trace-base";
 //#region src/policy.d.ts
 /** A path into an attribute. `"ccn"` and `["ccn"]` are equivalent. */
 type AttributePath = string | string[];