autotel 7.7.1 → 7.9.0

package/dist/{init-Dyq6WtsO.js → init-C-qfxo_u.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, createContextKey, 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,
@@ -1945,6 +2097,76 @@ var BaggageSpanProcessor = class {
 	async forceFlush() {}
 };
 
+//#endregion
+//#region src/request-attributes.ts
+/**
+* Attributes set through `requestCtx` describe the whole request, so every
+* span started inside that request carries them too - not only the request
+* span. This stays in-process: nothing rides baggage, so a `user.email` set in
+* auth middleware never leaves in a `baggage` header on an outgoing call.
+*/
+/**
+* The key `@opentelemetry/core` publishes RPC metadata under. `createContextKey`
+* is `Symbol.for`, so this reads exactly what `instrumentation-http` (and every
+* framework instrumentation that renames the route) wrote, without taking a
+* dependency on core.
+*/
+const RPC_METADATA_KEY = createContextKey("OpenTelemetry SDK Context Key RPC_METADATA");
+/** The server span of the request `ctx` belongs to, if it belongs to one. */
+function getRequestSpanIn(ctx = context.active()) {
+	const requestSpan = readProperty(ctx.getValue(RPC_METADATA_KEY), "span");
+	return isFunction(readProperty(requestSpan, "spanContext")) ? requestSpan : void 0;
+}
+const scopes = /* @__PURE__ */ new WeakMap();
+function scopeFor(span) {
+	let scope = scopes.get(span);
+	if (!scope) {
+		scope = { attributes: {} };
+		scopes.set(span, scope);
+	}
+	return scope;
+}
+/**
+* The request span's attributes, or else every ancestor `requestCtx` wrote to,
+* merged so the nearer one wins a key: a job span tagging `job.id` under a
+* consumer that tagged `tenant` must not hide the tenant from its children.
+*/
+function sourceOf(parentContext) {
+	const requestSpan = getRequestSpanIn(parentContext);
+	if (requestSpan) return scopes.get(requestSpan)?.attributes;
+	const nearestFirst = [];
+	const parent = trace.getSpan(parentContext);
+	for (let scope = parent && scopes.get(parent); scope; scope = scope.parent) nearestFirst.push(scope.attributes);
+	return nearestFirst.length > 0 ? Object.assign({}, ...nearestFirst.toReversed()) : void 0;
+}
+/** Remember attributes set through `requestCtx`, for the spans started under it. */
+function rememberRequestAttributes(span, attrs) {
+	Object.assign(scopeFor(span).attributes, attrs);
+}
+/**
+* Copies `requestCtx` attributes onto each span started inside the request -
+* or, outside one, under the span `requestCtx` fell back to. Only what was set
+* before the span started is copied, and a key the span already carries keeps
+* its own value.
+*/
+var RequestAttributesSpanProcessor = class {
+	onStart(span, parentContext) {
+		const parent = trace.getSpan(parentContext);
+		if (parent) scopeFor(span).parent = scopeFor(parent);
+		const attrs = sourceOf(parentContext);
+		if (!attrs) return;
+		const own = span.attributes;
+		for (const [key, value] of Object.entries(attrs)) if (value !== void 0 && !(key in own)) span.setAttribute(key, value);
+	}
+	onEnd() {}
+	forceFlush() {
+		return Promise.resolve();
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+
 //#endregion
 //#region src/redact-values.ts
 /** Standalone string redaction for use outside the span processor pipeline. */
@@ -2990,7 +3212,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 +4275,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;
@@ -4144,6 +4368,7 @@ function init(cfg) {
 		mergedConfig.spanFilter = userSpanFilter ? (span) => userSpanFilter(span) && policySpanFilter(span) : policySpanFilter;
 	}
 	if (mergedConfig.spanFilter && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new FilteringSpanProcessor(processor, { filter: mergedConfig.spanFilter }));
+	if (spanProcessors.length > 0) spanProcessors.unshift(new RequestAttributesSpanProcessor());
 	if (mergedConfig.spanEnrichers && mergedConfig.spanEnrichers.length > 0) spanProcessors.unshift(...mergedConfig.spanEnrichers);
 	const metricReaders = [];
 	if (configuredMetricReaders && configuredMetricReaders.length > 0) metricReaders.push(...configuredMetricReaders);
@@ -4165,10 +4390,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 +4436,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");
@@ -4307,4 +4533,4 @@ function getSdk() {
 }
 
 //#endregion
-export { getCorrelationStorage as $, FeatureFlagSampler as A, markForceKept as B, AUTOTEL_SAMPLING_RATE as C, AlwaysSampler as D, AdaptiveSampler as E, createLinkFromHeaders as F, getActiveContextWithBaggage as G, samplingPresets as H, debugCaptureRequested as I, getEventQueue as J, getContextStorage as K, extractLinksFromBatch as L, NeverSampler as M, RandomSampler as N, CompositeSampler as O, UserIdSampler as P, getCorrelationId as Q, hashUnitInterval as R, AUTOTEL_DEBUG_BAGGAGE_KEY as S, AUTOTEL_SAMPLING_TAIL_KEEP as T, createTraceContext as U, resolveSamplingPreset as V, defineBaggageSchema as W, CORRELATION_ID_BAGGAGE_KEY as X, track as Y, generateCorrelationId as Z, loadYamlConfig as _, init as a, BaggageSpanProcessor as b, lockLogger as c, Event as d, getOrCreateCorrelationId as et, getEvents as f, hasYamlConfig as g, runInOperationContext as h, getSdk as i, KeyTargetRateSampler as j, DeterministicSampler as k, flush as l, getOperationContext as m, getConfiguredSampler as n, setCorrelationId as nt, isInitialized as o, resetEvents as p, hasExplicitSpanStatus as q, getLogger as r, setCorrelationIdInBaggage as rt, isLoggerLocked as s, getConfig as t, runWithCorrelationId as tt, shutdown as u, loadYamlConfigFromFile as v, AUTOTEL_SAMPLING_TAIL_EVALUATED as w, TailSamplingSpanProcessor as x, createStringRedactor as y, isForceKept as z };
+export { generateCorrelationId as $, CompositeSampler as A, hashUnitInterval as B, TailSamplingSpanProcessor as C, AUTOTEL_SAMPLING_TAIL_KEEP as D, AUTOTEL_SAMPLING_TAIL_EVALUATED as E, RandomSampler as F, createTraceContext as G, markForceKept as H, UserIdSampler as I, getContextStorage as J, defineBaggageSchema as K, createLinkFromHeaders as L, FeatureFlagSampler as M, KeyTargetRateSampler as N, AdaptiveSampler as O, NeverSampler as P, CORRELATION_ID_BAGGAGE_KEY as Q, debugCaptureRequested as R, BaggageSpanProcessor as S, AUTOTEL_SAMPLING_RATE as T, resolveSamplingPreset as U, isForceKept as V, samplingPresets as W, getEventQueue as X, hasExplicitSpanStatus as Y, track as Z, loadYamlConfig as _, init as a, setCorrelationIdInBaggage as at, getRequestSpanIn as b, lockLogger as c, Event as d, getCorrelationId as et, getEvents as f, hasYamlConfig as g, runInOperationContext as h, getSdk as i, setCorrelationId as it, DeterministicSampler as j, AlwaysSampler as k, flush as l, getOperationContext as m, getConfiguredSampler as n, getOrCreateCorrelationId as nt, isInitialized as o, resetEvents as p, getActiveContextWithBaggage as q, getLogger as r, runWithCorrelationId as rt, isLoggerLocked as s, getConfig as t, getCorrelationStorage as tt, shutdown as u, loadYamlConfigFromFile as v, AUTOTEL_DEBUG_BAGGAGE_KEY as w, rememberRequestAttributes as x, createStringRedactor as y, extractLinksFromBatch as z };

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.