@telemetry-dev/otel 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { ROOT_CONTEXT, context, createContextKey } from "@opentelemetry/api";
+import { ROOT_CONTEXT, TraceFlags, context, createContextKey, diag as diag$1, isSpanContextValid, trace } from "@opentelemetry/api";
 import { AggregationTemporality, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { ExportResultCode } from "@opentelemetry/core";
+import { ExportResultCode, getNumberFromEnv, getStringFromEnv } from "@opentelemetry/core";
 import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { AlwaysOffSampler, AlwaysOnSampler, BatchSpanProcessor, ParentBasedSampler, SimpleSpanProcessor, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
 import { ProtobufLogsSerializer, ProtobufMetricsSerializer, ProtobufTraceSerializer } from "@opentelemetry/otlp-transformer";
 //#region src/attrs.ts
 const SCOPE_NAME = "@telemetry-dev/sdk";
@@ -301,6 +301,8 @@ var StampingSpanProcessor = class {
 //#endregion
 //#region src/transport.ts
 const RETRY_DELAYS_MS = [100, 500];
+const MAX_RETRY_AFTER_MS = 2e3;
+const MAX_TIMER_DELAY_MS = 2147483647;
 const RETRYABLE_STATUSES = new Set([
 	429,
 	502,
@@ -308,21 +310,105 @@ const RETRYABLE_STATUSES = new Set([
 	504
 ]);
 const isRetryableStatus = (status) => RETRYABLE_STATUSES.has(status);
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const HTTP_MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+const HTTP_WEEKDAYS = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+];
+const HTTP_WEEKDAYS_LONG = [
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+];
+const httpDateTimestamp = (weekday, dayText, monthText, yearText, hourText, minuteText, secondText, weekdays) => {
+	const day = Number(dayText);
+	const month = HTTP_MONTHS.indexOf(monthText);
+	const year = Number(yearText);
+	const hour = Number(hourText);
+	const minute = Number(minuteText);
+	const second = Number(secondText);
+	if (hour > 23 || minute > 59 || second > 59) return void 0;
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, month, day);
+	date.setUTCHours(hour, minute, second, 0);
+	if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day || weekdays[date.getUTCDay()] !== weekday) return;
+	return date.getTime();
+};
+const parseHttpDate = (value) => {
+	const imf = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{2}):(\d{2}):(\d{2}) GMT$/.exec(value);
+	if (imf) return httpDateTimestamp(...imf.slice(1), HTTP_WEEKDAYS);
+	const rfc850 = /^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{2}):(\d{2}):(\d{2}) GMT$/.exec(value);
+	if (rfc850) {
+		const fields = rfc850.slice(1);
+		const currentYear = (/* @__PURE__ */ new Date()).getUTCFullYear();
+		let year = Math.floor(currentYear / 100) * 100 + Number(fields[3]);
+		if (year > currentYear + 50) year -= 100;
+		fields[3] = String(year);
+		return httpDateTimestamp(...fields, HTTP_WEEKDAYS_LONG);
+	}
+	const asctime = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|[12]\d|3[01]) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/.exec(value);
+	if (!asctime) return void 0;
+	const [, weekday, month, day, hour, minute, second, year] = asctime;
+	return httpDateTimestamp(weekday, day.trim(), month, year, hour, minute, second, HTTP_WEEKDAYS);
+};
+const retryAfterMs = (res) => {
+	const header = res.headers.get("retry-after")?.trim();
+	if (header === void 0) return void 0;
+	if (/^\d+$/.test(header)) return Number(header) * 1e3;
+	const at = parseHttpDate(header);
+	return at === void 0 ? void 0 : Math.max(0, at - Date.now());
+};
+const delay = (ms, signal) => new Promise((resolve, reject) => {
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(signal?.reason ?? /* @__PURE__ */ new Error("telemetry.dev export aborted"));
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
+});
 const cancelBody = async (res) => {
 	try {
 		await res.body?.cancel();
 	} catch {}
 };
