autotel 3.5.0 → 3.7.0

package/dist/init-DvapOXCc.cjs

@@ -0,0 +1,1092 @@
+const require_yaml_config = require('./yaml-config-B3dQ82GR.cjs');
+const require_sampling = require('./sampling.cjs');
+const require_node_require = require('./node-require-DF5QBX6z.cjs');
+const require_tail_sampling_processor = require('./tail-sampling-processor.cjs');
+const require_filtering_span_processor = require('./filtering-span-processor.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');
+const require_canonical_log_line_processor = require('./canonical-log-line-processor--RlFDHhm.cjs');
+let _opentelemetry_sdk_node = require("@opentelemetry/sdk-node");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+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");
+
+//#region src/posthog-logs.ts
+var RedactingLogRecordProcessor = class {
+	wrapped;
+	redact;
+	constructor(wrapped, redact) {
+		this.wrapped = wrapped;
+		this.redact = redact;
+	}
+	onEmit(logRecord, context) {
+		if (logRecord.body && typeof logRecord.body === "string") logRecord.body = this.redact(logRecord.body);
+		if (logRecord.attributes) {
+			for (const [key, value] of Object.entries(logRecord.attributes)) if (typeof value === "string") logRecord.attributes[key] = this.redact(value);
+			else if (Array.isArray(value)) logRecord.attributes[key] = value.map((item) => typeof item === "string" ? this.redact(item) : item);
+		}
+		this.wrapped.onEmit(logRecord, context);
+	}
+	shutdown() {
+		return this.wrapped.shutdown();
+	}
+	forceFlush() {
+		return this.wrapped.forceFlush();
+	}
+};
+/**
+* Build log record processors for PostHog OTLP logs integration.
+*
+* Resolution order:
+* 1. config.url if provided
+* 2. POSTHOG_LOGS_URL env var
+* 3. Empty array (disabled)
+*/
+function buildPostHogLogProcessors(config, stringRedactor) {
+	const url = config?.url || process.env.POSTHOG_LOGS_URL;
+	if (!url) return [];
+	const sdkLogs = require_node_require.safeRequire("@opentelemetry/sdk-logs");
+	const exporterModule = require_node_require.safeRequire("@opentelemetry/exporter-logs-otlp-http");
+	if (!sdkLogs || !exporterModule) return [];
+	const exporter = new exporterModule.OTLPLogExporter({ url });
+	let processor = new sdkLogs.BatchLogRecordProcessor(exporter);
+	if (stringRedactor) processor = new RedactingLogRecordProcessor(processor, stringRedactor);
+	return [processor];
+}
+
+//#endregion
+//#region src/baggage-span-processor.ts
+/**
+* Span processor that automatically copies baggage entries to span attributes
+*
+* This makes baggage visible in trace UIs (Jaeger, Grafana, DataDog, etc.)
+* without manually calling ctx.setAttribute() for each baggage entry.
+*
+* @example Enable in init()
+* ```typescript
+* init({
+*   service: 'my-app',
+*   baggage: true // Uses default 'baggage.' prefix
+* });
+*
+* // Now baggage automatically appears as span attributes
+* await withBaggage({
+*   baggage: { 'tenant.id': 't1', 'user.id': 'u1' },
+*   fn: async () => {
+*     // Span has baggage.tenant.id and baggage.user.id attributes!
+*   }
+* });
+* ```
+*
+* @example Custom prefix
+* ```typescript
+* init({
+*   service: 'my-app',
+*   baggage: 'ctx' // Uses 'ctx.' prefix
+* });
+* // Creates attributes: ctx.tenant.id, ctx.user.id
+* ```
+*/
+var BaggageSpanProcessor = class {
+	prefix;
+	constructor(options = {}) {
+		this.prefix = options.prefix ?? "baggage.";
+	}
+	onStart(span, parentContext) {
+		let baggage = _opentelemetry_api.propagation.getBaggage(parentContext);
+		if (!baggage) baggage = _opentelemetry_api.propagation.getBaggage(_opentelemetry_api.context.active());
+		if (!baggage) try {
+			const { getActiveContextWithBaggage } = require_node_require.requireModule("./trace-context");
+			const storedContext = getActiveContextWithBaggage();
+			baggage = _opentelemetry_api.propagation.getBaggage(storedContext);
+		} catch {}
+		if (!baggage) return;
+		for (const [key, entry] of baggage.getAllEntries()) span.setAttribute(`${this.prefix}${key}`, entry.value);
+	}
+	onEnd(_span) {}
+	async shutdown() {}
+	async forceFlush() {}
+};
+
+//#endregion
+//#region src/redact-values.ts
+/** Standalone string redaction for use outside the span processor pipeline. */
+function createStringRedactor(config) {
+	const resolved = typeof config === "string" ? require_attribute_redacting_processor.REDACTOR_PRESETS[config] : config;
+	const valuePatterns = resolved.valuePatterns ?? [];
+	const defaultReplacement = resolved.replacement ?? "[REDACTED]";
+	return (value) => {
+		let result = value;
+		for (const { pattern, replacement, mask } of valuePatterns) {
+			pattern.lastIndex = 0;
+			if (mask) result = result.replaceAll(pattern, (match) => mask(match));
+			else result = result.replaceAll(pattern, replacement ?? defaultReplacement);
+		}
+		return result;
+	};
+}
+
+//#endregion
+//#region src/env-config.ts
+/**
+* Validate URL format
+*/
+function isValidUrl(urlString) {
+	try {
+		const url = new URL(urlString);
+		return url.protocol === "http:" || url.protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+/**
+* Resolve OpenTelemetry environment variables from process.env
+*/
+function resolveOtelEnv() {
+	const env = {};
+	if (process.env.OTEL_SERVICE_NAME) {
+		const value = process.env.OTEL_SERVICE_NAME.trim();
+		if (value) env.OTEL_SERVICE_NAME = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+		const value = process.env.OTEL_EXPORTER_OTLP_ENDPOINT.trim();
+		if (value && isValidUrl(value)) env.OTEL_EXPORTER_OTLP_ENDPOINT = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
+		const value = process.env.OTEL_EXPORTER_OTLP_HEADERS.trim();
+		if (value) env.OTEL_EXPORTER_OTLP_HEADERS = value;
+	}
+	if (process.env.OTEL_RESOURCE_ATTRIBUTES) {
+		const value = process.env.OTEL_RESOURCE_ATTRIBUTES.trim();
+		if (value) env.OTEL_RESOURCE_ATTRIBUTES = value;
+	}
+	if (process.env.OTEL_EXPORTER_OTLP_PROTOCOL) {
+		const value = process.env.OTEL_EXPORTER_OTLP_PROTOCOL.trim().toLowerCase();
+		if (value === "http" || value === "grpc") env.OTEL_EXPORTER_OTLP_PROTOCOL = value;
+	}
+	if (process.env.OTEL_TRACES_SAMPLER) {
+		const value = process.env.OTEL_TRACES_SAMPLER.trim();
+		if (value) env.OTEL_TRACES_SAMPLER = value;
+	}
+	if (process.env.OTEL_TRACES_SAMPLER_ARG) {
+		const value = process.env.OTEL_TRACES_SAMPLER_ARG.trim();
+		if (value) env.OTEL_TRACES_SAMPLER_ARG = value;
+	}
+	return env;
+}
+function parseRatioSamplerArg(samplerName, samplerArg) {
+	if (samplerArg === void 0) return 1;
+	const ratio = Number(samplerArg);
+	if (!Number.isFinite(ratio) || ratio < 0 || ratio > 1) {
+		console.error(`[autotel] Invalid OTEL_TRACES_SAMPLER_ARG="${samplerArg}" for ${samplerName}. Expected a number in [0..1]. Falling back to 1.0.`);
+		return 1;
+	}
+	return ratio;
+}
+function warnOnUnusedSamplerArg(samplerName, samplerArg) {
+	if (samplerArg !== void 0) console.error(`[autotel] OTEL_TRACES_SAMPLER_ARG is not used by OTEL_TRACES_SAMPLER="${samplerName}". Ignoring value "${samplerArg}".`);
+}
+function createSamplerFromEnv(env) {
+	const samplerName = env.OTEL_TRACES_SAMPLER;
+	if (!samplerName) return;
+	switch (samplerName) {
+		case "always_on":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new _opentelemetry_sdk_trace_base.AlwaysOnSampler();
+		case "always_off":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new _opentelemetry_sdk_trace_base.AlwaysOffSampler();
+		case "traceidratio": return new _opentelemetry_sdk_trace_base.TraceIdRatioBasedSampler(parseRatioSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG));
+		case "parentbased_always_on":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new _opentelemetry_sdk_trace_base.ParentBasedSampler({ root: new _opentelemetry_sdk_trace_base.AlwaysOnSampler() });
+		case "parentbased_always_off":
+			warnOnUnusedSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG);
+			return new _opentelemetry_sdk_trace_base.ParentBasedSampler({ root: new _opentelemetry_sdk_trace_base.AlwaysOffSampler() });
+		case "parentbased_traceidratio": return new _opentelemetry_sdk_trace_base.ParentBasedSampler({ root: new _opentelemetry_sdk_trace_base.TraceIdRatioBasedSampler(parseRatioSamplerArg(samplerName, env.OTEL_TRACES_SAMPLER_ARG)) });
+		case "jaeger_remote":
+		case "parentbased_jaeger_remote":
+		case "xray":
+			console.error(`[autotel] OTEL_TRACES_SAMPLER="${samplerName}" is not supported yet by autotel. Falling back to the next sampler source.`);
+			return;
+		default:
+			console.error(`[autotel] Unknown OTEL_TRACES_SAMPLER="${samplerName}". Falling back to the next sampler source.`);
+			return;
+	}
+}
+/**
+* Parse OTEL_RESOURCE_ATTRIBUTES from comma-separated key=value pairs
+* Example: "service.version=1.0.0,deployment.environment=production"
+*/
+function parseResourceAttributes(input) {
+	if (!input || input.trim() === "") return {};
+	const attributes = {};
+	const pairs = input.split(",");
+	for (const pair of pairs) {
+		const trimmedPair = pair.trim();
+		if (!trimmedPair) continue;
+		const equalIndex = trimmedPair.indexOf("=");
+		if (equalIndex === -1) continue;
+		const key = trimmedPair.slice(0, equalIndex).trim();
+		const value = trimmedPair.slice(equalIndex + 1).trim();
+		if (key && value) attributes[key] = value;
+	}
+	return attributes;
+}
+/**
+* Parse OTEL_EXPORTER_OTLP_HEADERS from comma-separated key=value pairs
+* Example: "api-key=secret123,x-custom-header=value"
+*/
+function parseOtlpHeaders(input) {
+	if (!input || input.trim() === "") return {};
+	const headers = {};
+	const pairs = input.split(",");
+	for (const pair of pairs) {
+		const trimmedPair = pair.trim();
+		if (!trimmedPair) continue;
+		const equalIndex = trimmedPair.indexOf("=");
+		if (equalIndex === -1) continue;
+		const key = trimmedPair.slice(0, equalIndex).trim();
+		const value = trimmedPair.slice(equalIndex + 1).trim();
+		if (key && value) headers[key] = value;
+	}
+	return headers;
+}
+/**
+* Convert resolved environment variables to config
+*/
+function envToConfig(env) {
+	const config = {};
+	if (env.OTEL_SERVICE_NAME) config.service = env.OTEL_SERVICE_NAME;
+	if (env.OTEL_EXPORTER_OTLP_ENDPOINT) config.endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (env.OTEL_EXPORTER_OTLP_PROTOCOL) config.protocol = env.OTEL_EXPORTER_OTLP_PROTOCOL;
+	if (env.OTEL_EXPORTER_OTLP_HEADERS) config.headers = parseOtlpHeaders(env.OTEL_EXPORTER_OTLP_HEADERS);
+	const resourceAttrs = parseResourceAttributes(env.OTEL_RESOURCE_ATTRIBUTES);
+	if (Object.keys(resourceAttrs).length > 0) config.resourceAttributes = resourceAttrs;
+	const sampler = createSamplerFromEnv(env);
+	if (sampler) config.otelSampler = sampler;
+	return config;
+}
+/**
+* Main function to resolve config from environment variables
+*/
+function resolveConfigFromEnv() {
+	return envToConfig(resolveOtelEnv());
+}
+
+//#endregion
+//#region src/devtools.ts
+const defaultHost = "127.0.0.1";
+const defaultPort = 4318;
+function resolveDevtoolsConfig(config) {
+	if (!config) return {
+		enabled: false,
+		endpoint: void 0,
+		embedded: false,
+		host: defaultHost,
+		port: defaultPort,
+		verbose: false
+	};
+	if (config === true) return {
+		enabled: true,
+		endpoint: `http://${defaultHost}:${defaultPort}`,
+		embedded: false,
+		host: defaultHost,
+		port: defaultPort,
+		verbose: false
+	};
+	const enabled = config.enabled ?? true;
+	const host = config.host ?? defaultHost;
+	const port = config.port ?? defaultPort;
+	const endpoint = config.endpoint ?? `http://${host}:${port}`;
+	return {
+		enabled,
+		endpoint: enabled ? endpoint : void 0,
+		embedded: enabled && (config.embedded ?? false),
+		host,
+		port,
+		verbose: config.verbose ?? false
+	};
+}
+
+//#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) {
+			return { decision: sampler.shouldSample({
+				operationName: spanName,
+				args: [],
+				links
+			}) ? _opentelemetry_sdk_trace_base.SamplingDecision.RECORD_AND_SAMPLED : _opentelemetry_sdk_trace_base.SamplingDecision.NOT_RECORD };
+		},
+		toString() {
+			return `AutotelSamplerAdapter`;
+		}
+	};
+}
+let OTLPTraceExporterGRPC;
+let OTLPMetricExporterGRPC;
+let OTLPLogExporterGRPC;
+/**
+* Helper: Lazy-load gRPC trace exporter
+*/
+function loadGRPCTraceExporter() {
+	if (OTLPTraceExporterGRPC) return OTLPTraceExporterGRPC;
+	try {
+		OTLPTraceExporterGRPC = require_node_require.requireModule("@opentelemetry/exporter-trace-otlp-grpc").OTLPTraceExporter;
+		return OTLPTraceExporterGRPC;
+	} catch {
+		throw new Error("gRPC trace exporter not found. Install @opentelemetry/exporter-trace-otlp-grpc");
+	}
+}
+/**
+* Helper: Lazy-load gRPC metric exporter
+*/
+function loadGRPCMetricExporter() {
+	if (OTLPMetricExporterGRPC) return OTLPMetricExporterGRPC;
+	try {
+		OTLPMetricExporterGRPC = require_node_require.requireModule("@opentelemetry/exporter-metrics-otlp-grpc").OTLPMetricExporter;
+		return OTLPMetricExporterGRPC;
+	} catch {
+		throw new Error("gRPC metric exporter not found. Install @opentelemetry/exporter-metrics-otlp-grpc");
+	}
+}
+/**
+* Helper: Create trace exporter based on protocol
+*/
+function createTraceExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCTraceExporter())(config);
+	return new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter(config);
+}
+/**
+* Helper: Create metric exporter based on protocol
+*/
+function createMetricExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCMetricExporter())(config);
+	return new _opentelemetry_exporter_metrics_otlp_http.OTLPMetricExporter(config);
+}
+/**
+* Helper: Lazy-load gRPC log exporter
+*/
+function loadGRPCLogExporter() {
+	if (OTLPLogExporterGRPC) return OTLPLogExporterGRPC;
+	try {
+		OTLPLogExporterGRPC = require_node_require.requireModule("@opentelemetry/exporter-logs-otlp-grpc").OTLPLogExporter;
+		return OTLPLogExporterGRPC;
+	} catch {
+		throw new Error("gRPC log exporter not found. Install @opentelemetry/exporter-logs-otlp-grpc");
+	}
+}
+/**
+* Helper: Create log exporter based on protocol
+*/
+function createLogExporter(protocol, config) {
+	if (protocol === "grpc") return new (loadGRPCLogExporter())(config);
+	return new _opentelemetry_exporter_logs_otlp_http.OTLPLogExporter(config);
+}
+/**
+* Helper: Resolve protocol from config and environment
+*/
+function resolveProtocol(configProtocol) {
+	if (configProtocol === "grpc" || configProtocol === "http") return configProtocol;
+	const envProtocol = process.env.OTEL_EXPORTER_OTLP_PROTOCOL;
+	if (envProtocol === "grpc") return "grpc";
+	if (envProtocol === "http/protobuf" || envProtocol === "http") return "http";
+	return "http";
+}
+/**
+* Helper: Adjust endpoint URL for protocol
+* gRPC exporters don't need the /v1/traces or /v1/metrics path
+* HTTP exporters need the full path
+*/
+function formatEndpointUrl(endpoint, signal, protocol) {
+	if (protocol === "grpc") return endpoint.replace(/\/(v1\/)?(traces|metrics|logs)$/, "");
+	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;
+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")
+	};
+}
+/**
+* Resolve the effective attribute redactor. Explicit config wins (`false`
+* disables). Otherwise the `AUTOTEL_REDACT_PII` env var controls it, and as a
+* final default PII redaction is auto-enabled in production.
+*/
+function resolveAttributeRedactor(explicit, environment) {
+	if (explicit === false) return void 0;
+	if (explicit !== void 0) return explicit;
+	const flag = process.env.AUTOTEL_REDACT_PII?.trim().toLowerCase();
+	if (flag) {
+		if ([
+			"off",
+			"false",
+			"0",
+			"none",
+			"disabled"
+		].includes(flag)) return;
+		if (flag === "default" || flag === "strict" || flag === "pci-dss") return flag;
+		if ([
+			"on",
+			"true",
+			"1",
+			"enabled"
+		].includes(flag)) return "default";
+	}
+	return environment === "production" ? "default" : void 0;
+}
+function detectEnvironmentAttributes() {
+	const attrs = {};
+	const commitSha = process.env.COMMIT_SHA || process.env.GITHUB_SHA || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CF_PAGES_COMMIT_SHA || process.env.AWS_CODEPIPELINE_EXECUTION_ID;
+	if (commitSha) attrs["service.commit.sha"] = commitSha;
+	const region = process.env.VERCEL_REGION || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || process.env.FLY_REGION || process.env.CF_REGION || process.env.GOOGLE_CLOUD_REGION;
+	if (region) attrs["service.region"] = region;
+	const version = process.env.APP_VERSION || process.env.HEROKU_RELEASE_VERSION || process.env.VERCEL_GIT_COMMIT_REF;
+	if (version) attrs["service.deploy.version"] = version;
+	return attrs;
+}
+/**
+* Resolve metrics flag with env var override support
+*/
+function resolveMetricsFlag(configFlag = "auto") {
+	const envFlag = process.env.AUTOTEL_METRICS;
+	if (envFlag === "on" || envFlag === "true") return true;
+	if (envFlag === "off" || envFlag === "false") return false;
+	if (configFlag === true) return true;
+	if (configFlag === false) return false;
+	return true;
+}
+/**
+* Resolve logs flag with env var override support.
+* Defaults to disabled (opt-in only) to avoid unexpected log export
+* and to preserve the upstream SDK's OTEL_LOGS_EXPORTER handling.
+*/
+function resolveLogsFlag(configFlag = "auto") {
+	const envFlag = process.env.AUTOTEL_LOGS;
+	if (envFlag === "on" || envFlag === "true") return true;
+	if (envFlag === "off" || envFlag === "false") return false;
+	if (configFlag === true) return true;
+	if (configFlag === false) return false;
+	return false;
+}
+/**
+* Resolve debug flag with env var override support
+*
+* Supports:
+* - `'pretty'`: Colorized, hierarchical output (PrettyConsoleExporter)
+* - `true` / `'true'` / `'1'`: Raw JSON output (ConsoleSpanExporter)
+* - `false` / `'false'` / `'0'`: Disabled
+*/
+function resolveDebugFlag(configFlag) {
+	const envFlag = process.env.AUTOTEL_DEBUG;
+	if (envFlag === "pretty") return "pretty";
+	if (envFlag === "true" || envFlag === "1") return true;
+	if (envFlag === "false" || envFlag === "0") return false;
+	return configFlag ?? false;
+}
+function normalizeOtlpHeaders(headers) {
+	if (!headers) return void 0;
+	if (typeof headers !== "string") return headers;
+	const parsed = {};
+	for (const pair of headers.split(",")) {
+		const [key, ...valueParts] = pair.split("=");
+		if (!key || valueParts.length === 0) continue;
+		parsed[key.trim()] = valueParts.join("=").trim();
+	}
+	return parsed;
+}
+/**
+* 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 otlpHeaders = normalizeOtlpHeaders(mergedConfig.headers);
+	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");
+		if (devtoolsModule?.createDevtools) {
+			const devtoolsInstance = devtoolsModule.createDevtools({
+				port: devtoolsConfig.port,
+				host: devtoolsConfig.host,
+				verbose: devtoolsConfig.verbose
+			});
+			_devtoolsClose = devtoolsInstance.close;
+			endpoint = `http://${devtoolsConfig.host}:${devtoolsInstance.port}`;
+			logger.info({}, `[autotel] autotel-devtools embedded server started at ${endpoint}`);
+		} else logger.warn({}, "[autotel] devtools.embedded requested but autotel-devtools is not installed. Falling back to endpoint-only mode.");
+	}
+	const hostname = detectHostname();
+	let resource = (0, _opentelemetry_resources.resourceFromAttributes)({
+		[_opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: mergedConfig.service,
+		[_opentelemetry_semantic_conventions.ATTR_SERVICE_VERSION]: version,
+		"deployment.environment": environment,
+		"deployment.environment.name": environment
+	});
+	if (hostname) resource = resource.merge((0, _opentelemetry_resources.resourceFromAttributes)({
+		"host.name": hostname,
+		"datadog.host.name": hostname
+	}));
+	if (mergedConfig.resource) resource = resource.merge(mergedConfig.resource);
+	if (mergedConfig.resourceAttributes) resource = resource.merge((0, _opentelemetry_resources.resourceFromAttributes)(mergedConfig.resourceAttributes));
+	const protocol = resolveProtocol(mergedConfig.protocol);
+	const configuredSpanProcessors = mergedConfig.spanProcessors && mergedConfig.spanProcessors.length > 0 ? mergedConfig.spanProcessors : mergedConfig.spanProcessor ? [mergedConfig.spanProcessor] : void 0;
+	const configuredSpanExporters = mergedConfig.spanExporters && mergedConfig.spanExporters.length > 0 ? mergedConfig.spanExporters : mergedConfig.spanExporter ? [mergedConfig.spanExporter] : void 0;
+	const configuredMetricReaders = mergedConfig.metricReaders && mergedConfig.metricReaders.length > 0 ? mergedConfig.metricReaders : mergedConfig.metricReader ? [mergedConfig.metricReader] : void 0;
+	const configuredLogRecordProcessors = mergedConfig.logRecordProcessors && mergedConfig.logRecordProcessors.length > 0 ? mergedConfig.logRecordProcessors : mergedConfig.logRecordProcessor ? [mergedConfig.logRecordProcessor] : void 0;
+	let spanProcessors = [];
+	if (configuredSpanProcessors && configuredSpanProcessors.length > 0) spanProcessors.push(...configuredSpanProcessors);
+	else if (configuredSpanExporters && configuredSpanExporters.length > 0) for (const exporter of configuredSpanExporters) spanProcessors.push(new require_tail_sampling_processor.TailSamplingSpanProcessor(new _opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter)));
+	else if (endpoint) {
+		const traceExporter = createTraceExporter(protocol, {
+			url: formatEndpointUrl(endpoint, "traces", protocol),
+			headers: otlpHeaders
+		});
+		spanProcessors.push(new require_tail_sampling_processor.TailSamplingSpanProcessor(new _opentelemetry_sdk_trace_base.BatchSpanProcessor(traceExporter)));
+	}
+	if (mergedConfig.baggage) {
+		const prefix = typeof mergedConfig.baggage === "string" ? mergedConfig.baggage ? `${mergedConfig.baggage}.` : "" : "baggage.";
+		spanProcessors.push(new BaggageSpanProcessor({ prefix }));
+	}
+	const debugMode = resolveDebugFlag(mergedConfig.debug);
+	if (debugMode === "pretty") spanProcessors.push(new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(new require_pretty_console_exporter.PrettyConsoleExporter()));
+	else if (debugMode === true) spanProcessors.push(new _opentelemetry_sdk_trace_base.SimpleSpanProcessor(new _opentelemetry_sdk_trace_base.ConsoleSpanExporter()));
+	if (mergedConfig.canonicalLogLines?.enabled) {
+		const canonicalOptions = {
+			logger: mergedConfig.canonicalLogLines.logger || mergedConfig.logger,
+			rootSpansOnly: mergedConfig.canonicalLogLines.rootSpansOnly,
+			minLevel: mergedConfig.canonicalLogLines.minLevel,
+			messageFormat: mergedConfig.canonicalLogLines.messageFormat,
+			includeResourceAttributes: mergedConfig.canonicalLogLines.includeResourceAttributes,
+			shouldEmit: mergedConfig.canonicalLogLines.shouldEmit,
+			keep: mergedConfig.canonicalLogLines.keep,
+			drain: mergedConfig.canonicalLogLines.drain,
+			onDrainError: mergedConfig.canonicalLogLines.onDrainError,
+			pretty: mergedConfig.canonicalLogLines.pretty
+		};
+		spanProcessors.push(new require_canonical_log_line_processor.CanonicalLogLineProcessor(canonicalOptions));
+	}
+	if (mergedConfig.attributeRedactor && spanProcessors.length > 0) {
+		const redactor = mergedConfig.attributeRedactor;
+		spanProcessors = spanProcessors.map((processor) => new require_attribute_redacting_processor.AttributeRedactingProcessor(processor, { redactor }));
+	}
+	if (mergedConfig.attributeRedactor) _stringRedactor = createStringRedactor(mergedConfig.attributeRedactor);
+	if (_stringRedactor && mergedConfig.subscribers) {
+		for (const subscriber of mergedConfig.subscribers) if ("setStringRedactor" in subscriber && typeof subscriber.setStringRedactor === "function") 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.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);
+	else if (metricsEnabled && endpoint) {
+		const metricExporter = createMetricExporter(protocol, {
+			url: formatEndpointUrl(endpoint, "metrics", protocol),
+			headers: otlpHeaders
+		});
+		metricReaders.push(new _opentelemetry_sdk_metrics.PeriodicExportingMetricReader({ exporter: metricExporter }));
+	}
+	let logRecordProcessors;
+	if (configuredLogRecordProcessors && configuredLogRecordProcessors.length > 0) logRecordProcessors = [...configuredLogRecordProcessors];
+	if (logsEnabled && endpoint) {
+		let processor = new _opentelemetry_sdk_logs.BatchLogRecordProcessor(createLogExporter(protocol, {
+			url: formatEndpointUrl(endpoint, "logs", protocol),
+			headers: otlpHeaders
+		}));
+		if (_stringRedactor) processor = new RedactingLogRecordProcessor(processor, _stringRedactor);
+		if (!logRecordProcessors) logRecordProcessors = [];
+		logRecordProcessors.push(processor);
+		logger.info({}, "[autotel] OTLP log exporter configured");
+	}
+	const posthogProcessors = buildPostHogLogProcessors(mergedConfig.posthog, _stringRedactor);
+	if (posthogProcessors.length > 0) {
+		if (!logRecordProcessors) logRecordProcessors = [];
+		logRecordProcessors.push(...posthogProcessors);
+		logger.info({}, "[autotel] PostHog OTLP logs configured");
+	}
+	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");
+		try {
+			const manualInstrumentationNames = getInstrumentationNames(mergedConfig.instrumentations ?? []);
+			if (manualInstrumentationNames.size > 0) {
+				const manualNames = [...manualInstrumentationNames].join(", ");
+				logger.info({}, `[autotel] Detected manual instrumentations (${manualNames}). These will take precedence over auto-instrumentations. Tip: Set autoInstrumentations:false if you want full manual control, or remove manual configs to use auto-instrumentations.`);
+			}
+			const autoInstrumentations = getAutoInstrumentations(mergedConfig.autoInstrumentations, manualInstrumentationNames);
+			if (autoInstrumentations && autoInstrumentations.length > 0) finalInstrumentations = [...finalInstrumentations, ...autoInstrumentations];
+		} catch (error) {
+			logger.warn({}, `[autotel] Failed to configure auto-instrumentations: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	const autotelSampler = mergedConfig.sampler ?? (mergedConfig.sampling ? require_sampling.resolveSamplingPreset(mergedConfig.sampling) : void 0);
+	if (autotelSampler) mergedConfig.sampler = autotelSampler;
+	const sampler = autotelSampler ? toOtelSampler(autotelSampler) : envConfig.otelSampler ?? toOtelSampler(require_sampling.samplingPresets.production());
+	const sdkOptions = {
+		resource,
+		sampler,
+		instrumentations: finalInstrumentations
+	};
+	if (spanProcessors.length > 0) sdkOptions.spanProcessors = spanProcessors;
+	if (metricReaders.length > 0) sdkOptions.metricReaders = metricReaders;
+	if (logRecordProcessors && logRecordProcessors.length > 0) sdkOptions.logRecordProcessors = logRecordProcessors;
+	sdk = mergedConfig.sdkFactory ? mergedConfig.sdkFactory(sdkOptions) : new _opentelemetry_sdk_node.NodeSDK(sdkOptions);
+	if (!sdk) throw new Error("[autotel] sdkFactory must return a NodeSDK instance");
+	sdk.start();
+	if (mergedConfig.openllmetry?.enabled) {
+		const traceloop = _optionalRequire("@traceloop/node-server-sdk");
+		if (traceloop) {
+			const initOptions = { ...mergedConfig.openllmetry.options };
+			try {
+				initOptions.tracerProvider = sdk.getTracerProvider();
+			} catch {}
+			if (configuredSpanExporters?.[0]) initOptions.exporter = configuredSpanExporters[0];
+			if (typeof traceloop.initialize === "function") {
+				traceloop.initialize(initOptions);
+				logger.info({}, "[autotel] OpenLLMetry initialized successfully");
+			} else logger.warn({}, "[autotel] OpenLLMetry initialize function not found. Check @traceloop/node-server-sdk version.");
+		} else logger.warn({}, "[autotel] OpenLLMetry enabled but @traceloop/node-server-sdk is not installed. Install it as a peer dependency to use OpenLLMetry integration.");
+	}
+	initialized = true;
+}
+/**
+* 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);
+}
+/**
+* Check if autotel has been initialized
+*/
+function isInitialized() {
+	return initialized;
+}
+/**
+* Get current config (internal use)
+*/
+function getConfig() {
+	return config;
+}
+/**
+* Get current logger (internal use)
+*/
+function getLogger() {
+	return logger;
+}
+/**
+* Get validation config (internal use)
+*/
+function getValidationConfig() {
+	return validationConfig;
+}
+/**
+* Get events config (internal use)
+*/
+function getEventsConfig() {
+	return eventsConfig;
+}
+/**
+* Warn once if not initialized (same behavior in all environments)
+*/
+function warnIfNotInitialized(context) {
+	if (!initialized && !warnedOnce) {
+		logger.warn({}, `[autotel] ${context} used before init() called. Call init({ service: "..." }) first. See: https://docs.autotel.dev/quickstart`);
+		warnedOnce = true;
+	}
+}
+/**
+* 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() {
+	if (_devtoolsClose) {
+		await _devtoolsClose();
+		_devtoolsClose = null;
+	}
+}
+/**
+* Get SDK instance (for shutdown)
+*/
+function getSdk() {
+	return sdk;
+}
+
+//#endregion
+Object.defineProperty(exports, 'BaggageSpanProcessor', {
+  enumerable: true,
+  get: function () {
+    return BaggageSpanProcessor;
+  }
+});
+Object.defineProperty(exports, '_closeEmbeddedDevtools', {
+  enumerable: true,
+  get: function () {
+    return _closeEmbeddedDevtools;
+  }
+});
+Object.defineProperty(exports, 'createStringRedactor', {
+  enumerable: true,
+  get: function () {
+    return createStringRedactor;
+  }
+});
+Object.defineProperty(exports, 'getConfig', {
+  enumerable: true,
+  get: function () {
+    return getConfig;
+  }
+});
+Object.defineProperty(exports, 'getEventsConfig', {
+  enumerable: true,
+  get: function () {
+    return getEventsConfig;
+  }
+});
+Object.defineProperty(exports, 'getLogger', {
+  enumerable: true,
+  get: function () {
+    return getLogger;
+  }
+});
+Object.defineProperty(exports, 'getSdk', {
+  enumerable: true,
+  get: function () {
+    return getSdk;
+  }
+});
+Object.defineProperty(exports, 'getValidationConfig', {
+  enumerable: true,
+  get: function () {
+    return getValidationConfig;
+  }
+});
+Object.defineProperty(exports, 'init', {
+  enumerable: true,
+  get: function () {
+    return init;
+  }
+});
+Object.defineProperty(exports, 'isInitialized', {
+  enumerable: true,
+  get: function () {
+    return isInitialized;
+  }
+});
+Object.defineProperty(exports, 'isLoggerLocked', {
+  enumerable: true,
+  get: function () {
+    return isLoggerLocked;
+  }
+});
+Object.defineProperty(exports, 'lockLogger', {
+  enumerable: true,
+  get: function () {
+    return lockLogger;
+  }
+});
+Object.defineProperty(exports, 'warnIfNotInitialized', {
+  enumerable: true,
+  get: function () {
+    return warnIfNotInitialized;
+  }
+});
+//# sourceMappingURL=init-DvapOXCc.cjs.map