@sebspark/otel 2.0.7 → 2.0.8

package/dist/index.mjs

@@ -0,0 +1,740 @@
+import { DiagConsoleLogger, DiagLogLevel, SpanStatusCode, SpanStatusCode as SpanStatusCode$1, context, context as context$1, diag, metrics, trace } from "@opentelemetry/api";
+import { SeverityNumber, logs } from "@opentelemetry/api-logs";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchLogRecordProcessor, LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { ExportResultCode } from "@opentelemetry/core";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import fss from "fast-safe-stringify";
+import kleur from "kleur";
+import { containerDetector } from "@opentelemetry/resource-detector-container";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import { detectResources, envDetector, osDetector, processDetector, resourceFromAttributes, serviceInstanceIdDetector } from "@opentelemetry/resources";
+
+//#region src/instrumentations.ts
+let _http;
+let _express;
+let _grpc;
+let _redis;
+let _dns;
+let _net;
+let _fs;
+let _undici;
+let _socketIo;
+const instrumentations = {
+	get http() {
+		if (!_http) _http = import("@opentelemetry/instrumentation-http").then(({ HttpInstrumentation }) => new HttpInstrumentation());
+		return _http;
+	},
+	get express() {
+		if (!_express) _express = import("@opentelemetry/instrumentation-express").then(({ ExpressInstrumentation }) => new ExpressInstrumentation());
+		return _express;
+	},
+	get grpc() {
+		if (!_grpc) _grpc = import("@opentelemetry/instrumentation-grpc").then(({ GrpcInstrumentation }) => new GrpcInstrumentation());
+		return _grpc;
+	},
+	get redis() {
+		if (!_redis) _redis = import("@opentelemetry/instrumentation-redis").then(({ RedisInstrumentation }) => new RedisInstrumentation());
+		return _redis;
+	},
+	get dns() {
+		if (!_dns) _dns = import("@opentelemetry/instrumentation-dns").then(({ DnsInstrumentation }) => new DnsInstrumentation());
+		return _dns;
+	},
+	get net() {
+		if (!_net) _net = import("@opentelemetry/instrumentation-net").then(({ NetInstrumentation }) => new NetInstrumentation());
+		return _net;
+	},
+	get fs() {
+		if (!_fs) _fs = import("@opentelemetry/instrumentation-fs").then(({ FsInstrumentation }) => new FsInstrumentation());
+		return _fs;
+	},
+	get undici() {
+		if (!_undici) _undici = import("@opentelemetry/instrumentation-undici").then(({ UndiciInstrumentation }) => new UndiciInstrumentation());
+		return _undici;
+	},
+	get socketIo() {
+		if (!_socketIo) _socketIo = import("@opentelemetry/instrumentation-socket.io").then(({ SocketIoInstrumentation }) => new SocketIoInstrumentation());
+		return _socketIo;
+	}
+};
+
+//#endregion
+//#region src/consts.ts
+const LOG_SEVERITY_MAP = {
+	TRACE: 1,
+	DEBUG: 5,
+	INFO: 9,
+	NOTICE: 10,
+	WARNING: 13,
+	WARN: 13,
+	ERROR: 17,
+	FATAL: 21,
+	CRITICAL: 21,
+	ALERT: 22,
+	EMERGENCY: 23
+};
+
+//#endregion
+//#region src/loggers/formatters/style.ts
+const colors = {
+	gray: kleur.gray,
+	dim: kleur.dim,
+	cyan: kleur.cyan,
+	white: kleur.white,
+	green: kleur.green,
+	yellow: kleur.yellow,
+	red: kleur.red,
+	magenta: kleur.magenta
+};
+const levelColorMap = {
+	DEBUG: kleur.magenta,
+	INFO: kleur.green,
+	WARN: kleur.yellow,
+	ERROR: kleur.red,
+	FATAL: kleur.red
+};
+const levelIconMap = {
+	DEBUG: "🐛",
+	INFO: "ℹ️ ",
+	WARN: "⚠️ ",
+	ERROR: "❌",
+	FATAL: "💀"
+};
+const statusLabelMap = {
+	0: "UNSET",
+	1: "OK",
+	2: "ERROR"
+};
+const statusColorMap = {
+	0: colors.gray,
+	1: colors.green,
+	2: colors.red
+};
+const kindColorMap = {
+	0: colors.white,
+	1: colors.cyan,
+	2: colors.yellow,
+	3: colors.magenta,
+	4: colors.green
+};
+
+//#endregion
+//#region src/loggers/formatters/shared.ts
+const stringify = fss.default.stableStringify;
+function formatTimestamp(time) {
+	const date = new Date(hrTimeToMillis(time));
+	return colors.dim(date.toISOString().slice(11, 23));
+}
+function formatService(resource) {
+	const name = resource.attributes[ATTR_SERVICE_NAME] ?? "unknown-service";
+	const version = resource.attributes[ATTR_SERVICE_VERSION] ?? "1.0.0";
+	return colors.gray(`[${name}@${version}]`);
+}
+function formatLevel(record) {
+	const text = (record.severityText ?? "INFO").toUpperCase();
+	const colorFn = levelColorMap[text] ?? colors.white;
+	return `${levelIconMap[text] ?? "•"}  ${colorFn(text.padEnd(5))}`;
+}
+function formatScope(resource, instrumentationScope) {
+	const component = resource.attributes["component.name"];
+	const { name, version } = instrumentationScope;
+	const scopeLabel = component || (name && name !== "unknown" ? name : void 0);
+	if (!scopeLabel) return "";
+	const versionLabel = version ? `@${version}` : "";
+	return colors.cyan(`${scopeLabel}${versionLabel} `);
+}
+function formatMessage(record) {
+	return typeof record.body === "string" ? record.body : stringify(record.body);
+}
+function formatAttributes(attrs) {
+	const keys = Object.keys(attrs).filter((k) => !k.startsWith("service.") && !k.startsWith("serviceContext."));
+	if (keys.length === 0) return "";
+	const formatted = keys.map((k) => {
+		const val = attrs[k];
+		return `${k}=${typeof val === "object" ? stringify(val) : val}`;
+	});
+	return `  ${colors.gray(formatted.join(" "))}`;
+}
+function hrTimeToMillis(hrTime) {
+	return hrTime[0] * 1e3 + Math.floor(hrTime[1] / 1e6);
+}
+function calculateDuration(span) {
+	const start = hrTimeToMillis(span.startTime);
+	const end = hrTimeToMillis(span.endTime);
+	return Math.max(0, Math.round(end - start));
+}
+
+//#endregion
+//#region src/loggers/formatters/log-record.ts
+function formatLogRecord(record) {
+	const timestamp = formatTimestamp(record.hrTime);
+	return `${formatService(record.resource)} ${timestamp}  ${formatLevel(record)}  ${formatScope(record.resource, record.instrumentationScope)}${formatMessage(record)}${formatAttributes(record.attributes)}`;
+}
+
+//#endregion
+//#region src/loggers/formatters/metrics.ts
+function formatMetrics(resourceMetrics) {
+	const { resource, scopeMetrics } = resourceMetrics;
+	return scopeMetrics.map((scopeMetric) => formatScopeMetric(scopeMetric, resource)).join("\n");
+}
+function formatScopeMetric(scopeMetric, resource) {
+	return scopeMetric.metrics.map((metric) => formatMetricData(metric, resource, scopeMetric.scope)).join("\n");
+}
+function formatMetricData(metric, resource, scope) {
+	const scopeStr = formatScope(resource, scope);
+	const serviceStr = formatService(resource);
+	const lines = [];
+	for (const dp of metric.dataPoints) {
+		const ts = formatTimestamp(dp.startTime);
+		const value = extractMetricValue(dp);
+		const attrs = formatAttributes(dp.attributes ?? {});
+		lines.push(`${serviceStr} ${ts}  📊  ${scopeStr}${colors.white(metric.descriptor.name)} ${colors.dim(value)}${attrs}`);
+	}
+	return lines.join("\n");
+}
+function extractMetricValue(dp) {
+	const value = dp.value;
+	if (typeof value === "number") return value.toString();
+	if (isHistogramLike(value)) return value.sum.toString();
+	return "[complex]";
+}
+function isHistogramLike(val) {
+	return typeof val === "object" && val !== null && "sum" in val && typeof val.sum === "number";
+}
+
+//#endregion
+//#region src/loggers/formatters/span.ts
+const LABEL_WIDTH = 20;
+const DESCRIPTION_MAX_WIDTH = 16;
+const BAR_MIN_WIDTH = 1;
+const BAR_MAX_WIDTH = 20;
+function formatSpans(spans) {
+	const rootSpan = spans[0];
+	const rootStart = hrTimeToMillis(rootSpan.startTime);
+	const totalDuration = hrTimeToMillis(rootSpan.endTime) - rootStart;
+	const lines = [`${formatService(rootSpan.resource)} ${formatTimestamp(rootSpan.startTime)} ${colors.gray(`[${rootSpan.spanContext().traceId}]`)}`];
+	for (const span of spans) {
+		const offset = hrTimeToMillis(span.startTime) - rootStart;
+		const depth = computeDepth(span, spans);
+		lines.push(formatSpan(span, {
+			offsetMs: offset,
+			totalDurationMs: totalDuration,
+			depth
+		}));
+	}
+	return lines.join("\n");
+}
+function formatSpan(span, opts) {
+	const label = formatLabel(span, opts.depth);
+	const bar = buildBar(span, opts?.offsetMs, opts?.totalDurationMs);
+	const barColor = span.status.code === SpanStatusCode$1.OK ? colors.green : span.status.code === SpanStatusCode$1.ERROR ? colors.red : colors.gray;
+	const desc = formatDescription(span);
+	const status = formatStatus(span);
+	const duration = formatDuration(span, opts?.offsetMs);
+	const spanId = colors.gray(`[${span.spanContext().spanId}]`);
+	return `${label} ${barColor(bar)} ${desc} ${status} ${duration} ${spanId}`;
+}
+function formatLabel(span, depth) {
+	return `${"  ".repeat(depth)}└─ ${span.name}`.padEnd(LABEL_WIDTH);
+}
+function buildBar(span, offsetMs, totalDurationMs) {
+	const duration = calculateDuration(span);
+	if (typeof offsetMs !== "number" || typeof totalDurationMs !== "number" || totalDurationMs === 0) {
+		const capped = Math.min(duration, 1e3);
+		const barLength = Math.max(BAR_MIN_WIDTH, Math.round(capped / 1e3 * BAR_MAX_WIDTH));
+		return "█".repeat(barLength).padEnd(BAR_MAX_WIDTH + 2);
+	}
+	const offsetRatio = Math.max(0, Math.min(offsetMs / totalDurationMs, 1));
+	const durationRatio = Math.max(0, Math.min(duration / totalDurationMs, 1));
+	const offsetChars = Math.floor(offsetRatio * BAR_MAX_WIDTH);
+	const barChars = Math.max(BAR_MIN_WIDTH, Math.round(durationRatio * BAR_MAX_WIDTH));
+	return (" ".repeat(offsetChars) + "█".repeat(barChars)).padEnd(BAR_MAX_WIDTH + 2);
+}
+function formatDescription(span) {
+	for (const keys of [
+		["http.method", "http.target"],
+		["http.route"],
+		["http.url"],
+		["graphql.operation.name"],
+		["graphql.operation.type"],
+		["graphql.document"],
+		["ws.event"],
+		["ws.message_type"],
+		["ws.url"],
+		["db.system", "db.statement"],
+		["db.operation"],
+		["db.statement"],
+		["db.operation"],
+		["db.name"],
+		["db.operation"],
+		["db.statement"],
+		["messaging.operation"],
+		["messaging.destination"],
+		["messaging.gcp_pubsub.topic"],
+		["faas.invoked_name"],
+		["faas.trigger"],
+		["otel.description"]
+	]) {
+		const parts = keys.map((k) => span.attributes[k]).filter((v) => v !== void 0 && v !== null).map((v) => String(v));
+		if (parts.length > 0) return truncate(parts.join(" "), DESCRIPTION_MAX_WIDTH - 1).padEnd(DESCRIPTION_MAX_WIDTH);
+	}
+	return "".padEnd(DESCRIPTION_MAX_WIDTH);
+}
+function formatStatus(span) {
+	const code = span.status.code;
+	const label = statusLabelMap[code] ?? "UNSET";
+	return (statusColorMap[code] ?? colors.gray)(label).padEnd(6);
+}
+function formatDuration(span, offsetMs) {
+	const duration = calculateDuration(span);
+	const format = (ms) => ms >= 1e3 ? `${(ms / 1e3).toFixed(2)} s` : `${ms} ms`;
+	return `(${format(offsetMs || 0)}–${format(duration)})`.padEnd(16);
+}
+function truncate(input, maxLength) {
+	const str = String(input ?? "");
+	return str.length > maxLength ? `${str.slice(0, maxLength - 1)}…` : str;
+}
+function computeDepth(span, allSpans) {
+	let depth = 0;
+	let currentParentId = span.parentSpanContext?.spanId;
+	while (currentParentId) {
+		const parentSpan = allSpans.find((s) => s.spanContext().spanId === currentParentId);
+		if (!parentSpan) break;
+		depth += 1;
+		currentParentId = parentSpan.parentSpanContext?.spanId;
+	}
+	return depth;
+}
+
+//#endregion
+//#region src/loggers/console-metric-pretty-exporter.ts
+var ConsoleMetricPrettyExporter = class {
+	patterns;
+	constructor() {
+		this.patterns = (process.env.METRIC_FILTER ?? "").split(",").map((e) => e.trim()).filter(Boolean).map(globToRegex);
+	}
+	filterMetrics(resourceMetrics) {
+		if (this.patterns.length === 0) return void 0;
+		const filteredScopes = resourceMetrics.scopeMetrics.map((scopeMetric) => {
+			const filteredMetrics = scopeMetric.metrics.filter((metric) => this.patterns.some((pattern) => pattern.test(metric.descriptor.name)));
+			if (filteredMetrics.length === 0) return void 0;
+			return {
+				...scopeMetric,
+				metrics: filteredMetrics
+			};
+		}).filter((s) => s !== void 0);
+		if (filteredScopes.length === 0) return void 0;
+		return {
+			...resourceMetrics,
+			scopeMetrics: filteredScopes
+		};
+	}
+	export(metrics$1, resultCallback) {
+		const filtered = this.filterMetrics(metrics$1);
+		if (filtered) console.log(formatMetrics(filtered));
+		resultCallback({ code: ExportResultCode.SUCCESS });
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+	forceFlush() {
+		return Promise.resolve();
+	}
+};
+function globToRegex(glob) {
+	const regex = `^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`;
+	return new RegExp(regex);
+}
+
+//#endregion
+//#region src/loggers/console-log-pretty-exporter.ts
+var ConsoleLogPrettyExporter = class {
+	logThreshold;
+	constructor() {
+		const defaultLogLevel = "INFO";
+		this.logThreshold = LOG_SEVERITY_MAP[process.env.LOG_LEVEL?.toUpperCase() ?? defaultLogLevel] ?? LOG_SEVERITY_MAP[defaultLogLevel];
+	}
+	export(logs$1, resultCallback) {
+		this._sendLogRecords(logs$1, resultCallback);
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+	forceFlush() {
+		return Promise.resolve();
+	}
+	_sendLogRecords(logRecords, done) {
+		for (const record of logRecords) if ((record.severityNumber ?? 0) >= this.logThreshold) {
+			const formatted = formatLogRecord(record);
+			const severity = record.severityNumber || SeverityNumber.UNSPECIFIED;
+			if (severity >= SeverityNumber.ERROR) console.error(formatted);
+			else if (severity >= SeverityNumber.WARN) console.warn(formatted);
+			else if (severity >= SeverityNumber.INFO) console.info(formatted);
+			else if (severity >= SeverityNumber.DEBUG) console.debug(formatted);
+			else console.trace(formatted);
+		}
+		done?.({ code: ExportResultCode.SUCCESS });
+	}
+};
+
+//#endregion
+//#region src/loggers/console-span-pretty-exporter.ts
+var ConsoleSpanPrettyExporter = class {
+	allowedStatuses;
+	constructor() {
+		const env = process.env.SPAN_LEVEL?.toUpperCase();
+		if (!env) this.allowedStatuses = new Set([
+			SpanStatusCode$1.UNSET,
+			SpanStatusCode$1.OK,
+			SpanStatusCode$1.ERROR
+		]);
+		else {
+			const map = {
+				UNSET: SpanStatusCode$1.UNSET,
+				OK: SpanStatusCode$1.OK,
+				ERROR: SpanStatusCode$1.ERROR
+			};
+			this.allowedStatuses = new Set(env.split(",").map((s) => s.trim()).map((s) => map[s]).filter((v) => typeof v === "number"));
+		}
+	}
+	shouldExport(spans) {
+		if (this.allowedStatuses.size === 3) return true;
+		return spans.some((span) => this.allowedStatuses.has(span.status.code));
+	}
+	export(spans, resultCallback) {
+		if (this.shouldExport(spans)) console.log(formatSpans(spans));
+		resultCallback({ code: ExportResultCode.SUCCESS });
+	}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+//#region src/loggers/tree-span-processor.ts
+var TreeSpanProcessor = class {
+	exporter;
+	orphans = /* @__PURE__ */ new Map();
+	constructor(exporter) {
+		this.exporter = exporter;
+	}
+	onStart() {}
+	onEnd(span) {
+		const parentId = span.parentSpanContext?.spanId;
+		if (parentId) {
+			const siblings = this.orphans.get(parentId) || [];
+			this.orphans.set(parentId, [...siblings, span]);
+			return;
+		}
+		const sorted = [span, ...this.getChildrenRecursively(span)].sort((s1, s2) => {
+			const [sec1, nano1] = s1.startTime;
+			const [sec2, nano2] = s2.startTime;
+			if (sec1 !== sec2) return sec1 - sec2;
+			return nano1 - nano2;
+		});
+		this.exporter.export(sorted, () => {});
+	}
+	getChildrenRecursively(span) {
+		const spanId = span.spanContext().spanId;
+		const children = this.orphans.get(spanId) || [];
+		this.orphans.delete(spanId);
+		const result = [...children];
+		for (const child of children) result.push(...this.getChildrenRecursively(child));
+		return result;
+	}
+	shutdown() {
+		return this.exporter.shutdown();
+	}
+	async forceFlush() {
+		await this.exporter.forceFlush?.();
+	}
+};
+
+//#endregion
+//#region src/providers.ts
+const getLogProvider = (resource, otlpEndpoint) => {
+	if (otlpEndpoint) {
+		const processors = [new BatchLogRecordProcessor(new OTLPLogExporter({ url: `${otlpEndpoint}/v1/logs` }))];
+		if (process.env.LOG_LEVEL) processors.push(new SimpleLogRecordProcessor(new ConsoleLogPrettyExporter()));
+		return new LoggerProvider({
+			resource,
+			processors
+		});
+	}
+	return new LoggerProvider({
+		resource,
+		processors: [new SimpleLogRecordProcessor(new ConsoleLogPrettyExporter())]
+	});
+};
+const getSpanProcessor = (otlpEndpoint) => {
+	const exporter = otlpEndpoint ? new OTLPTraceExporter({ url: `${otlpEndpoint}/v1/traces` }) : new ConsoleSpanPrettyExporter();
+	return otlpEndpoint ? new BatchSpanProcessor(exporter) : new TreeSpanProcessor(exporter);
+};
+const getMetricReader = (otlpEndpoint) => {
+	return new PeriodicExportingMetricReader({ exporter: otlpEndpoint ? new OTLPMetricExporter({ url: `${otlpEndpoint}/v1/metrics` }) : new ConsoleMetricPrettyExporter() });
+};
+
+//#endregion
+//#region src/otel-context.ts
+/**
+* Extracts telemetry context from environment (cloud/k8s aware),
+* with support for subservice/component override.
+*/
+function detectTelemetryContext(componentNameOverride) {
+	const { OTEL_SERVICE_NAME, OTEL_SERVICE_VERSION, K_SERVICE, K_REVISION, K_CONFIGURATION, KUBERNETES_SERVICE_HOST, POD_NAME, POD_NAMESPACE, GCP_PROJECT, CLOUD_PROVIDER } = process.env;
+	const systemName = OTEL_SERVICE_NAME || "unknown-service";
+	const systemVersion = OTEL_SERVICE_VERSION || "1.0.0";
+	const componentName = componentNameOverride || void 0;
+	return {
+		systemName,
+		systemVersion,
+		componentName,
+		resourceAttributes: {
+			[ATTR_SERVICE_NAME]: systemName,
+			[ATTR_SERVICE_VERSION]: systemVersion,
+			"serviceContext.service": systemName,
+			"serviceContext.version": systemVersion,
+			...K_SERVICE && { "cloud.run.service": K_SERVICE },
+			...K_REVISION && { "cloud.run.revision": K_REVISION },
+			...K_CONFIGURATION && { "cloud.run.configuration": K_CONFIGURATION },
+			...POD_NAME && { "k8s.pod_name": POD_NAME },
+			...POD_NAMESPACE && { "k8s.namespace_name": POD_NAMESPACE },
+			...KUBERNETES_SERVICE_HOST && { "cloud.orchestrator": "kubernetes" },
+			...GCP_PROJECT && { "cloud.account.id": GCP_PROJECT },
+			...CLOUD_PROVIDER && { "cloud.provider": CLOUD_PROVIDER },
+			...componentName && { "component.name": componentName }
+		}
+	};
+}
+
+//#endregion
+//#region src/resource.ts
+const getResource = async () => {
+	const baseRes = await detectResources({ detectors: [
+		containerDetector,
+		envDetector,
+		gcpDetector,
+		osDetector,
+		processDetector,
+		serviceInstanceIdDetector
+	] });
+	if (baseRes.waitForAsyncAttributes) await baseRes.waitForAsyncAttributes();
+	const { resourceAttributes } = detectTelemetryContext();
+	const customRes = resourceFromAttributes(resourceAttributes);
+	const resource = baseRes.merge(customRes);
+	if (resource.waitForAsyncAttributes) await resource.waitForAsyncAttributes();
+	return resource;
+};
+
+//#endregion
+//#region src/otel.ts
+diag.disable();
+diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR);
+let initialization;
+let _isInitialized = false;
+async function initialize(...instrumentations$1) {
+	if (!initialization) {
+		initialization = _initialize(await Promise.all(instrumentations$1));
+		initialization.then(() => {
+			_isInitialized = true;
+		});
+	}
+	return initialization;
+}
+function isInitialized() {
+	return _isInitialized;
+}
+async function _initialize(instrumentations$1) {
+	try {
+		const serviceName = process.env.OTEL_SERVICE_NAME ?? "unknown-service";
+		const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+		const resource = await getResource();
+		context$1.disable();
+		logs.disable();
+		trace.disable();
+		metrics.disable();
+		const logProvider = getLogProvider(resource, otlpEndpoint);
+		logs.setGlobalLoggerProvider(logProvider);
+		const sdk = new NodeSDK({
+			spanProcessor: getSpanProcessor(otlpEndpoint),
+			metricReader: getMetricReader(otlpEndpoint),
+			instrumentations: instrumentations$1,
+			resource
+		});
+		await sdk.start();
+		console.log(`[otel] Telemetry initialized for "${serviceName}"`);
+		process.on("SIGTERM", async () => {
+			console.log("[otel] Shutting down...");
+			await Promise.all([sdk.shutdown(), logProvider.shutdown()]);
+			console.log("[otel] Shutdown complete.");
+			process.exit(0);
+		});
+	} catch (err) {
+		console.error("[otel] Startup error:", err);
+	}
+}
+
+//#endregion
+//#region src/logger.ts
+function getLogger(serviceOverride, extraAttrs = {}) {
+	const { systemName, systemVersion, resourceAttributes } = detectTelemetryContext(serviceOverride);
+	const defaultAttrs = {
+		...resourceAttributes,
+		...extraAttrs
+	};
+	function emit(severityText, body, attrs = {}) {
+		if (!isInitialized() && process.env.NODE_ENV !== "test") {
+			console.warn("OTEL must be initialized before using logger");
+			console.log(`[${severityText}] ${body}`);
+			return;
+		}
+		const logger = logs.getLogger(systemName, systemVersion);
+		const spanContext = trace.getSpan(context$1.active())?.spanContext();
+		logger.emit({
+			severityText,
+			severityNumber: LOG_SEVERITY_MAP[severityText],
+			body,
+			attributes: {
+				...defaultAttrs,
+				...spanContext && {
+					trace_id: spanContext.traceId,
+					span_id: spanContext.spanId
+				},
+				...attrs
+			}
+		});
+	}
+	return {
+		debug: (msg, attrs) => emit("DEBUG", msg, attrs),
+		info: (msg, attrs) => emit("INFO", msg, attrs),
+		notice: (msg, attrs) => emit("NOTICE", msg, attrs),
+		warn: (msg, attrs) => emit("WARNING", msg, attrs),
+		error: (msg, errOrAttrs, maybeAttrs = {}) => {
+			let body;
+			let attrs;
+			if (errOrAttrs instanceof Error) {
+				body = `${msg}: ${errOrAttrs.stack || errOrAttrs.message}`;
+				attrs = maybeAttrs;
+			} else {
+				body = msg instanceof Error ? msg.stack || msg.message : msg;
+				attrs = errOrAttrs || {};
+			}
+			emit("ERROR", body, attrs);
+		},
+		critical: (msg, attrs) => emit("CRITICAL", msg, attrs),
+		alert: (msg, attrs) => emit("ALERT", msg, attrs),
+		emergency: (msg, attrs) => emit("EMERGENCY", msg, attrs)
+	};
+}
+
+//#endregion
+//#region src/metrics.ts
+function getMeter(componentNameOverride) {
+	if (!isInitialized() && process.env.NODE_ENV !== "test") console.warn("OTEL must be initialized before using getMeter()");
+	const { componentName, systemName, systemVersion } = detectTelemetryContext(componentNameOverride);
+	return metrics.getMeter(componentName ?? systemName, systemVersion);
+}
+
+//#endregion
+//#region src/tracer.ts
+/**
+* Returns an OpenTelemetry tracer bound to the current service.
+* Includes `withTrace()` and `withTraceSync()` helpers for span-wrapped execution.
+*
+* @param serviceOverride - Optional override for service name
+* @returns Tracer with helpers
+*/
+function getTracer(componentNameOverride) {
+	if (!isInitialized() && process.env.NODE_ENV !== "test") console.warn("OTEL must be initialized before calling getTracer()");
+	const { componentName, systemName, systemVersion } = detectTelemetryContext(componentNameOverride);
+	const tracer = trace.getTracer(componentName ?? systemName, systemVersion);
+	/**
+	* Runs a function inside a new span (async variant).
+	* Automatically handles span status and nesting.
+	*/
+	const withTrace = async (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+		const { options, parent, fn } = extractArgs(spanOptionsSpanOrFunc, spanOrFunc, func);
+		const parentContext = parent ? trace.setSpan(context$1.active(), parent) : context$1.active();
+		const span = tracer.startSpan(name, options, parentContext);
+		return await context$1.with(trace.setSpan(parentContext, span), async () => {
+			try {
+				const result = await fn(span);
+				span.setStatus({ code: SpanStatusCode$1.OK });
+				return result;
+			} catch (err) {
+				const error = err;
+				span.setStatus({
+					code: SpanStatusCode$1.ERROR,
+					message: error.message
+				});
+				span.recordException?.(error);
+				throw err;
+			} finally {
+				span.end();
+			}
+		});
+	};
+	/**
+	* Runs a synchronous function inside a new span.
+	* Automatically handles span status and nesting.
+	*/
+	const withTraceSync = (name, spanOptionsSpanOrFunc, spanOrFunc, func) => {
+		const { options, parent, fn } = extractArgs(spanOptionsSpanOrFunc, spanOrFunc, func);
+		const parentContext = parent ? trace.setSpan(context$1.active(), parent) : context$1.active();
+		const span = tracer.startSpan(name, options, parentContext);
+		return context$1.with(trace.setSpan(parentContext, span), () => {
+			try {
+				const result = fn(span);
+				span.setStatus({ code: SpanStatusCode$1.OK });
+				return result;
+			} catch (err) {
+				const error = err;
+				span.setStatus({
+					code: SpanStatusCode$1.ERROR,
+					message: error.message
+				});
+				span.recordException?.(error);
+				throw err;
+			} finally {
+				span.end();
+			}
+		});
+	};
+	tracer.withTrace = withTrace;
+	tracer.withTraceSync = withTraceSync;
+	return tracer;
+}
+function extractArgs(spanOptionsSpanOrFunc, spanOrFunc, func) {
+	let options = {};
+	let parent;
+	let fn;
+	if (isFunction(spanOptionsSpanOrFunc)) fn = spanOptionsSpanOrFunc;
+	else if (isFunction(spanOrFunc)) {
+		const spanOrSpanOptions = spanOptionsSpanOrFunc;
+		if (isSpanOptions(spanOrSpanOptions)) options = spanOrSpanOptions;
+		else parent = spanOrSpanOptions;
+		fn = spanOrFunc;
+	} else {
+		options = spanOptionsSpanOrFunc;
+		parent = spanOrFunc;
+		fn = func;
+	}
+	return {
+		options,
+		parent,
+		fn
+	};
+}
+const isFunction = (value) => typeof value === "function";
+const isSpan = (value) => value !== null && value !== void 0 && isFunction(value.spanContext) && isFunction(value.end);
+const isSpanOptions = (value) => value !== null && value !== void 0 && (!!value.startTime || !!value.attributes || !!value.kind) && !isSpan(value);
+
+//#endregion
+export { SpanStatusCode, context, getLogger, getMeter, getTracer, initialize, instrumentations, isInitialized };
+//# sourceMappingURL=index.mjs.map