-const postOtlp = async ({ fetchImpl, url, headers, body }) => {
+const postOtlp = async ({ fetchImpl, url, headers, body, signal }) => {
 	for (let attempt = 0;; attempt += 1) {
+		let retryAfter;
 		try {
 			const res = await fetchImpl(url, {
 				method: "POST",
 				headers,
-				body
+				body,
+				signal
 			});
-			if (res.ok || !isRetryableStatus(res.status) || attempt === RETRY_DELAYS_MS.length) {
+			retryAfter = retryAfterMs(res);
+			if (res.ok || !isRetryableStatus(res.status) || attempt === RETRY_DELAYS_MS.length || retryAfter !== void 0 && retryAfter > MAX_RETRY_AFTER_MS) {
 				await cancelBody(res);
 				return res;
 			}
@@ -330,7 +416,7 @@ const postOtlp = async ({ fetchImpl, url, headers, body }) => {
 		} catch (error) {
 			if (attempt === RETRY_DELAYS_MS.length) throw error;
 		}
-		await delay(RETRY_DELAYS_MS[attempt]);
+		await delay(retryAfter ?? RETRY_DELAYS_MS[attempt], signal);
 	}
 };
 const GZIP_THRESHOLD_BYTES = 1024;
@@ -346,113 +432,133 @@ async function maybeGzip(body) {
 		return { body };
 	}
 }
+async function postSerialized(body, target, transport, label, post = postOtlp, signal) {
+	const { body: finalBody, contentEncoding } = await maybeGzip(body);
+	const headers = contentEncoding ? {
+		...target.headers,
+		"content-encoding": contentEncoding
+	} : target.headers;
+	const res = await post({
+		fetchImpl: transport.fetchImpl,
+		url: target.url,
+		headers,
+		body: finalBody,
+		signal
+	});
+	if (!res.ok) {
+		const retryAfter = retryAfterMs(res);
+		const retryAfterHeader = res.headers.get("retry-after")?.trim();
+		const retryDetail = retryAfter !== void 0 && retryAfter > MAX_RETRY_AFTER_MS && retryAfterHeader !== void 0 ? `; retry-after ${retryAfterHeader} exceeds ${MAX_RETRY_AFTER_MS / 1e3}s retry cap` : "";
+		throw new Error(`telemetry.dev ${label} ingest failed: ${res.status}${retryDetail}`);
+	}
+}
+const createExportLifecycle = (transport) => {
+	const inFlight = /* @__PURE__ */ new Set();
+	let shutDown = false;
+	const configuredTimeoutMillis = transport.exportTimeoutMillis ?? DEFAULT_BATCH.exportTimeoutMillis;
+	const timeoutMillis = Number.isFinite(configuredTimeoutMillis) && configuredTimeoutMillis >= 0 && configuredTimeoutMillis <= MAX_TIMER_DELAY_MS ? configuredTimeoutMillis : DEFAULT_BATCH.exportTimeoutMillis;
+	const callback = (resultCallback, result) => {
+		try {
+			resultCallback(result);
+		} catch (error) {
+			reportError(transport.onError, error);
+		}
+	};
+	const exportBatch = (send, resultCallback) => {
+		if (shutDown) {
+			const error = /* @__PURE__ */ new Error("telemetry.dev exporter is shut down");
+			callback(resultCallback, {
+				code: ExportResultCode.FAILED,
+				error
+			});
+			return;
+		}
+		const controller = new AbortController();
+		let timer;
+		const timeout = new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				controller.abort();
+				reject(/* @__PURE__ */ new Error(`telemetry.dev export timed out after ${timeoutMillis}ms`));
+			}, timeoutMillis);
+		});
+		let tracked;
+		tracked = Promise.race([Promise.resolve().then(() => send(controller.signal)), timeout]).then(() => callback(resultCallback, { code: ExportResultCode.SUCCESS }), (cause) => {
+			const error = cause instanceof Error ? cause : new Error(String(cause));
+			reportError(transport.onError, error);
+			callback(resultCallback, {
+				code: ExportResultCode.FAILED,
+				error
+			});
+		}).finally(() => {
+			clearTimeout(timer);
+			inFlight.delete(tracked);
+		});
+		inFlight.add(tracked);
+	};
+	const forceFlush = () => Promise.all(inFlight).then(() => void 0);
+	const shutdown = () => {
+		shutDown = true;
+		return forceFlush();
+	};
+	return {
+		exportBatch,
+		forceFlush,
+		shutdown
+	};
+};
 const MAX_BODY_BYTES = 35e5;
 function createOtlpBatchSender(serializer, target, transport, label) {
-	const send = async (items) => {
+	const send = async (items, signal) => {
 		const body = serializer.serializeRequest(items);
 		if (!body || body.byteLength === 0) return;
 		if (body.byteLength > MAX_BODY_BYTES) {
 			if (items.length > 1) {
 				const mid = Math.ceil(items.length / 2);
-				await send(items.slice(0, mid));
-				await send(items.slice(mid));
+				await send(items.slice(0, mid), signal);
+				await send(items.slice(mid), signal);
 				return;
 			}
 			reportError(transport.onError, /* @__PURE__ */ new Error(`telemetry.dev: ${label} record exceeds max export size, dropped`));
 			return;
 		}
-		const { body: finalBody, contentEncoding } = await maybeGzip(body);
-		const headers = contentEncoding ? {
-			...target.headers,
-			"content-encoding": contentEncoding
-		} : target.headers;
-		const res = await postOtlp({
-			fetchImpl: transport.fetchImpl,
-			url: target.url,
-			headers,
-			body: finalBody
-		});
-		if (!res.ok) throw new Error(`telemetry.dev ${label} ingest failed: ${res.status}`);
+		await postSerialized(body, target, transport, label, postOtlp, signal);
 	};
 	return send;
 }
 function createTraceExporter(target, transport) {
 	const send = createOtlpBatchSender(ProtobufTraceSerializer, target, transport, "trace");
+	const lifecycle = createExportLifecycle(transport);
 	return {
 		export(spans, resultCallback) {
-			send(spans).then(() => resultCallback({ code: ExportResultCode.SUCCESS }), (error) => {
-				reportError(transport.onError, error);
-				resultCallback({
-					code: ExportResultCode.FAILED,
-					error: error instanceof Error ? error : void 0
-				});
-			});
+			lifecycle.exportBatch((signal) => send(spans, signal), resultCallback);
 		},
-		forceFlush: () => Promise.resolve(),
-		shutdown: () => Promise.resolve()
+		forceFlush: lifecycle.forceFlush,
+		shutdown: lifecycle.shutdown
 	};
 }
 function createLogExporter(target, transport) {
 	const send = createOtlpBatchSender(ProtobufLogsSerializer, target, transport, "log");
+	const lifecycle = createExportLifecycle(transport);
 	return {
 		export(logs, resultCallback) {
-			send(logs).then(() => resultCallback({ code: ExportResultCode.SUCCESS }), (error) => {
-				reportError(transport.onError, error);
-				resultCallback({
-					code: ExportResultCode.FAILED,
-					error: error instanceof Error ? error : void 0
-				});
-			});
+			lifecycle.exportBatch((signal) => send(logs, signal), resultCallback);
 		},
-		forceFlush: () => Promise.resolve(),
-		shutdown: () => Promise.resolve()
+		forceFlush: lifecycle.forceFlush,
+		shutdown: lifecycle.shutdown
 	};
 }
 function createMetricExporter(target, transport) {
-	const { fetchImpl, onError } = transport;
+	const lifecycle = createExportLifecycle(transport);
 	return {
 		export(resourceMetrics, resultCallback) {
-			if (!resourceMetrics.scopeMetrics.some((scope) => scope.metrics.some((metric) => metric.dataPoints.length > 0))) {
-				resultCallback({ code: 0 });
-				return;
-			}
-			const body = ProtobufMetricsSerializer.serializeRequest(resourceMetrics);
-			if (!body || body.byteLength === 0) {
-				resultCallback({ code: 0 });
-				return;
-			}
-			maybeGzip(body).then(({ body: finalBody, contentEncoding }) => {
-				const headers = contentEncoding ? {
-					...target.headers,
-					"content-encoding": contentEncoding
-				} : target.headers;
-				return fetchImpl(target.url, {
-					method: "POST",
-					headers,
-					body: finalBody
-				});
-			}).then((res) => {
-				if (!res.ok) {
-					const error = /* @__PURE__ */ new Error(`telemetry.dev metric ingest failed: ${res.status}`);
-					reportError(onError, error);
-					resultCallback({
-						code: 1,
-						error
-					});
-					return;
-				}
-				resultCallback({ code: 0 });
-			}).catch((error) => {
-				reportError(onError, error);
-				resultCallback({
-					code: 1,
-					error: error instanceof Error ? error : void 0
-				});
-			});
+			lifecycle.exportBatch(async (signal) => {
+				const body = resourceMetrics.scopeMetrics.some((scope) => scope.metrics.some((metric) => metric.dataPoints.length > 0)) ? ProtobufMetricsSerializer.serializeRequest(resourceMetrics) : void 0;
+				if (body !== void 0 && body.byteLength > 0) await postSerialized(body, target, transport, "metric", postOtlp, signal);
+			}, resultCallback);
 		},
 		selectAggregationTemporality: () => AggregationTemporality.DELTA,
-		forceFlush: () => Promise.resolve(),
-		shutdown: () => Promise.resolve()
+		forceFlush: lifecycle.forceFlush,
+		shutdown: lifecycle.shutdown
 	};
 }
 function otlpHeaders(apiKey, sdkName = "@telemetry-dev/otel") {
@@ -478,7 +584,8 @@ var TelemetrySpanProcessor = class {
 		const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? "https://ingest.telemetry.dev").replace(/\/+$/, "");
 		const transport = {
 			fetchImpl: options.fetch ?? globalThis.fetch,
-			onError: options.onError
+			onError: options.onError,
+			exportTimeoutMillis: options.batch?.exportTimeoutMillis
 		};
 		const exporter = options.spanExporter ?? (apiKey ? createTraceExporter({
 			url: `${baseUrl}/v1/traces`,
@@ -547,8 +654,272 @@ function createTelemetrySpanExporter(options = {}) {
 		headers: otlpHeaders(apiKey)
 	}, {
 		fetchImpl: options.fetch ?? globalThis.fetch,
-		onError: options.onError
+		onError: options.onError,
+		exportTimeoutMillis: options.exportTimeoutMillis
 	});
 }
 //#endregion
-export { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, DURATION_BUCKETS, PROPAGATED_KEY, SCOPE_NAME, SCOPE_VERSION, StampingSpanProcessor, TOKEN_BUCKETS, TelemetrySpanProcessor, activeContext, als, buildPropagatedAttributes, createLogExporter, createMetricExporter, createMetricsPipeline, createTelemetrySpanExporter, createTraceExporter, diag, jsonAttr, maybeGzip, omitUndefined, otlpHeaders, postOtlp, propagateAttributes, propagatedFromContext, reportError, resolveEnv, setLogLevel, withContext };
+//#region src/session.ts
+const SESSION_PARENTS = /* @__PURE__ */ new WeakMap();
+/**
+* Install on the provider used with withSessionParent or sessionRootTracerProvider.
+* Pass the provider's configured sampler explicitly; OTel cannot read it back from a provider.
+* Without an argument, uses OTEL_TRACES_SAMPLER / OTEL_TRACES_SAMPLER_ARG defaults.
+*/
+function sessionSampler(inner = samplerFromEnv()) {
+	return {
+		shouldSample(ctx, traceId, name, kind, attributes, links) {
+			const parent = trace.getSpan(ctx);
+			const original = parent && SESSION_PARENTS.get(parent);
+			if (original) {
+				const span = trace.getSpan(original);
+				ctx = span ? trace.setSpan(ctx, span) : trace.deleteSpan(ctx);
+			}
+			return inner.shouldSample(ctx, traceId, name, kind, attributes, links);
+		},
+		toString: () => `SessionSampler{${inner.toString()}}`
+	};
+}
+function samplerFromEnv() {
+	const name = getStringFromEnv("OTEL_TRACES_SAMPLER") ?? "parentbased_always_on";
+	let root;
+	switch (name) {
+		case "always_off":
+		case "parentbased_always_off":
+			root = new AlwaysOffSampler();
+			break;
+		case "traceidratio":
+		case "parentbased_traceidratio": {
+			const ratio = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+			const valid = ratio !== void 0 && Number.isFinite(ratio) && ratio >= 0 && ratio <= 1;
+			if (!valid) diag$1.error("Invalid OTEL_TRACES_SAMPLER_ARG; using 1.");
+			root = new TraceIdRatioBasedSampler(valid ? ratio : 1);
+			break;
+		}
+		case "always_on":
+		case "parentbased_always_on":
+			root = new AlwaysOnSampler();
+			break;
+		default:
+			diag$1.error(`Invalid OTEL_TRACES_SAMPLER "${name}"; using parentbased_always_on.`);
+			return new ParentBasedSampler({ root: new AlwaysOnSampler() });
+	}
+	return name.startsWith("parentbased_") ? new ParentBasedSampler({ root }) : root;
+}
+/**
+* Deterministic remote parent for a session: every root span of the session joins one trace
+* (`traceId = SHA-256(apiKey ‖ 0x00 ‖ sessionId)[0:16]`, parent `spanId = digest[16:24]`).
+* The API key is part of the input so two projects with the same session id never share a trace
+* id. No span is ever emitted for the parent. Its flags are not a sampling decision:
+* use withSessionParent and install sessionSampler on the provider. Python mirrors these IDs.
+*/
+function sessionSpanContext(apiKey, sessionId) {
+	const digest = sha256(new TextEncoder().encode(`${apiKey ?? ""}\0${sessionId}`));
+	return {
+		traceId: hex(digest.subarray(0, 16)),
+		spanId: hex(digest.subarray(16, 24)),
+		traceFlags: TraceFlags.NONE,
+		isRemote: true
+	};
+}
+/**
+* Wraps a provider so that spans `sessionRootOf` recognizes are parented under the session
+* parent even when a parent is active. Frameworks that run each turn inside their own
+* engine span (eve's "workflow" scope) otherwise give every turn its own trace.
+* The inner provider MUST use sessionSampler(configuredSampler) to retain sampling policy.
+*/
+function sessionRootTracerProvider(inner, apiKey, sessionRootOf, onError) {
+	const reparent = (name, options, ctx) => {
+		if (!apiKey) return ctx;
+		try {
+			const sessionId = sessionRootOf(name, options?.attributes ?? {});
+			return sessionId ? setSessionParent(options?.root ? trace.deleteSpan(ctx) : ctx, sessionId, apiKey) : ctx;
+		} catch (error) {
+			reportError(onError, error);
+			return ctx;
+		}
+	};
+	return { getTracer(name, version, options) {
+		const tracer = inner.getTracer(name, version, options);
+		return {
+			startSpan: (spanName, spanOptions, ctx = context.active()) => {
+				const parent = reparent(spanName, spanOptions, ctx);
+				return tracer.startSpan(spanName, parent !== ctx && spanOptions?.root ? {
+					...spanOptions,
+					root: false
+				} : spanOptions, parent);
+			},
+			startActiveSpan(spanName, ...args) {
+				const fn = args.at(-1);
+				const spanOptions = args.length > 1 ? args[0] : void 0;
+				const ctx = args.length > 2 ? args[1] : context.active();
+				const parent = reparent(spanName, spanOptions, ctx);
+				return tracer.startActiveSpan(spanName, parent !== ctx && spanOptions?.root ? {
+					...spanOptions,
+					root: false
+				} : spanOptions ?? {}, parent, fn);
+			}
+		};
+	} };
+}
+/**
+* Parent a would-be root under the session; nested spans keep their real parent.
+* Requires sessionSampler(configuredSampler) on the provider that starts the span.
+*/
+function withSessionParent(ctx, sessionId, apiKey) {
+	if (!apiKey || !sessionId) return ctx;
+	const current = trace.getSpanContext(ctx);
+	if (current && isSpanContextValid(current)) return ctx;
+	return setSessionParent(ctx, sessionId, apiKey);
+}
+function setSessionParent(ctx, sessionId, apiKey) {
+	const parent = trace.wrapSpanContext({
+		...sessionSpanContext(apiKey, sessionId),
+		traceState: trace.getSpanContext(ctx)?.traceState
+	});
+	SESSION_PARENTS.set(parent, ctx);
+	return trace.setSpan(ctx, parent);
+}
+function sessionIdOf(ctx, attributes) {
+	const explicit = attributes?.["gen_ai.conversation.id"];
+	if (typeof explicit === "string") return explicit;
+	const propagated = propagatedFromContext(ctx)?.["gen_ai.conversation.id"];
+	return typeof propagated === "string" ? propagated : void 0;
+}
+function hex(bytes) {
+	let s = "";
+	for (const b of bytes) s += b.toString(16).padStart(2, "0");
+	return s;
+}
+const K = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const rotr = (x, n) => x >>> n | x << 32 - n;
+/** FIPS 180-4 SHA-256 in plain JS: the package must stay synchronous and runtime-neutral. */
+function sha256(bytes) {
+	const h = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const padded = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	const bitLen = bytes.length * 8;
+	view.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+	view.setUint32(padded.length - 4, bitLen >>> 0);
+	const w = new Uint32Array(64);
+	for (let off = 0; off < padded.length; off += 64) {
+		for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4);
+		for (let i = 16; i < 64; i++) {
+			const x = w[i - 15];
+			const y = w[i - 2];
+			const s0 = rotr(x, 7) ^ rotr(x, 18) ^ x >>> 3;
+			const s1 = rotr(y, 17) ^ rotr(y, 19) ^ y >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+		}
+		let a = h[0];
+		let b = h[1];
+		let c = h[2];
+		let d = h[3];
+		let e = h[4];
+		let f = h[5];
+		let g = h[6];
+		let hh = h[7];
+		for (let i = 0; i < 64; i++) {
+			const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[i] + w[i] >>> 0;
+			const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			hh = g;
+			g = f;
+			f = e;
+			e = d + t1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 >>> 0;
+		}
+		h[0] = h[0] + a >>> 0;
+		h[1] = h[1] + b >>> 0;
+		h[2] = h[2] + c >>> 0;
+		h[3] = h[3] + d >>> 0;
+		h[4] = h[4] + e >>> 0;
+		h[5] = h[5] + f >>> 0;
+		h[6] = h[6] + g >>> 0;
+		h[7] = h[7] + hh >>> 0;
+	}
+	const out = new Uint8Array(32);
+	const outView = new DataView(out.buffer);
+	for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i]);
+	return out;
+}
+//#endregion
+export { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, DURATION_BUCKETS, PROPAGATED_KEY, SCOPE_NAME, SCOPE_VERSION, StampingSpanProcessor, TOKEN_BUCKETS, TelemetrySpanProcessor, activeContext, als, buildPropagatedAttributes, createLogExporter, createMetricExporter, createMetricsPipeline, createTelemetrySpanExporter, createTraceExporter, diag, jsonAttr, maybeGzip, omitUndefined, otlpHeaders, postOtlp, propagateAttributes, propagatedFromContext, reportError, resolveEnv, sessionIdOf, sessionRootTracerProvider, sessionSampler, sessionSpanContext, setLogLevel, sha256, withContext, withSessionParent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telemetry-dev/otel",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Bring-your-own OpenTelemetry base layer for telemetry.dev: span processor and OTLP/protobuf trace exporter.",
   "keywords": [
     "genai",

package/src/config.ts

@@ -22,7 +22,7 @@ export const DEFAULT_BATCH: Required<BatchOptions> = {
   exportTimeoutMillis: 30000,
 };
 
-export function resolveEnv() {
+export function resolveEnv(): Record<string, string | undefined> {
   if (globalThis.process !== undefined && process.env) return process.env;
   return {};
 }

package/src/index.ts

@@ -34,6 +34,15 @@ export {
   type TelemetrySpanProcessorOptions,
 } from "./otel.ts";
 export { StampingSpanProcessor, type StampingProcessorOptions } from "./processor.ts";
+export {
+  sessionIdOf,
+  type SessionRootOf,
+  sessionRootTracerProvider,
+  sessionSampler,
+  sessionSpanContext,
+  sha256,
+  withSessionParent,
+} from "./session.ts";
 export {
   createLogExporter,
   createMetricExporter,

package/src/otel.ts

@@ -71,6 +71,7 @@ export class TelemetrySpanProcessor implements SpanProcessor {
     const transport: Transport = {
       fetchImpl: options.fetch ?? globalThis.fetch,
       onError: options.onError,
+      exportTimeoutMillis: options.batch?.exportTimeoutMillis,
     };
 
     const exporter =
@@ -143,6 +144,7 @@ export function createTelemetrySpanExporter(
     baseUrl?: string;
     fetch?: typeof fetch;
     onError?: (error: Error) => void;
+    exportTimeoutMillis?: number;
   } = {},
 ): SpanExporter {
   const env = resolveEnv();
@@ -161,6 +163,10 @@ export function createTelemetrySpanExporter(
   }
   return createTraceExporter(
     { url: `${baseUrl}/v1/traces`, headers: otlpHeaders(apiKey) },
-    { fetchImpl: options.fetch ?? globalThis.fetch, onError: options.onError },
+    {
+      fetchImpl: options.fetch ?? globalThis.fetch,
+      onError: options.onError,
+      exportTimeoutMillis: options.exportTimeoutMillis,
+    },
   );
 }