autotel 6.2.1 → 6.4.0

package/dist/{init-BzVuFs5a.cjs → init-C5V4z7S5.cjs}

@@ -5,6 +5,7 @@ const require_sampling = require('./sampling.cjs');
 const require_node_require = require('./node-require-PFqDihze.cjs');
 const require_tail_sampling_processor = require('./tail-sampling-processor.cjs');
 const require_filtering_span_processor = require('./filtering-span-processor.cjs');
+const require_policy = require('./policy.cjs');
 const require_span_name_normalizer = require('./span-name-normalizer.cjs');
 const require_attribute_redacting_processor = require('./attribute-redacting-processor.cjs');
 const require_pretty_console_exporter = require('./pretty-console-exporter-CMzlrRNg.cjs');
@@ -18,13 +19,13 @@ let _opentelemetry_resources = require("@opentelemetry/resources");
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 let _opentelemetry_api = require("@opentelemetry/api");
 let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
-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_logs = require("@opentelemetry/sdk-logs");
 let node_os = require("node:os");
 let node_async_hooks = require("node:async_hooks");
 node_async_hooks = require_rolldown_runtime.__toESM(node_async_hooks, 1);
+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");
 
 //#region src/posthog-logs.ts
 var RedactingLogRecordProcessor = class {
@@ -327,6 +328,39 @@ function resolveDevtoolsConfig(config) {
 //#endregion
 //#region src/process-handlers.ts
 let removeOwnedHandlers = [];
+/**
+* Tracked separately from `removeOwnedHandlers` because the exit flush outlives
+* a call to `installProcessHandlers`, which clears that list before installing
+* its own signal listeners.
+*/
+let removeExitFlush;
+/**
+* Shared across every path that can end the process: signals, fatal errors and
+* a clean exit. They can overlap — a container stopping a job that has just
+* finished its work sends SIGTERM while the exit flush is still draining — and
+* a second shutdown would tear down queues the first is still using.
+*/
+let shutdownInFlight;
+/**
+* The clean-exit flush, while it runs. Doubles as the latch that keeps a
+* re-emitted `beforeExit` from flushing twice, and as the thing a shutdown
+* waits on rather than tearing down queues mid-drain.
+*/
+let exitFlushInFlight;
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 2e3;
+function runShutdownOnce(shutdown, timeoutMs) {
+	if (shutdownInFlight) return shutdownInFlight;
+	let timeoutHandle;
+	const shutdownAttempt = Promise.resolve(exitFlushInFlight).then(shutdown).catch(() => void 0);
+	const timeout = new Promise((resolve) => {
+		timeoutHandle = setTimeout(resolve, timeoutMs);
+		timeoutHandle.unref();
+	});
+	shutdownInFlight = Promise.race([shutdownAttempt, timeout]).then(() => {
+		if (timeoutHandle) clearTimeout(timeoutHandle);
+	});
+	return shutdownInFlight;
+}
 const DEFAULT_SIGNALS = ["SIGTERM", "SIGINT"];
 function signalExitCode(signal) {
 	return 128 + node_os.constants.signals[signal];
@@ -345,21 +379,7 @@ function reportFatalError(error, event) {
 }
 function installProcessHandlers(config, shutdown) {
 	uninstallProcessHandlers();
-	let shutdownInFlight;
-	const runShutdownOnce = () => {
-		if (shutdownInFlight) return shutdownInFlight;
-		const timeoutMs = config.shutdownTimeoutMs ?? 2e3;
-		let timeoutHandle;
-		const shutdownAttempt = Promise.resolve().then(shutdown).catch(() => void 0);
-		const timeout = new Promise((resolve) => {
-			timeoutHandle = setTimeout(resolve, timeoutMs);
-			timeoutHandle.unref();
-		});
-		shutdownInFlight = Promise.race([shutdownAttempt, timeout]).then(() => {
-			if (timeoutHandle) clearTimeout(timeoutHandle);
-		});
-		return shutdownInFlight;
-	};
+	const timeoutMs = config.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
 	let exitScheduled = false;
 	let resolvedExitCode = 0;
 	let fatalLatched = false;
@@ -372,7 +392,7 @@ function installProcessHandlers(config, shutdown) {
 		} else if (!exitScheduled && !fatalLatched) resolvedExitCode = exitCode;
 		if (exitScheduled) return;
 		exitScheduled = true;
-		runShutdownOnce().then(() => {
+		runShutdownOnce(shutdown, timeoutMs).then(() => {
 			process.exit(resolvedExitCode);
 		});
 	};
@@ -403,9 +423,43 @@ function installProcessHandlers(config, shutdown) {
 		});
 	}
 }
+/**
+* Flush telemetry when the process runs to completion.
+*
+* The signal and fatal-error handlers above cover a process that is stopped or
+* that crashes. Neither fires when a script simply finishes: the event loop
+* drains and Node exits, taking whatever the batch span processor was still
+* holding with it. `beforeExit` is the only hook for that case, and it is the
+* one that matters for CLIs, cron jobs, CI steps and serverless handlers.
+*
+* A flush, never a shutdown: `beforeExit` fires on *any* event-loop drain, not
+* only the final one, so tearing the SDK down here would silently kill
+* telemetry in a process that goes on to do more work.
+*/
+function installExitFlush(flushTelemetry, timeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS) {
+	removeExitFlush?.();
+	exitFlushInFlight = void 0;
+	const listener = (code) => {
+		if (exitFlushInFlight || shutdownInFlight) return;
+		const deadline = setTimeout(() => {
+			process.exit(process.exitCode ?? code);
+		}, timeoutMs);
+		exitFlushInFlight = flushTelemetry().catch(() => void 0).finally(() => {
+			clearTimeout(deadline);
+		});
+	};
+	process.on("beforeExit", listener);
+	removeExitFlush = () => {
+		process.removeListener("beforeExit", listener);
+		removeExitFlush = void 0;
+	};
+}
 function uninstallProcessHandlers() {
 	for (const removeHandler of removeOwnedHandlers) removeHandler();
 	removeOwnedHandlers = [];
+	removeExitFlush?.();
+	shutdownInFlight = void 0;
+	exitFlushInFlight = void 0;
 }
 
 //#endregion
@@ -493,11 +547,15 @@ function getContextStorage() {
 	return contextStorage;
 }
 /**
-* Get the active context, checking our stored context first
-* This ensures baggage setters work with OpenTelemetry's propagation
+* Get the active OTel context with the latest stored baggage overlaid.
+* Span identity always comes from the active OTel scope.
 */
 function getActiveContextWithBaggage() {
-	return contextStorage.getStore()?.value ?? _opentelemetry_api.context.active();
+	const activeContext = _opentelemetry_api.context.active();
+	const stored = contextStorage.getStore()?.value;
+	if (!stored) return activeContext;
+	const storedBaggage = _opentelemetry_api.propagation.getBaggage(stored);
+	return storedBaggage ? _opentelemetry_api.propagation.setBaggage(activeContext, storedBaggage) : activeContext;
 }
 /**
 * Set a value in AsyncLocalStorage, preferring enterWith() when available
@@ -577,15 +635,13 @@ function createTraceContext(span) {
 			return baggage?.getEntry(key)?.value;
 		},
 		setBaggage(key, value) {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const updated = (_opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage()).setEntry(key, { value });
 			updateActiveContext(_opentelemetry_api.propagation.setBaggage(currentContext, updated));
 			return value;
 		},
 		deleteBaggage(key) {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const baggage = _opentelemetry_api.propagation.getBaggage(currentContext);
 			if (baggage) {
 				const updated = baggage.removeEntry(key);
@@ -621,8 +677,7 @@ function createTraceContext(span) {
 			return Object.keys(result).length > 0 ? result : void 0;
 		}),
 		setTypedBaggage: ((namespace, value) => {
-			const activeCtx = _opentelemetry_api.context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			let baggage = _opentelemetry_api.propagation.getBaggage(currentContext) ?? _opentelemetry_api.propagation.createBaggage();
 			const prefix = namespace ? `${namespace}.` : "";
 			for (const [key, val] of Object.entries(value)) if (val !== void 0) {
@@ -913,6 +968,11 @@ function getSubscriberName(subscriber) {
 	return (subscriber.constructor?.name || "unknown").replace(/Subscriber$/i, "").toLowerCase();
 }
 /**
+* Subscribers whose `shutdown()` has run. Terminal for the client they wrap, so
+* a queue rebuilt from the same config must not reuse them.
+*/
+const shutDownSubscribers = /* @__PURE__ */ new WeakSet();
+/**
 * Events queue with batching and backpressure
 *
 * Features:
@@ -934,13 +994,15 @@ var EventQueue = class {
 	observableCleanups = [];
 	subscriberHealthy = /* @__PURE__ */ new Map();
 	constructor(subscribers, config) {
-		this.subscribers = subscribers;
+		const live = subscribers.filter((s) => !shutDownSubscribers.has(s));
+		if (live.length < subscribers.length) getLogger().warn({ subscribers: subscribers.filter((s) => shutDownSubscribers.has(s)).map((s) => getSubscriberName(s)) }, "[autotel] Subscriber already shut down, events will not be delivered; pass new subscriber instances to init()");
+		this.subscribers = live;
 		this.config = {
 			...DEFAULT_CONFIG$2,
 			...config
 		};
 		this.rateLimiter = this.config.rateLimit ? new TokenBucketRateLimiter(this.config.rateLimit) : null;
-		for (const subscriber of subscribers) {
+		for (const subscriber of this.subscribers) {
 			const name = getSubscriberName(subscriber);
 			this.subscriberHealthy.set(name, true);
 		}
@@ -1234,6 +1296,20 @@ var EventQueue = class {
 	async shutdown() {
 		this.isShuttingDown = true;
 		await this.flush();
+		const drains = await Promise.allSettled(this.subscribers.map(async (subscriber) => {
+			if (!subscriber.shutdown) return;
+			shutDownSubscribers.add(subscriber);
+			return subscriber.shutdown();
+		}));
+		for (const [index, drain] of drains.entries()) {
+			if (drain.status !== "rejected") continue;
+			const subscriberName = getSubscriberName(this.subscribers[index]);
+			this.subscriberHealthy.set(subscriberName, false);
+			getLogger().error({
+				subscriber: subscriberName,
+				err: drain.reason
+			}, "[autotel] Subscriber shutdown failed, buffered events may be lost");
+		}
 	}
 	/**
 	* Cleanup observable metric callbacks to prevent memory leaks
@@ -2463,47 +2539,7 @@ async function shutdown() {
 }
 
 //#endregion
-//#region src/init.ts
-/**
-* Simplified initialization for autotel
-*
-* Single init() function with sensible defaults.
-* Replaces initInstrumentation() and separate events config.
-*/
-/**
-* Silent logger (no-op) - used as default when user doesn't provide one.
-* Internal autotel logs are silent by default to avoid spam.
-* Users can import { autotelLogger } from 'autotel/logger' to create their own.
-*/
-const silentLogger = {
-	info: () => {},
-	warn: () => {},
-	error: () => {},
-	debug: () => {}
-};
-/**
-* Adapts an Autotel Sampler to the OTel SDK Sampler interface.
-*/
-function toOtelSampler(sampler) {
-	return {
-		shouldSample(_context, _traceId, spanName, _spanKind, _attributes, links) {
-			const samplingContext = {
-				operationName: spanName,
-				args: [],
-				links
-			};
-			const shouldTrace = sampler.shouldSample(samplingContext);
-			const rate = sampler.sampleRate?.(samplingContext);
-			return {
-				decision: shouldTrace ? _opentelemetry_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED : _opentelemetry_sdk_trace_base.SamplingDecision.NOT_RECORD,
-				...shouldTrace && rate !== void 0 && rate > 1 ? { attributes: { [require_sampling.AUTOTEL_SAMPLING_RATE]: rate } } : {}
-			};
-		},
-		toString() {
-			return `AutotelSamplerAdapter`;
-		}
-	};
-}
+//#region src/otlp-exporters.ts
 let OTLPTraceExporterPROTO;
 let OTLPMetricExporterPROTO;
 let OTLPLogExporterPROTO;
@@ -2617,62 +2653,9 @@ function formatEndpointUrl(endpoint, signal, protocol) {
 	if (!endpoint.endsWith(`/v1/${signal}`)) return `${endpoint}/v1/${signal}`;
 	return endpoint;
 }
-let initialized = false;
-let locked = false;
-let config = null;
-let sdk = null;
-let warnedOnce = false;
-let logger = silentLogger;
-let validationConfig = null;
-let eventsConfig = null;
-let _stringRedactor = null;
-function acceptsStringRedactor(subscriber) {
-	return typeof subscriber === "object" && subscriber !== null && "setStringRedactor" in subscriber && typeof subscriber.setStringRedactor === "function";
-}
-let _optionalRequire = require_node_require.safeRequire;
-let _devtoolsClose = null;
-const LOG_LEVELS = {
-	debug: 0,
-	info: 1,
-	warn: 2,
-	error: 3
-};
-/**
-* Lock the logger to prevent further `init()` calls.
-* Use this when framework plugins set up instrumentation and you want
-* to prevent accidental re-initialization from user code.
-*/
-function lockLogger() {
-	locked = true;
-}
-/**
-* Check if the logger has been locked.
-*/
-function isLoggerLocked() {
-	return locked;
-}
-function createSilentLogger() {
-	return {
-		info: () => {},
-		warn: () => {},
-		error: () => {},
-		debug: () => {}
-	};
-}
-function wrapLogger(base, silent, minLevel) {
-	if (silent) return createSilentLogger();
-	const threshold = LOG_LEVELS[minLevel];
-	const wrap = (fn, level) => {
-		if (LOG_LEVELS[level] < threshold) return (() => {});
-		return ((...args) => fn(...args));
-	};
-	return {
-		debug: wrap(base.debug, "debug"),
-		info: wrap(base.info, "info"),
-		warn: wrap(base.warn, "warn"),
-		error: wrap(base.error, "error")
-	};
-}
+
+//#endregion
+//#region src/config-resolution.ts
 /**
 * Resolve the effective attribute redactor. Explicit config wins (`false`
 * disables). Otherwise the `AUTOTEL_REDACT_PII` env var controls it, and as a
@@ -2787,102 +2770,343 @@ function destinationSupportsSignal(destination, signal) {
 	return destination.signals ? destination.signals.has(signal) : true;
 }
 /**
-* Initialize autotel - Write Once, Observe Everywhere
-*
-* Follows OpenTelemetry standards: opinionated defaults with full flexibility
-* Idempotent: multiple calls are safe, last one wins
-*
-* @example Minimal setup (OTLP default)
-* ```typescript
-* init({ service: 'my-app' })
-* ```
-*
-* @example With events (observe in PostHog, Mixpanel, etc.)
-* ```typescript
-* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
-*
-* init({
-*   service: 'my-app',
-*   subscribers: [new PostHogSubscriber({ apiKey: '...' })]
-* })
-* ```
-*
-* @example Observe in Jaeger
-* ```typescript
-* import { JaegerExporter } from '@opentelemetry/exporter-jaeger'
-*
-* init({
-*   service: 'my-app',
-*   spanExporter: new JaegerExporter({ endpoint: 'http://localhost:14268/api/traces' })
-* })
-* ```
-*
-* @example Observe in Zipkin
-* ```typescript
-* import { ZipkinExporter } from '@opentelemetry/exporter-zipkin'
-*
-* init({
-*   service: 'my-app',
-*   spanExporter: new ZipkinExporter({ url: 'http://localhost:9411/api/v2/spans' })
-* })
-* ```
-*
-* @example Observe in Datadog
-* ```typescript
-* import { DatadogSpanProcessor } from '@opentelemetry/exporter-datadog'
-*
-* init({
-*   service: 'my-app',
-*   spanProcessor: new DatadogSpanProcessor({ ... })
-* })
-* ```
+* Auto-detect version from package.json
+*/
+function detectVersion() {
+	try {
+		const fs = require_node_require.requireModule("node:fs");
+		return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).version || "1.0.0";
+	} catch {
+		return "1.0.0";
+	}
+}
+/**
+* Detect hostname for resource attributes.
+* Supports Datadog conventions (DD_HOSTNAME) and falls back to system hostname.
 *
-* @example Console output (dev)
-* ```typescript
-* import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
+* Priority order:
+* 1. DD_HOSTNAME environment variable (Datadog convention)
+* 2. HOSTNAME environment variable (common Unix convention)
+* 3. os.hostname() (system hostname)
 *
-* init({
-*   service: 'my-app',
-*   spanProcessor: new SimpleSpanProcessor(new ConsoleSpanExporter())
-* })
-* ```
+* @returns hostname string or undefined if detection fails
 */
-function init(cfg) {
-	if (locked) return;
-	const envConfig = resolveConfigFromEnv();
-	const yamlConfig = require_yaml_config.loadYamlConfig() ?? {};
-	const mergedConfig = {
-		...envConfig,
-		...yamlConfig,
-		...cfg,
-		resourceAttributes: {
-			...envConfig.resourceAttributes,
-			...yamlConfig.resourceAttributes,
-			...detectEnvironmentAttributes(),
-			...cfg.resourceAttributes
-		},
-		headers: cfg.headers ?? yamlConfig.headers ?? envConfig.headers
-	};
-	const resolvedRedactor = resolveAttributeRedactor(mergedConfig.attributeRedactor, mergedConfig.environment || process.env.NODE_ENV || "development");
-	if (resolvedRedactor === void 0) mergedConfig.attributeRedactor = void 0;
-	else {
-		const normalizedRedactor = require_attribute_redacting_processor.normalizeAttributeRedactorConfig(resolvedRedactor);
-		if (!normalizedRedactor) throw new Error("Invalid attributeRedactor config");
-		mergedConfig.attributeRedactor = normalizedRedactor;
+function detectHostname() {
+	if (process.env.DD_HOSTNAME) return process.env.DD_HOSTNAME;
+	if (process.env.HOSTNAME) return process.env.HOSTNAME;
+	try {
+		return require_node_require.requireModule("node:os").hostname();
+	} catch {
+		return;
 	}
-	const devtoolsConfig = resolveDevtoolsConfig(mergedConfig.devtools);
-	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);
-	if (initialized) logger.warn({}, "[autotel] init() called again - last config wins. This may cause unexpected behavior.");
-	config = mergedConfig;
-	validationConfig = mergedConfig.validation || null;
-	eventsConfig = mergedConfig.events || null;
-	let endpoint = mergedConfig.endpoint ?? devtoolsConfig.endpoint;
-	const version = mergedConfig.version || detectVersion();
-	const environment = mergedConfig.environment || process.env.NODE_ENV || "development";
-	const metricsEnabled = resolveMetricsFlag(mergedConfig.metrics);
+}
+
+//#endregion
+//#region src/auto-instrumentations.ts
+/**
+* Extract instrumentation class names from instrumentation instances
+* Used to detect duplicates between manual and auto instrumentations
+*/
+function getInstrumentationNames(instrumentations) {
+	const names = /* @__PURE__ */ new Set();
+	if (!instrumentations) return names;
+	for (const instrumentation of instrumentations) if (instrumentation && typeof instrumentation === "object") names.add(instrumentation.constructor.name);
+	return names;
+}
+/**
+* Map common instrumentation class names to their package names
+* Used to disable auto-instrumentations when user provides manual configs
+*/
+const INSTRUMENTATION_CLASS_TO_PACKAGE = {
+	HttpInstrumentation: "@opentelemetry/instrumentation-http",
+	HttpsInstrumentation: "@opentelemetry/instrumentation-http",
+	ExpressInstrumentation: "@opentelemetry/instrumentation-express",
+	FastifyInstrumentation: "@opentelemetry/instrumentation-fastify",
+	MongoDBInstrumentation: "@opentelemetry/instrumentation-mongodb",
+	MongooseInstrumentation: "@opentelemetry/instrumentation-mongoose",
+	PrismaInstrumentation: "@opentelemetry/instrumentation-prisma",
+	PinoInstrumentation: "@opentelemetry/instrumentation-pino",
+	WinstonInstrumentation: "@opentelemetry/instrumentation-winston",
+	RedisInstrumentation: "@opentelemetry/instrumentation-redis",
+	GraphQLInstrumentation: "@opentelemetry/instrumentation-graphql",
+	GrpcInstrumentation: "@opentelemetry/instrumentation-grpc",
+	IORedisInstrumentation: "@opentelemetry/instrumentation-ioredis",
+	KnexInstrumentation: "@opentelemetry/instrumentation-knex",
+	NestJsInstrumentation: "@opentelemetry/instrumentation-nestjs-core",
+	PgInstrumentation: "@opentelemetry/instrumentation-pg",
+	MySQLInstrumentation: "@opentelemetry/instrumentation-mysql",
+	MySQL2Instrumentation: "@opentelemetry/instrumentation-mysql2"
+};
+/**
+* Detect if we're running in ESM mode
+*/
+function isESMMode() {
+	try {
+		const fs = require_node_require.requireModule("node:fs");
+		try {
+			return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).type === "module";
+		} catch {
+			return false;
+		}
+	} catch {
+		return false;
+	}
+}
+/**
+* Lazy-load auto-instrumentations (optional peer dependency)
+* Only loads when integrations config is truthy, avoiding ~40+ package imports at startup.
+*/
+function loadNodeAutoInstrumentations() {
+	try {
+		return require_node_require.requireModule("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations;
+	} catch {
+		const isESM = isESMMode();
+		const baseMessage = "@opentelemetry/auto-instrumentations-node not found.";
+		if (isESM) throw new Error(`${baseMessage}\n\nESM Setup Required:
+1. Install as a direct dependency: pnpm add @opentelemetry/auto-instrumentations-node
+2. Create instrumentation.mjs with:
+   import 'autotel/register';  // MUST be first!
+   import { init } from 'autotel';
+   import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+   init({ service: "my-app", instrumentations: getNodeAutoInstrumentations() });
+3. Run with: tsx --import ./instrumentation.mjs src/index.ts
+
+See: https://github.com/jagreehal/autotel#esm-setup`);
+		throw new Error(`${baseMessage} Install it: pnpm add @opentelemetry/auto-instrumentations-node`);
+	}
+}
+/**
+* Injectable loader for testing. Set to override the default loader.
+* @internal
+*/
+let _autoInstrumentationsLoader = null;
+/**
+* Get auto-instrumentations based on simple integration names
+* Excludes instrumentations that are manually provided to avoid conflicts
+*/
+function getAutoInstrumentations(integrations, manualInstrumentationNames = /* @__PURE__ */ new Set()) {
+	if (integrations === false) return [];
+	const getNodeAutoInstrumentations = _autoInstrumentationsLoader ? _autoInstrumentationsLoader() : loadNodeAutoInstrumentations();
+	const exclusionConfig = {};
+	for (const className of manualInstrumentationNames) {
+		const packageName = INSTRUMENTATION_CLASS_TO_PACKAGE[className];
+		if (packageName) exclusionConfig[packageName] = { enabled: false };
+	}
+	if (integrations === true) {
+		if (Object.keys(exclusionConfig).length > 0) return getNodeAutoInstrumentations(exclusionConfig);
+		return getNodeAutoInstrumentations();
+	}
+	if (Array.isArray(integrations)) {
+		const config = { ...exclusionConfig };
+		for (const name of integrations) {
+			const packageName = `@opentelemetry/instrumentation-${name}`;
+			if (!exclusionConfig[packageName]) config[packageName] = { enabled: true };
+		}
+		return getNodeAutoInstrumentations(config);
+	}
+	const config = {
+		...exclusionConfig,
+		...integrations
+	};
+	for (const packageName of Object.keys(exclusionConfig)) if (Object.keys(integrations).find((key) => packageName.includes(key))) config[packageName] = { enabled: false };
+	return getNodeAutoInstrumentations(config);
+}
+
+//#endregion
+//#region src/init.ts
+/**
+* Simplified initialization for autotel
+*
+* Single init() function with sensible defaults.
+* Replaces initInstrumentation() and separate events config.
+*/
+/**
+* Silent logger (no-op) - used as default when user doesn't provide one.
+* Internal autotel logs are silent by default to avoid spam.
+* Users can import { autotelLogger } from 'autotel/logger' to create their own.
+*/
+const silentLogger = {
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {}
+};
+/**
+* Adapts an Autotel Sampler to the OTel SDK Sampler interface.
+*/
+function toOtelSampler(sampler) {
+	return {
+		shouldSample(_context, _traceId, spanName, _spanKind, _attributes, links) {
+			const samplingContext = {
+				operationName: spanName,
+				args: [],
+				links
+			};
+			const shouldTrace = sampler.shouldSample(samplingContext);
+			const rate = sampler.sampleRate?.(samplingContext);
+			return {
+				decision: shouldTrace ? _opentelemetry_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED : _opentelemetry_sdk_trace_base.SamplingDecision.NOT_RECORD,
+				...shouldTrace && rate !== void 0 && rate > 1 ? { attributes: { [require_sampling.AUTOTEL_SAMPLING_RATE]: rate } } : {}
+			};
+		},
+		toString() {
+			return `AutotelSamplerAdapter`;
+		}
+	};
+}
+let initialized = false;
+let locked = false;
+let config = null;
+let sdk = null;
+let warnedOnce = false;
+let logger = silentLogger;
+let validationConfig = null;
+let eventsConfig = null;
+let _stringRedactor = null;
+function acceptsStringRedactor(subscriber) {
+	return typeof subscriber === "object" && subscriber !== null && "setStringRedactor" in subscriber && typeof subscriber.setStringRedactor === "function";
+}
+let _optionalRequire = require_node_require.safeRequire;
+let _devtoolsClose = null;
+const LOG_LEVELS = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Lock the logger to prevent further `init()` calls.
+* Use this when framework plugins set up instrumentation and you want
+* to prevent accidental re-initialization from user code.
+*/
+function lockLogger() {
+	locked = true;
+}
+/**
+* Check if the logger has been locked.
+*/
+function isLoggerLocked() {
+	return locked;
+}
+function createSilentLogger() {
+	return {
+		info: () => {},
+		warn: () => {},
+		error: () => {},
+		debug: () => {}
+	};
+}
+function wrapLogger(base, silent, minLevel) {
+	if (silent) return createSilentLogger();
+	const threshold = LOG_LEVELS[minLevel];
+	const wrap = (fn, level) => {
+		if (LOG_LEVELS[level] < threshold) return (() => {});
+		return ((...args) => fn(...args));
+	};
+	return {
+		debug: wrap(base.debug, "debug"),
+		info: wrap(base.info, "info"),
+		warn: wrap(base.warn, "warn"),
+		error: wrap(base.error, "error")
+	};
+}
+/**
+* Initialize autotel - Write Once, Observe Everywhere
+*
+* Follows OpenTelemetry standards: opinionated defaults with full flexibility
+* Idempotent: multiple calls are safe, last one wins
+*
+* @example Minimal setup (OTLP default)
+* ```typescript
+* init({ service: 'my-app' })
+* ```
+*
+* @example With events (observe in PostHog, Mixpanel, etc.)
+* ```typescript
+* import { PostHogSubscriber } from 'autotel-subscribers/posthog';
+*
+* init({
+*   service: 'my-app',
+*   subscribers: [new PostHogSubscriber({ apiKey: '...' })]
+* })
+* ```
+*
+* @example Observe in Jaeger
+* ```typescript
+* import { JaegerExporter } from '@opentelemetry/exporter-jaeger'
+*
+* init({
+*   service: 'my-app',
+*   spanExporter: new JaegerExporter({ endpoint: 'http://localhost:14268/api/traces' })
+* })
+* ```
+*
+* @example Observe in Zipkin
+* ```typescript
+* import { ZipkinExporter } from '@opentelemetry/exporter-zipkin'
+*
+* init({
+*   service: 'my-app',
+*   spanExporter: new ZipkinExporter({ url: 'http://localhost:9411/api/v2/spans' })
+* })
+* ```
+*
+* @example Observe in Datadog
+* ```typescript
+* import { DatadogSpanProcessor } from '@opentelemetry/exporter-datadog'
+*
+* init({
+*   service: 'my-app',
+*   spanProcessor: new DatadogSpanProcessor({ ... })
+* })
+* ```
+*
+* @example Console output (dev)
+* ```typescript
+* import { ConsoleSpanExporter, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base'
+*
+* init({
+*   service: 'my-app',
+*   spanProcessor: new SimpleSpanProcessor(new ConsoleSpanExporter())
+* })
+* ```
+*/
+function init(cfg) {
+	if (locked) return;
+	const envConfig = resolveConfigFromEnv();
+	const yamlConfig = require_yaml_config.loadYamlConfig() ?? {};
+	const mergedConfig = {
+		...envConfig,
+		...yamlConfig,
+		...cfg,
+		resourceAttributes: {
+			...envConfig.resourceAttributes,
+			...yamlConfig.resourceAttributes,
+			...detectEnvironmentAttributes(),
+			...cfg.resourceAttributes
+		},
+		headers: cfg.headers ?? yamlConfig.headers ?? envConfig.headers
+	};
+	const resolvedRedactor = resolveAttributeRedactor(mergedConfig.attributeRedactor, mergedConfig.environment || process.env.NODE_ENV || "development");
+	if (resolvedRedactor === void 0) mergedConfig.attributeRedactor = void 0;
+	else {
+		const normalizedRedactor = require_attribute_redacting_processor.normalizeAttributeRedactorConfig(resolvedRedactor);
+		if (!normalizedRedactor) throw new Error("Invalid attributeRedactor config");
+		mergedConfig.attributeRedactor = normalizedRedactor;
+	}
+	const devtoolsConfig = resolveDevtoolsConfig(mergedConfig.devtools);
+	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);
+	if (initialized) logger.warn({}, "[autotel] init() called again - last config wins. This may cause unexpected behavior.");
+	config = mergedConfig;
+	validationConfig = mergedConfig.validation || null;
+	eventsConfig = mergedConfig.events || null;
+	let endpoint = mergedConfig.endpoint ?? devtoolsConfig.endpoint;
+	const version = mergedConfig.version || detectVersion();
+	const environment = mergedConfig.environment || process.env.NODE_ENV || "development";
+	const metricsEnabled = resolveMetricsFlag(mergedConfig.metrics);
 	const logsEnabled = resolveLogsFlag(mergedConfig.logs);
 	if (devtoolsConfig.enabled && devtoolsConfig.embedded) {
 		const devtoolsModule = _optionalRequire("autotel-devtools");
@@ -2957,6 +3181,12 @@ function init(cfg) {
 		for (const subscriber of mergedConfig.subscribers) if (acceptsStringRedactor(subscriber)) subscriber.setStringRedactor(_stringRedactor);
 	}
 	if (mergedConfig.spanNameNormalizer && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new require_span_name_normalizer.SpanNameNormalizingProcessor(processor, { normalizer: mergedConfig.spanNameNormalizer }));
+	if (mergedConfig.policies) {
+		if (typeof mergedConfig.policies === "string") require_policy.watchPolicyFile(mergedConfig.policies);
+		else require_policy.setPolicies(mergedConfig.policies);
+		const userSpanFilter = mergedConfig.spanFilter;
+		mergedConfig.spanFilter = userSpanFilter ? (span) => userSpanFilter(span) && require_policy.policySpanFilter(span) : require_policy.policySpanFilter;
+	}
 	if (mergedConfig.spanFilter && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new require_filtering_span_processor.FilteringSpanProcessor(processor, { filter: mergedConfig.spanFilter }));
 	const metricReaders = [];
 	if (configuredMetricReaders && configuredMetricReaders.length > 0) metricReaders.push(...configuredMetricReaders);
@@ -2995,6 +3225,7 @@ function init(cfg) {
 		logRecordProcessors.push(...posthogProcessors);
 		logger.info({}, "[autotel] PostHog OTLP logs configured");
 	}
+	if (mergedConfig.policies && logRecordProcessors) logRecordProcessors = logRecordProcessors.map((processor) => new require_policy.PolicyLogRecordProcessor(processor));
 	let finalInstrumentations = mergedConfig.instrumentations ? [...mergedConfig.instrumentations] : [];
 	if (mergedConfig.autoInstrumentations !== void 0 && mergedConfig.autoInstrumentations !== false) {
 		if (isESMMode()) logger.info({}, "[autotel] ESM mode detected. For auto-instrumentation to work:\n  1. Install @opentelemetry/auto-instrumentations-node as a direct dependency\n  2. Import autotel/register FIRST in your instrumentation file\n  3. Use getNodeAutoInstrumentations() directly instead of autoInstrumentations\n  See: https://github.com/jagreehal/autotel#esm-setup");
@@ -3041,118 +3272,18 @@ function init(cfg) {
 	}
 	initialized = true;
 	const processHandlers = mergedConfig.processHandlers;
-	if (processHandlers) installProcessHandlers(processHandlers === true ? {} : processHandlers, shutdown);
+	const handlersConfig = processHandlers && processHandlers !== true ? processHandlers : {};
+	if (processHandlers) installProcessHandlers(handlersConfig, shutdown);
 	else uninstallProcessHandlers();
-}
-/**
-* Extract instrumentation class names from instrumentation instances
-* Used to detect duplicates between manual and auto instrumentations
-*/
-function getInstrumentationNames(instrumentations) {
-	const names = /* @__PURE__ */ new Set();
-	if (!instrumentations) return names;
-	for (const instrumentation of instrumentations) if (instrumentation && typeof instrumentation === "object") names.add(instrumentation.constructor.name);
-	return names;
-}
-/**
-* Map common instrumentation class names to their package names
-* Used to disable auto-instrumentations when user provides manual configs
-*/
-const INSTRUMENTATION_CLASS_TO_PACKAGE = {
-	HttpInstrumentation: "@opentelemetry/instrumentation-http",
-	HttpsInstrumentation: "@opentelemetry/instrumentation-http",
-	ExpressInstrumentation: "@opentelemetry/instrumentation-express",
-	FastifyInstrumentation: "@opentelemetry/instrumentation-fastify",
-	MongoDBInstrumentation: "@opentelemetry/instrumentation-mongodb",
-	MongooseInstrumentation: "@opentelemetry/instrumentation-mongoose",
-	PrismaInstrumentation: "@opentelemetry/instrumentation-prisma",
-	PinoInstrumentation: "@opentelemetry/instrumentation-pino",
-	WinstonInstrumentation: "@opentelemetry/instrumentation-winston",
-	RedisInstrumentation: "@opentelemetry/instrumentation-redis",
-	GraphQLInstrumentation: "@opentelemetry/instrumentation-graphql",
-	GrpcInstrumentation: "@opentelemetry/instrumentation-grpc",
-	IORedisInstrumentation: "@opentelemetry/instrumentation-ioredis",
-	KnexInstrumentation: "@opentelemetry/instrumentation-knex",
-	NestJsInstrumentation: "@opentelemetry/instrumentation-nestjs-core",
-	PgInstrumentation: "@opentelemetry/instrumentation-pg",
-	MySQLInstrumentation: "@opentelemetry/instrumentation-mysql",
-	MySQL2Instrumentation: "@opentelemetry/instrumentation-mysql2"
-};
-/**
-* Detect if we're running in ESM mode
-*/
-function isESMMode() {
-	try {
-		const fs = require_node_require.requireModule("node:fs");
-		try {
-			return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).type === "module";
-		} catch {
-			return false;
-		}
-	} catch {
-		return false;
-	}
-}
-/**
-* Lazy-load auto-instrumentations (optional peer dependency)
-* Only loads when integrations config is truthy, avoiding ~40+ package imports at startup.
-*/
-function loadNodeAutoInstrumentations() {
-	try {
-		return require_node_require.requireModule("@opentelemetry/auto-instrumentations-node").getNodeAutoInstrumentations;
-	} catch {
-		const isESM = isESMMode();
-		const baseMessage = "@opentelemetry/auto-instrumentations-node not found.";
-		if (isESM) throw new Error(`${baseMessage}\n\nESM Setup Required:
-1. Install as a direct dependency: pnpm add @opentelemetry/auto-instrumentations-node
-2. Create instrumentation.mjs with:
-   import 'autotel/register';  // MUST be first!
-   import { init } from 'autotel';
-   import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-   init({ service: "my-app", instrumentations: getNodeAutoInstrumentations() });
-3. Run with: tsx --import ./instrumentation.mjs src/index.ts
-
-See: https://github.com/jagreehal/autotel#esm-setup`);
-		throw new Error(`${baseMessage} Install it: pnpm add @opentelemetry/auto-instrumentations-node`);
+	if (mergedConfig.flushOnExit !== false) {
+		const timeoutMs = handlersConfig.shutdownTimeoutMs;
+		installExitFlush(() => flush({
+			forShutdown: true,
+			timeout: timeoutMs
+		}), timeoutMs);
 	}
 }
 /**
-* Injectable loader for testing. Set to override the default loader.
-* @internal
-*/
-let _autoInstrumentationsLoader = null;
-/**
-* Get auto-instrumentations based on simple integration names
-* Excludes instrumentations that are manually provided to avoid conflicts
-*/
-function getAutoInstrumentations(integrations, manualInstrumentationNames = /* @__PURE__ */ new Set()) {
-	if (integrations === false) return [];
-	const getNodeAutoInstrumentations = _autoInstrumentationsLoader ? _autoInstrumentationsLoader() : loadNodeAutoInstrumentations();
-	const exclusionConfig = {};
-	for (const className of manualInstrumentationNames) {
-		const packageName = INSTRUMENTATION_CLASS_TO_PACKAGE[className];
-		if (packageName) exclusionConfig[packageName] = { enabled: false };
-	}
-	if (integrations === true) {
-		if (Object.keys(exclusionConfig).length > 0) return getNodeAutoInstrumentations(exclusionConfig);
-		return getNodeAutoInstrumentations();
-	}
-	if (Array.isArray(integrations)) {
-		const config = { ...exclusionConfig };
-		for (const name of integrations) {
-			const packageName = `@opentelemetry/instrumentation-${name}`;
-			if (!exclusionConfig[packageName]) config[packageName] = { enabled: true };
-		}
-		return getNodeAutoInstrumentations(config);
-	}
-	const config = {
-		...exclusionConfig,
-		...integrations
-	};
-	for (const packageName of Object.keys(exclusionConfig)) if (Object.keys(integrations).find((key) => packageName.includes(key))) config[packageName] = { enabled: false };
-	return getNodeAutoInstrumentations(config);
-}
-/**
 * Check if autotel has been initialized
 */
 function isInitialized() {
@@ -3192,37 +3323,6 @@ function warnIfNotInitialized(context) {
 	}
 }
 /**
-* Auto-detect version from package.json
-*/
-function detectVersion() {
-	try {
-		const fs = require_node_require.requireModule("node:fs");
-		return JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`, "utf8")).version || "1.0.0";
-	} catch {
-		return "1.0.0";
-	}
-}
-/**
-* Detect hostname for resource attributes.
-* Supports Datadog conventions (DD_HOSTNAME) and falls back to system hostname.
-*
-* Priority order:
-* 1. DD_HOSTNAME environment variable (Datadog convention)
-* 2. HOSTNAME environment variable (common Unix convention)
-* 3. os.hostname() (system hostname)
-*
-* @returns hostname string or undefined if detection fails
-*/
-function detectHostname() {
-	if (process.env.DD_HOSTNAME) return process.env.DD_HOSTNAME;
-	if (process.env.HOSTNAME) return process.env.HOSTNAME;
-	try {
-		return require_node_require.requireModule("node:os").hostname();
-	} catch {
-		return;
-	}
-}
-/**
 * @internal Close embedded devtools if running.
 */
 async function _closeEmbeddedDevtools() {