@davidilie/telemetry-node 0.0.0-bootstrap.0

package/dist/sampler-BnXptsJ8.cjs

@@ -0,0 +1,513 @@
+let _opentelemetry_api = require("@opentelemetry/api");
+let _opentelemetry_api_logs = require("@opentelemetry/api-logs");
+let _davidilie_telemetry_core = require("@davidilie/telemetry-core");
+let _opentelemetry_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+//#region src/attributes.ts
+function toOtelAttributeValue(value) {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value.every((entry) => typeof entry === "string")) return [...value];
+	if (value.every((entry) => typeof entry === "number")) return [...value];
+	if (value.every((entry) => typeof entry === "boolean")) return [...value];
+	return value.map(String);
+}
+function toOtelAttributes(attributes = {}) {
+	const result = {};
+	for (const [key, value] of Object.entries(attributes)) {
+		if (value == null) continue;
+		result[key] = toOtelAttributeValue(value);
+	}
+	return result;
+}
+function telemetryResourceAttributes(resource) {
+	return {
+		...toOtelAttributes(resource.attributes),
+		"service.name": resource.serviceName,
+		...resource.serviceVersion ? { "service.version": resource.serviceVersion } : {},
+		...resource.environment ? { "deployment.environment.name": resource.environment } : {},
+		...resource.namespace ? { "service.namespace": resource.namespace } : {},
+		...resource.repositoryUrl ? {
+			"app.repository.url": resource.repositoryUrl,
+			"vcs.repository.url.full": resource.repositoryUrl
+		} : {},
+		...resource.commitSha ? { "vcs.ref.head.revision": resource.commitSha } : {},
+		...resource.platform ? {
+			"app.platform": resource.platform,
+			"deployment.platform": resource.platform
+		} : {}
+	};
+}
+//#endregion
+//#region src/adapter.ts
+const severityNumbers = {
+	debug: _opentelemetry_api_logs.SeverityNumber.DEBUG,
+	info: _opentelemetry_api_logs.SeverityNumber.INFO,
+	warn: _opentelemetry_api_logs.SeverityNumber.WARN,
+	error: _opentelemetry_api_logs.SeverityNumber.ERROR
+};
+function exceptionForOtel(error) {
+	if (error instanceof Error) {
+		const safe = new Error((0, _davidilie_telemetry_core.redactText)(error.message), { ...error.cause !== void 0 ? { cause: (0, _davidilie_telemetry_core.redactText)(String(error.cause)) } : {} });
+		safe.name = (0, _davidilie_telemetry_core.redactText)(error.name, 256);
+		if (error.stack) safe.stack = (0, _davidilie_telemetry_core.redactText)(error.stack, 16384);
+		return safe;
+	}
+	return (0, _davidilie_telemetry_core.redactText)(typeof error === "string" ? error : String(error));
+}
+function signalAttributes(signal) {
+	return {
+		...toOtelAttributes(signal.attributes),
+		...telemetryResourceAttributes(signal.resource),
+		"telemetry.signal.id": signal.id,
+		"telemetry.signal.type": signal.type
+	};
+}
+const spanKinds = {
+	internal: _opentelemetry_api.SpanKind.INTERNAL,
+	server: _opentelemetry_api.SpanKind.SERVER,
+	client: _opentelemetry_api.SpanKind.CLIENT,
+	producer: _opentelemetry_api.SpanKind.PRODUCER,
+	consumer: _opentelemetry_api.SpanKind.CONSUMER
+};
+const spanStatuses = {
+	unset: _opentelemetry_api.SpanStatusCode.UNSET,
+	ok: _opentelemetry_api.SpanStatusCode.OK,
+	error: _opentelemetry_api.SpanStatusCode.ERROR
+};
+const VALID_INSTRUMENT_NAME = /^[A-Za-z][A-Za-z0-9_.\-/]{0,254}$/;
+var OpenTelemetrySpan = class {
+	#span;
+	constructor(span) {
+		this.#span = span;
+	}
+	setAttribute(name, value) {
+		const safe = (0, _davidilie_telemetry_core.sanitizeAttributes)({ [name]: value });
+		if (safe[name] !== void 0) this.#span.setAttribute(name, toOtelAttributeValue(safe[name]));
+		return this;
+	}
+	recordException(error, attributes = {}) {
+		this.#span.setAttributes(toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes)));
+		this.#span.recordException(exceptionForOtel(error));
+		this.#span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+	}
+	setStatus(status, message) {
+		this.#span.setStatus({
+			code: spanStatuses[status],
+			...message ? { message: (0, _davidilie_telemetry_core.redactText)(message) } : {}
+		});
+		return this;
+	}
+	end() {
+		this.#span.end();
+	}
+};
+var OpenTelemetryAdapter = class {
+	#instrumentationName;
+	#instrumentationVersion;
+	#resource;
+	#structuredConsole;
+	#measurementMode;
+	#metricAttributeAllowlist;
+	#maxMetricInstruments;
+	#logSampleRate;
+	#shutdown;
+	#histograms = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.#resource = (0, _davidilie_telemetry_core.sanitizeResource)(config.resource);
+		this.#instrumentationName = config.instrumentationName ?? this.#resource.serviceName;
+		this.#instrumentationVersion = config.instrumentationVersion;
+		this.#structuredConsole = config.structuredConsole ?? true;
+		this.#measurementMode = config.measurementMode ?? "spans";
+		this.#metricAttributeAllowlist = new Set(config.metricAttributeAllowlist ?? []);
+		this.#maxMetricInstruments = Math.max(0, Math.floor(Number.isFinite(config.maxMetricInstruments) ? config.maxMetricInstruments ?? 64 : 64));
+		this.#logSampleRate = Number.isFinite(config.logSampleRate) ? Math.min(1, Math.max(0, config.logSampleRate ?? 1)) : 1;
+		this.#shutdown = config.shutdown;
+	}
+	send(signal) {
+		signal = (0, _davidilie_telemetry_core.sanitizeSignal)(signal);
+		const attributes = signalAttributes(signal);
+		switch (signal.type) {
+			case "event": {
+				const activeSpan = _opentelemetry_api.trace.getActiveSpan();
+				if (activeSpan) {
+					activeSpan.addEvent(signal.name, attributes, new Date(signal.timestamp));
+					return;
+				}
+				const span = this.#tracer().startSpan(signal.name, {
+					kind: _opentelemetry_api.SpanKind.INTERNAL,
+					attributes,
+					startTime: new Date(signal.timestamp)
+				});
+				span.addEvent(signal.name, attributes, new Date(signal.timestamp));
+				span.end(new Date(signal.timestamp));
+				return;
+			}
+			case "exception": {
+				const activeSpan = _opentelemetry_api.trace.getActiveSpan();
+				const span = activeSpan ?? this.#tracer().startSpan("exception", {
+					kind: _opentelemetry_api.SpanKind.INTERNAL,
+					attributes,
+					startTime: new Date(signal.timestamp)
+				});
+				span.setAttributes(attributes);
+				span.recordException({
+					name: signal.exception.name,
+					message: signal.exception.message,
+					...signal.exception.stack ? { stack: signal.exception.stack } : {}
+				});
+				span.setStatus({
+					code: _opentelemetry_api.SpanStatusCode.ERROR,
+					message: signal.exception.message
+				});
+				if (!activeSpan) span.end(new Date(signal.timestamp));
+				return;
+			}
+			case "log":
+				if (Math.random() >= this.#logSampleRate) return;
+				_opentelemetry_api_logs.logs.getLogger(this.#instrumentationName, this.#instrumentationVersion).emit({
+					body: signal.message,
+					severityText: signal.level.toUpperCase(),
+					severityNumber: severityNumbers[signal.level],
+					attributes,
+					timestamp: new Date(signal.timestamp)
+				});
+				if (this.#structuredConsole) {
+					const activeTrace = currentTraceContext();
+					const record = JSON.stringify({
+						...attributes,
+						timestamp: signal.timestamp,
+						level: signal.level,
+						message: signal.message,
+						service_name: signal.resource.serviceName,
+						...signal.resource.serviceVersion ? { service_version: signal.resource.serviceVersion } : {},
+						...activeTrace ? {
+							trace_id: activeTrace.traceId,
+							span_id: activeTrace.spanId
+						} : {}
+					});
+					console[signal.level](record);
+				}
+				return;
+			case "measurement": {
+				if (this.#measurementMode === "spans" || this.#measurementMode === "both") this.#tracer().startSpan(`measurement:${signal.name}`, {
+					kind: _opentelemetry_api.SpanKind.INTERNAL,
+					attributes: {
+						...attributes,
+						"telemetry.measurement.value": signal.value,
+						...signal.unit ? { "telemetry.measurement.unit": signal.unit } : {}
+					},
+					startTime: new Date(signal.timestamp)
+				}).end(new Date(signal.timestamp));
+				if (this.#measurementMode === "spans") return;
+				if (!VALID_INSTRUMENT_NAME.test(signal.name)) return;
+				const key = `${signal.name}\u0000${signal.unit ?? ""}`;
+				let histogram = this.#histograms.get(key);
+				if (!histogram) {
+					if (this.#histograms.size >= this.#maxMetricInstruments) return;
+					histogram = _opentelemetry_api.metrics.getMeter(this.#instrumentationName, this.#instrumentationVersion).createHistogram(signal.name, { ...signal.unit ? { unit: signal.unit } : {} });
+					this.#histograms.set(key, histogram);
+				}
+				const metricAttributes = Object.fromEntries(Object.entries(signal.attributes).filter(([name]) => this.#metricAttributeAllowlist.has(name)));
+				histogram.record(signal.value, toOtelAttributes(metricAttributes));
+			}
+		}
+	}
+	startSpan(name, attributes = {}, options = {}) {
+		return new OpenTelemetrySpan(this.#tracer().startSpan((0, _davidilie_telemetry_core.redactText)(name, 256), {
+			kind: spanKinds[options.kind ?? "internal"],
+			attributes: {
+				...toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes)),
+				...telemetryResourceAttributes(this.#resource)
+			}
+		}));
+	}
+	currentTraceContext() {
+		return currentTraceContext();
+	}
+	async withActiveSpan(name, operation, attributes = {}, options = {}) {
+		let operationRan = false;
+		let operationSucceeded = false;
+		let operationResult;
+		let operationError;
+		try {
+			await this.#tracer().startActiveSpan((0, _davidilie_telemetry_core.redactText)(name, 256), {
+				kind: spanKinds[options.kind ?? "internal"],
+				attributes: {
+					...toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes)),
+					...telemetryResourceAttributes(this.#resource)
+				}
+			}, async (span) => {
+				operationRan = true;
+				try {
+					operationResult = await operation();
+					operationSucceeded = true;
+				} catch (error) {
+					operationError = error;
+					try {
+						span.recordException(exceptionForOtel(error));
+						span.setStatus({
+							code: _opentelemetry_api.SpanStatusCode.ERROR,
+							...error instanceof Error ? { message: (0, _davidilie_telemetry_core.redactText)(error.message) } : {}
+						});
+					} catch {}
+				} finally {
+					try {
+						span.end();
+					} catch {}
+				}
+			});
+		} catch (telemetryError) {
+			if (!operationRan) throw telemetryError;
+		}
+		if (operationSucceeded) return operationResult;
+		if (operationRan) throw operationError;
+		return operation();
+	}
+	async shutdown() {
+		await this.#shutdown?.();
+	}
+	#tracer() {
+		return _opentelemetry_api.trace.getTracer(this.#instrumentationName, this.#instrumentationVersion);
+	}
+};
+function createOpenTelemetryAdapter(config) {
+	return new OpenTelemetryAdapter(config);
+}
+function currentTraceContext() {
+	const spanContext = _opentelemetry_api.trace.getSpan(_opentelemetry_api.context.active())?.spanContext();
+	if (!spanContext) return void 0;
+	return {
+		traceId: spanContext.traceId,
+		spanId: spanContext.spanId,
+		traceFlags: spanContext.traceFlags
+	};
+}
+function startSpan(name, attributes = {}, options = {}) {
+	return new OpenTelemetrySpan(_opentelemetry_api.trace.getTracer("@davidilie/telemetry-node").startSpan((0, _davidilie_telemetry_core.redactText)(name, 256), {
+		kind: spanKinds[options.kind ?? "internal"],
+		attributes: toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes))
+	}));
+}
+async function withSpan(name, operation, attributes = {}, options = {}) {
+	return _opentelemetry_api.trace.getTracer("@davidilie/telemetry-node").startActiveSpan((0, _davidilie_telemetry_core.redactText)(name, 256), {
+		kind: spanKinds[options.kind ?? "internal"],
+		attributes: toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes))
+	}, async (span) => {
+		try {
+			return await operation();
+		} catch (error) {
+			try {
+				span.recordException(exceptionForOtel(error));
+				span.setStatus({
+					code: _opentelemetry_api.SpanStatusCode.ERROR,
+					...error instanceof Error ? { message: (0, _davidilie_telemetry_core.redactText)(error.message) } : {}
+				});
+			} catch {}
+			throw error;
+		} finally {
+			try {
+				span.end();
+			} catch {}
+		}
+	});
+}
+function recordException(error, attributes = {}) {
+	const activeSpan = _opentelemetry_api.trace.getActiveSpan();
+	const span = activeSpan ?? _opentelemetry_api.trace.getTracer("@davidilie/telemetry-node").startSpan("exception");
+	span.setAttributes(toOtelAttributes((0, _davidilie_telemetry_core.sanitizeAttributes)(attributes)));
+	span.recordException(exceptionForOtel(error));
+	span.setStatus({
+		code: _opentelemetry_api.SpanStatusCode.ERROR,
+		...error instanceof Error ? { message: (0, _davidilie_telemetry_core.redactText)(error.message) } : {}
+	});
+	if (!activeSpan) span.end();
+}
+//#endregion
+//#region src/client.ts
+var NodeTelemetryClient = class extends _davidilie_telemetry_core.TelemetryClient {
+	#adapter;
+	#sampleRate;
+	#onError;
+	#onCollectionStateChange;
+	#enabled;
+	#consent;
+	constructor(config) {
+		const adapter = new OpenTelemetryAdapter({
+			resource: config.resource,
+			...config.instrumentationName ? { instrumentationName: config.instrumentationName } : {},
+			...config.instrumentationVersion ? { instrumentationVersion: config.instrumentationVersion } : {},
+			...config.structuredConsole !== void 0 ? { structuredConsole: config.structuredConsole } : {},
+			...config.measurementMode ? { measurementMode: config.measurementMode } : {},
+			...config.metricAttributeAllowlist ? { metricAttributeAllowlist: config.metricAttributeAllowlist } : {},
+			...config.maxMetricInstruments !== void 0 ? { maxMetricInstruments: config.maxMetricInstruments } : {},
+			...config.providerManagedSampling ? { logSampleRate: config.sampleRate } : {},
+			...config.shutdown ? { shutdown: config.shutdown } : {}
+		});
+		super({
+			adapter,
+			resource: config.resource,
+			...config.beforeSend ? { beforeSend: config.beforeSend } : {},
+			...config.enabled !== void 0 ? { enabled: config.enabled } : {},
+			...config.sampleRate !== void 0 ? { sampleRate: config.providerManagedSampling ? 1 : config.sampleRate } : {},
+			...config.consent ? { consent: config.consent } : {},
+			...config.debug !== void 0 ? { debug: config.debug } : {},
+			...config.onError ? { onError: config.onError } : {}
+		});
+		this.#adapter = adapter;
+		this.#sampleRate = config.providerManagedSampling ? 1 : Number.isFinite(config.sampleRate) ? Math.min(1, Math.max(0, config.sampleRate ?? 1)) : 1;
+		this.#onError = config.onError;
+		this.#onCollectionStateChange = config.onCollectionStateChange;
+		this.#enabled = config.enabled ?? true;
+		this.#consent = config.consent ?? "granted";
+	}
+	setEnabled(enabled) {
+		this.#enabled = enabled;
+		super.setEnabled(enabled);
+		this.#onCollectionStateChange?.({
+			enabled: this.#enabled,
+			consent: this.#consent
+		});
+	}
+	setConsent(consent) {
+		this.#consent = consent;
+		super.setConsent(consent);
+		this.#onCollectionStateChange?.({
+			enabled: this.#enabled,
+			consent: this.#consent
+		});
+	}
+	async withSpan(name, operation, attributes = {}, options = {}) {
+		if (!this.#enabled || this.#consent !== "granted" || Math.random() >= this.#sampleRate) return operation();
+		let operationStarted = false;
+		try {
+			return await this.#adapter.withActiveSpan((0, _davidilie_telemetry_core.redactText)(name, 256), () => {
+				operationStarted = true;
+				return operation();
+			}, (0, _davidilie_telemetry_core.sanitizeAttributes)(attributes), options);
+		} catch (error) {
+			if (operationStarted) throw error;
+			this.#reportAdapterError(error, { operation: "startSpan" });
+			return operation();
+		}
+	}
+	#reportAdapterError(error, context) {
+		if (!this.#onError) return;
+		try {
+			Promise.resolve(this.#onError(error, context)).catch(() => void 0);
+		} catch {}
+	}
+};
+function createNodeTelemetry(config) {
+	return new NodeTelemetryClient(config);
+}
+//#endregion
+//#region src/sampler.ts
+/**
+* A mutable gate around an ordinary OpenTelemetry sampler.
+*
+* OpenTelemetry providers are registered once, but consent and operational
+* switches can change later. This wrapper drops every span—including children
+* of sampled remote parents—while collection is disabled, then delegates to
+* the configured sampler immediately after collection is re-enabled.
+*/
+var DynamicTelemetrySampler = class {
+	delegate;
+	#enabled;
+	#consent;
+	constructor(delegate, state) {
+		this.delegate = delegate;
+		this.#enabled = state.enabled;
+		this.#consent = state.consent;
+	}
+	setEnabled(enabled) {
+		this.#enabled = enabled;
+	}
+	setConsent(consent) {
+		this.#consent = consent;
+	}
+	shouldSample(parentContext, traceId, spanName, spanKind, attributes, links) {
+		if (!this.#enabled || this.#consent !== "granted") return { decision: _opentelemetry_sdk_trace_base.SamplingDecision.NOT_RECORD };
+		return this.delegate.shouldSample(parentContext, traceId, spanName, spanKind, attributes, links);
+	}
+	toString() {
+		return `DynamicTelemetrySampler{${this.delegate.toString()}}`;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "DynamicTelemetrySampler", {
+	enumerable: true,
+	get: function() {
+		return DynamicTelemetrySampler;
+	}
+});
+Object.defineProperty(exports, "NodeTelemetryClient", {
+	enumerable: true,
+	get: function() {
+		return NodeTelemetryClient;
+	}
+});
+Object.defineProperty(exports, "OpenTelemetryAdapter", {
+	enumerable: true,
+	get: function() {
+		return OpenTelemetryAdapter;
+	}
+});
+Object.defineProperty(exports, "OpenTelemetrySpan", {
+	enumerable: true,
+	get: function() {
+		return OpenTelemetrySpan;
+	}
+});
+Object.defineProperty(exports, "createNodeTelemetry", {
+	enumerable: true,
+	get: function() {
+		return createNodeTelemetry;
+	}
+});
+Object.defineProperty(exports, "createOpenTelemetryAdapter", {
+	enumerable: true,
+	get: function() {
+		return createOpenTelemetryAdapter;
+	}
+});
+Object.defineProperty(exports, "currentTraceContext", {
+	enumerable: true,
+	get: function() {
+		return currentTraceContext;
+	}
+});
+Object.defineProperty(exports, "recordException", {
+	enumerable: true,
+	get: function() {
+		return recordException;
+	}
+});
+Object.defineProperty(exports, "startSpan", {
+	enumerable: true,
+	get: function() {
+		return startSpan;
+	}
+});
+Object.defineProperty(exports, "telemetryResourceAttributes", {
+	enumerable: true,
+	get: function() {
+		return telemetryResourceAttributes;
+	}
+});
+Object.defineProperty(exports, "toOtelAttributeValue", {
+	enumerable: true,
+	get: function() {
+		return toOtelAttributeValue;
+	}
+});
+Object.defineProperty(exports, "toOtelAttributes", {
+	enumerable: true,
+	get: function() {
+		return toOtelAttributes;
+	}
+});
+Object.defineProperty(exports, "withSpan", {
+	enumerable: true,
+	get: function() {
+		return withSpan;
+	}
+});