@davidilie/telemetry-node 0.0.0-bootstrap.0

package/dist/sampler-fxBt_DLP.mjs

@@ -0,0 +1,436 @@
+import { SpanKind, SpanStatusCode, context, metrics, trace } from "@opentelemetry/api";
+import { SeverityNumber, logs } from "@opentelemetry/api-logs";
+import { TelemetryClient, redactText, sanitizeAttributes, sanitizeResource, sanitizeSignal } from "@davidilie/telemetry-core";
+import { SamplingDecision } from "@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: SeverityNumber.DEBUG,
+	info: SeverityNumber.INFO,
+	warn: SeverityNumber.WARN,
+	error: SeverityNumber.ERROR
+};
+function exceptionForOtel(error) {
+	if (error instanceof Error) {
+		const safe = new Error(redactText(error.message), { ...error.cause !== void 0 ? { cause: redactText(String(error.cause)) } : {} });
+		safe.name = redactText(error.name, 256);
+		if (error.stack) safe.stack = redactText(error.stack, 16384);
+		return safe;
+	}
+	return 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: SpanKind.INTERNAL,
+	server: SpanKind.SERVER,
+	client: SpanKind.CLIENT,
+	producer: SpanKind.PRODUCER,
+	consumer: SpanKind.CONSUMER
+};
+const spanStatuses = {
+	unset: SpanStatusCode.UNSET,
+	ok: SpanStatusCode.OK,
+	error: 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 = sanitizeAttributes({ [name]: value });
+		if (safe[name] !== void 0) this.#span.setAttribute(name, toOtelAttributeValue(safe[name]));
+		return this;
+	}
+	recordException(error, attributes = {}) {
+		this.#span.setAttributes(toOtelAttributes(sanitizeAttributes(attributes)));
+		this.#span.recordException(exceptionForOtel(error));
+		this.#span.setStatus({ code: SpanStatusCode.ERROR });
+	}
+	setStatus(status, message) {
+		this.#span.setStatus({
+			code: spanStatuses[status],
+			...message ? { message: 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 = 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 = sanitizeSignal(signal);
+		const attributes = signalAttributes(signal);
+		switch (signal.type) {
+			case "event": {
+				const activeSpan = trace.getActiveSpan();
+				if (activeSpan) {
+					activeSpan.addEvent(signal.name, attributes, new Date(signal.timestamp));
+					return;
+				}
+				const span = this.#tracer().startSpan(signal.name, {
+					kind: 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 = trace.getActiveSpan();
+				const span = activeSpan ?? this.#tracer().startSpan("exception", {
+					kind: 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: SpanStatusCode.ERROR,
+					message: signal.exception.message
+				});
+				if (!activeSpan) span.end(new Date(signal.timestamp));
+				return;
+			}
+			case "log":
+				if (Math.random() >= this.#logSampleRate) return;
+				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: 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 = 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(redactText(name, 256), {
+			kind: spanKinds[options.kind ?? "internal"],
+			attributes: {
+				...toOtelAttributes(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(redactText(name, 256), {
+				kind: spanKinds[options.kind ?? "internal"],
+				attributes: {
+					...toOtelAttributes(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: SpanStatusCode.ERROR,
+							...error instanceof Error ? { message: 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 trace.getTracer(this.#instrumentationName, this.#instrumentationVersion);
+	}
+};
+function createOpenTelemetryAdapter(config) {
+	return new OpenTelemetryAdapter(config);
+}
+function currentTraceContext() {
+	const spanContext = trace.getSpan(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(trace.getTracer("@davidilie/telemetry-node").startSpan(redactText(name, 256), {
+		kind: spanKinds[options.kind ?? "internal"],
+		attributes: toOtelAttributes(sanitizeAttributes(attributes))
+	}));
+}
+async function withSpan(name, operation, attributes = {}, options = {}) {
+	return trace.getTracer("@davidilie/telemetry-node").startActiveSpan(redactText(name, 256), {
+		kind: spanKinds[options.kind ?? "internal"],
+		attributes: toOtelAttributes(sanitizeAttributes(attributes))
+	}, async (span) => {
+		try {
+			return await operation();
+		} catch (error) {
+			try {
+				span.recordException(exceptionForOtel(error));
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					...error instanceof Error ? { message: redactText(error.message) } : {}
+				});
+			} catch {}
+			throw error;
+		} finally {
+			try {
+				span.end();
+			} catch {}
+		}
+	});
+}
+function recordException(error, attributes = {}) {
+	const activeSpan = trace.getActiveSpan();
+	const span = activeSpan ?? trace.getTracer("@davidilie/telemetry-node").startSpan("exception");
+	span.setAttributes(toOtelAttributes(sanitizeAttributes(attributes)));
+	span.recordException(exceptionForOtel(error));
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		...error instanceof Error ? { message: redactText(error.message) } : {}
+	});
+	if (!activeSpan) span.end();
+}
+//#endregion
+//#region src/client.ts
+var NodeTelemetryClient = class extends 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(redactText(name, 256), () => {
+				operationStarted = true;
+				return operation();
+			}, 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: SamplingDecision.NOT_RECORD };
+		return this.delegate.shouldSample(parentContext, traceId, spanName, spanKind, attributes, links);
+	}
+	toString() {
+		return `DynamicTelemetrySampler{${this.delegate.toString()}}`;
+	}
+};
+//#endregion
+export { OpenTelemetrySpan as a, recordException as c, telemetryResourceAttributes as d, toOtelAttributeValue as f, OpenTelemetryAdapter as i, startSpan as l, NodeTelemetryClient as n, createOpenTelemetryAdapter as o, toOtelAttributes as p, createNodeTelemetry as r, currentTraceContext as s, DynamicTelemetrySampler as t, withSpan as u };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@davidilie/telemetry-node",
+  "version": "0.0.0-bootstrap.0",
+  "description": "OpenTelemetry-backed telemetry for Node.js services.",
+  "keywords": [
+    "analytics",
+    "node",
+    "observability",
+    "opentelemetry",
+    "telemetry"
+  ],
+  "author": "David Ilie <david@davidilie.com> (https://davidilie.com)",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DavidIlie/davidapps-telemetry.git",
+    "directory": "packages/node"
+  },
+  "homepage": "https://github.com/DavidIlie/davidapps-telemetry#readme",
+  "bugs": {
+    "url": "https://github.com/DavidIlie/davidapps-telemetry/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "UPSTREAM.yml"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./register": {
+      "import": {
+        "types": "./dist/register.d.mts",
+        "default": "./dist/register.mjs"
+      },
+      "require": {
+        "types": "./dist/register.d.cts",
+        "default": "./dist/register.cjs"
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/register.ts --format esm,cjs --dts --tsconfig tsconfig.build.json",
+    "check": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist coverage"
+  },
+  "dependencies": {
+    "@davidilie/telemetry-core": "0.0.0-bootstrap.0",
+    "@opentelemetry/api-logs": "0.221.0",
+    "@opentelemetry/resources": "2.10.0",
+    "@opentelemetry/sdk-node": "0.221.0",
+    "@opentelemetry/sdk-trace-base": "2.10.0"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0 <2.0.0"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "1.9.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  }
+}