@rivetkit/traces 2.1.0-rc.1

package/src/otlp.ts

@@ -0,0 +1,158 @@
+import { decode as decodeCbor } from "cbor-x";
+
+export interface OtlpAnyValue {
+	stringValue?: string;
+	boolValue?: boolean;
+	intValue?: string;
+	doubleValue?: number;
+	bytesValue?: string;
+	arrayValue?: { values: OtlpAnyValue[] };
+	kvlistValue?: { values: OtlpKeyValue[] };
+}
+
+export interface OtlpKeyValue {
+	key: string;
+	value?: OtlpAnyValue;
+}
+
+export interface OtlpSpanStatus {
+	code: number;
+	message?: string;
+}
+
+export interface OtlpSpanEvent {
+	timeUnixNano: string;
+	name: string;
+	attributes?: OtlpKeyValue[];
+	droppedAttributesCount?: number;
+}
+
+export interface OtlpSpanLink {
+	traceId: string;
+	spanId: string;
+	traceState?: string;
+	attributes?: OtlpKeyValue[];
+	droppedAttributesCount?: number;
+}
+
+export interface OtlpSpan {
+	traceId: string;
+	spanId: string;
+	parentSpanId?: string;
+	name: string;
+	kind?: number;
+	startTimeUnixNano: string;
+	endTimeUnixNano?: string;
+	attributes?: OtlpKeyValue[];
+	droppedAttributesCount?: number;
+	events?: OtlpSpanEvent[];
+	droppedEventsCount?: number;
+	links?: OtlpSpanLink[];
+	droppedLinksCount?: number;
+	status?: OtlpSpanStatus;
+	traceState?: string;
+	flags?: number;
+}
+
+export interface OtlpInstrumentationScope {
+	name: string;
+	version?: string;
+	attributes?: OtlpKeyValue[];
+	droppedAttributesCount?: number;
+}
+
+export interface OtlpScopeSpans {
+	scope?: OtlpInstrumentationScope;
+	spans: OtlpSpan[];
+	schemaUrl?: string;
+}
+
+export interface OtlpResource {
+	attributes?: OtlpKeyValue[];
+	droppedAttributesCount?: number;
+}
+
+export interface OtlpResourceSpans {
+	resource?: OtlpResource;
+	scopeSpans: OtlpScopeSpans[];
+	schemaUrl?: string;
+}
+
+export interface OtlpExportTraceServiceRequestJson {
+	resourceSpans: OtlpResourceSpans[];
+}
+
+export function hexFromBytes(bytes: Uint8Array): string {
+	let out = "";
+	for (let i = 0; i < bytes.length; i++) {
+		out += bytes[i].toString(16).padStart(2, "0");
+	}
+	return out;
+}
+
+export function base64FromBytes(bytes: Uint8Array): string {
+	const bufferCtor = (globalThis as { Buffer?: { from: (data: Uint8Array) => { toString: (encoding: string) => string } } }).Buffer;
+	if (bufferCtor) {
+		return bufferCtor.from(bytes).toString("base64");
+	}
+	let binary = "";
+	for (let i = 0; i < bytes.length; i++) {
+		binary += String.fromCharCode(bytes[i]);
+	}
+	const btoaFn = (globalThis as { btoa?: (data: string) => string }).btoa;
+	if (!btoaFn) {
+		throw new Error("No base64 encoder available");
+	}
+	return btoaFn(binary);
+}
+
+export function anyValueFromCborBytes(bytes: Uint8Array): OtlpAnyValue {
+	const value = decodeCbor(bytes) as unknown;
+	return anyValueFromJs(value);
+}
+
+export function anyValueFromJs(value: unknown): OtlpAnyValue {
+	if (value === null || value === undefined) {
+		return { stringValue: "" };
+	}
+	if (typeof value === "string") {
+		return { stringValue: value };
+	}
+	if (typeof value === "boolean") {
+		return { boolValue: value };
+	}
+	if (typeof value === "number") {
+		if (Number.isFinite(value) && Number.isInteger(value)) {
+			return { intValue: value.toString() };
+		}
+		return { doubleValue: value };
+	}
+	if (typeof value === "bigint") {
+		return { intValue: value.toString() };
+	}
+	if (value instanceof Uint8Array) {
+		return { bytesValue: base64FromBytes(value) };
+	}
+	if (Array.isArray(value)) {
+		return { arrayValue: { values: value.map((v) => anyValueFromJs(v)) } };
+	}
+	if (value instanceof Map) {
+		const values: OtlpKeyValue[] = [];
+		for (const [key, mapValue] of value.entries()) {
+			if (typeof key !== "string") {
+				continue;
+			}
+			values.push({ key, value: anyValueFromJs(mapValue) });
+		}
+		return { kvlistValue: { values } };
+	}
+	if (typeof value === "object") {
+		const values: OtlpKeyValue[] = [];
+		for (const [key, objectValue] of Object.entries(value as object)) {
+			values.push({ key, value: anyValueFromJs(objectValue) });
+		}
+		return { kvlistValue: { values } };
+	}
+
+	return { stringValue: String(value) };
+}

package/src/read-range.ts

@@ -0,0 +1,502 @@
+import { decode as decodeCbor } from "cbor-x";
+import {
+	type Attributes,
+	type Chunk,
+	type ReadRangeWire,
+	type Record as TraceRecord,
+	type RecordBody,
+	type SpanId,
+	type SpanLink,
+	type SpanSnapshot,
+	type SpanStart,
+	type SpanStatus,
+	SpanStatusCode,
+	type TraceId,
+} from "../schemas/versioned.js";
+import {
+	anyValueFromJs,
+	hexFromBytes,
+	type OtlpExportTraceServiceRequestJson,
+	type OtlpKeyValue,
+	type OtlpResource,
+	type OtlpSpan,
+	type OtlpSpanEvent,
+	type OtlpSpanLink,
+	type OtlpSpanStatus,
+} from "./otlp.js";
+
+type AttributeMap = Map<string, unknown>;
+
+type LinkState = {
+	traceId: TraceId;
+	spanId: SpanId;
+	traceState: string | null;
+	attributes: AttributeMap;
+	droppedAttributesCount: number;
+};
+
+type SpanEventState = {
+	name: string;
+	timeUnixNs: bigint;
+	attributes: AttributeMap;
+	droppedAttributesCount: number;
+};
+
+type SpanBuilder = {
+	traceId: TraceId;
+	spanId: SpanId;
+	parentSpanId: SpanId | null;
+	name: string;
+	kind: number;
+	traceState: string | null;
+	flags: number;
+	attributes: AttributeMap;
+	droppedAttributesCount: number;
+	links: LinkState[];
+	droppedLinksCount: number;
+	status: SpanStatus | null;
+	startTimeUnixNs: bigint;
+	endTimeUnixNs: bigint | null;
+	events: SpanEventState[];
+};
+
+type RecordEntry = {
+	record: TraceRecord;
+	strings: readonly string[];
+	absNs: bigint;
+	sequence: number;
+};
+
+type BaseRecordEntry = {
+	record: TraceRecord;
+	strings: readonly string[];
+	absNs: bigint;
+};
+
+function toUint8Array(buffer: ArrayBuffer): Uint8Array {
+	return new Uint8Array(buffer);
+}
+
+function normalizeBytes(input: Uint8Array | ArrayBuffer): Uint8Array {
+	return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+
+function spanKey(spanId: Uint8Array | SpanId): string {
+	return hexFromBytes(normalizeBytes(spanId));
+}
+
+export function readRangeWireToOtlp(
+	wire: ReadRangeWire,
+	resource?: OtlpResource,
+): { otlp: OtlpExportTraceServiceRequestJson; clamped: boolean } {
+	const startMs =
+		typeof wire.startTimeMs === "bigint"
+			? wire.startTimeMs
+			: BigInt(Math.floor(wire.startTimeMs));
+	const endMs =
+		typeof wire.endTimeMs === "bigint"
+			? wire.endTimeMs
+			: BigInt(Math.floor(wire.endTimeMs));
+	const limit =
+		typeof wire.limit === "bigint" ? Number(wire.limit) : wire.limit;
+
+	if (limit <= 0 || endMs <= startMs) {
+		return { otlp: emptyExport(resource), clamped: wire.clamped };
+	}
+
+	const startNs = startMs * 1_000_000n;
+	const endNs = endMs * 1_000_000n;
+	const baseRecords = buildBaseRecordMap(wire.baseChunks);
+	const sequenceRef = { value: 0 };
+	const records: RecordEntry[] = [];
+	for (const chunk of wire.chunks) {
+		collectRecordEntries(records, chunk, startNs, endNs, sequenceRef);
+	}
+
+	records.sort((a, b) => {
+		if (a.absNs < b.absNs) return -1;
+		if (a.absNs > b.absNs) return 1;
+		return a.sequence - b.sequence;
+	});
+
+	const { spans, reachedSpanLimit } = buildSpansFromRecords(
+		records,
+		baseRecords,
+		limit,
+	);
+	const exported = spans.map(toOtlpSpan);
+	return {
+		otlp: buildExport(exported, resource),
+		clamped: wire.clamped || reachedSpanLimit,
+	};
+}
+
+function collectRecordEntries(
+	collector: RecordEntry[],
+	chunk: Chunk,
+	startNs: bigint,
+	endNs: bigint,
+	sequenceRef: { value: number },
+): void {
+	for (const record of chunk.records) {
+		const absNs = chunk.baseUnixNs + record.timeOffsetNs;
+		if (absNs < startNs || absNs >= endNs) {
+			continue;
+		}
+		collector.push({
+			record,
+			strings: chunk.strings,
+			absNs,
+			sequence: sequenceRef.value++,
+		});
+	}
+}
+
+function buildBaseRecordMap(
+	chunks: readonly Chunk[],
+): Map<string, BaseRecordEntry> {
+	const map = new Map<string, BaseRecordEntry>();
+	for (const chunk of chunks) {
+		for (const record of chunk.records) {
+			const absNs = chunk.baseUnixNs + record.timeOffsetNs;
+			map.set(spanKey(recordSpanId(record.body)), {
+				record,
+				strings: chunk.strings,
+				absNs,
+			});
+		}
+	}
+	return map;
+}
+
+function buildSpansFromRecords(
+	records: RecordEntry[],
+	baseRecords: Map<string, BaseRecordEntry>,
+	limit: number,
+): { spans: SpanBuilder[]; reachedSpanLimit: boolean } {
+	const spans = new Map<string, SpanBuilder>();
+	let reachedSpanLimit = false;
+
+	for (const entry of records) {
+		const body = entry.record.body;
+		const id = recordSpanId(body);
+		const key = spanKey(id);
+		let span = spans.get(key);
+		if (!span) {
+			if (spans.size >= limit) {
+				reachedSpanLimit = true;
+				continue;
+			}
+			const baseRecord = baseRecords.get(key);
+			if (baseRecord) {
+				span = initSpanFromBaseRecord(
+					baseRecord.record.body,
+					baseRecord.strings,
+					baseRecord.absNs,
+				);
+			}
+			if (!span) {
+				span = initSpanFromRecord(
+					body,
+					entry.absNs,
+					entry.strings,
+				);
+			}
+			if (!span) {
+				continue;
+			}
+			spans.set(key, span);
+		}
+		applyRecord(span, body, entry.absNs, entry.strings);
+	}
+
+	return { spans: Array.from(spans.values()), reachedSpanLimit };
+}
+
+function recordSpanId(body: RecordBody): SpanId {
+	switch (body.tag) {
+		case "SpanStart":
+			return body.val.spanId;
+		case "SpanEvent":
+			return body.val.spanId;
+		case "SpanUpdate":
+			return body.val.spanId;
+		case "SpanEnd":
+			return body.val.spanId;
+		case "SpanSnapshot":
+			return body.val.spanId;
+	}
+}
+
+function initSpanFromBaseRecord(
+	base: RecordBody,
+	strings: readonly string[],
+	absNs: bigint,
+): SpanBuilder | undefined {
+	switch (base.tag) {
+		case "SpanStart":
+			return initSpanFromStart(base.val, absNs, strings);
+		case "SpanSnapshot":
+			return initSpanFromSnapshot(base.val, strings);
+		default:
+			return undefined;
+	}
+}
+
+function initSpanFromRecord(
+	body: RecordBody,
+	absNs: bigint,
+	strings: readonly string[],
+): SpanBuilder | undefined {
+	switch (body.tag) {
+		case "SpanStart":
+			return initSpanFromStart(body.val, absNs, strings);
+		case "SpanSnapshot":
+			return initSpanFromSnapshot(body.val, strings);
+		default:
+			return undefined;
+	}
+}
+
+function initSpanFromStart(
+	start: SpanStart,
+	absNs: bigint | null,
+	strings: readonly string[],
+): SpanBuilder {
+	return {
+		traceId: start.traceId,
+		spanId: start.spanId,
+		parentSpanId: start.parentSpanId,
+		name: strings[start.name] ?? "",
+		kind: start.kind,
+		traceState: start.traceState,
+		flags: start.flags,
+		attributes: decodeAttributeList(start.attributes, strings),
+		droppedAttributesCount: start.droppedAttributesCount,
+		links: decodeLinks(start.links, strings),
+		droppedLinksCount: start.droppedLinksCount,
+		status: null,
+		startTimeUnixNs: absNs ?? 0n,
+		endTimeUnixNs: null,
+		events: [],
+	};
+}
+
+function initSpanFromSnapshot(
+	snapshot: SpanSnapshot,
+	strings: readonly string[],
+): SpanBuilder {
+	return {
+		traceId: snapshot.traceId,
+		spanId: snapshot.spanId,
+		parentSpanId: snapshot.parentSpanId,
+		name: strings[snapshot.name] ?? "",
+		kind: snapshot.kind,
+		traceState: snapshot.traceState,
+		flags: snapshot.flags,
+		attributes: decodeAttributeList(snapshot.attributes, strings),
+		droppedAttributesCount: snapshot.droppedAttributesCount,
+		links: decodeLinks(snapshot.links, strings),
+		droppedLinksCount: snapshot.droppedLinksCount,
+		status: snapshot.status,
+		startTimeUnixNs: snapshot.startTimeUnixNs,
+		endTimeUnixNs: null,
+		events: [],
+	};
+}
+
+function applyRecord(
+	span: SpanBuilder,
+	body: RecordBody,
+	absNs: bigint,
+	strings: readonly string[],
+): void {
+	switch (body.tag) {
+		case "SpanStart":
+			if (span.startTimeUnixNs === 0n) {
+				span.startTimeUnixNs = absNs;
+			}
+			return;
+		case "SpanSnapshot":
+			span.traceId = body.val.traceId;
+			span.parentSpanId = body.val.parentSpanId;
+			span.name = strings[body.val.name] ?? "";
+			span.kind = body.val.kind;
+			span.traceState = body.val.traceState;
+			span.flags = body.val.flags;
+			span.attributes = decodeAttributeList(
+				body.val.attributes,
+				strings,
+			);
+			span.droppedAttributesCount = body.val.droppedAttributesCount;
+			span.links = decodeLinks(body.val.links, strings);
+			span.droppedLinksCount = body.val.droppedLinksCount;
+			span.status = body.val.status;
+			span.startTimeUnixNs = body.val.startTimeUnixNs;
+			return;
+		case "SpanUpdate":
+			applyAttributes(span.attributes, body.val.attributes, strings);
+			span.droppedAttributesCount += body.val.droppedAttributesCount;
+			if (body.val.status) {
+				span.status = body.val.status;
+			}
+			return;
+		case "SpanEvent":
+			span.events.push({
+				name: strings[body.val.name] ?? "",
+				timeUnixNs: absNs,
+				attributes: decodeAttributeList(
+					body.val.attributes,
+					strings,
+				),
+				droppedAttributesCount: body.val.droppedAttributesCount,
+			});
+			return;
+		case "SpanEnd":
+			span.endTimeUnixNs = absNs;
+			if (body.val.status) {
+				span.status = body.val.status;
+			}
+			return;
+	}
+}
+
+function decodeAttributeList(
+	attributes: Attributes,
+	strings: readonly string[],
+): AttributeMap {
+	const map = new Map<string, unknown>();
+	for (const kv of attributes) {
+		const key = strings[kv.key] ?? "";
+		try {
+			map.set(key, decodeCbor(toUint8Array(kv.value)) as unknown);
+		} catch {
+			continue;
+		}
+	}
+	return map;
+}
+
+function applyAttributes(
+	map: AttributeMap,
+	attributes: Attributes,
+	strings: readonly string[],
+): void {
+	for (const kv of attributes) {
+		const key = strings[kv.key] ?? "";
+		try {
+			map.set(key, decodeCbor(toUint8Array(kv.value)) as unknown);
+		} catch {
+			continue;
+		}
+	}
+}
+
+function decodeLinks(
+	links: readonly SpanLink[],
+	strings: readonly string[],
+): LinkState[] {
+	return links.map((link) => ({
+		traceId: link.traceId,
+		spanId: link.spanId,
+		traceState: link.traceState,
+		attributes: decodeAttributeList(link.attributes, strings),
+		droppedAttributesCount: link.droppedAttributesCount,
+	}));
+}
+
+function toOtlpSpan(span: SpanBuilder): OtlpSpan {
+	const attributes = mapToOtlpAttributes(span.attributes);
+	const events = span.events.map((event) => toOtlpEvent(event));
+	const links = span.links.map((link) => toOtlpLink(link));
+	const status = span.status ? toOtlpStatus(span.status) : undefined;
+	return {
+		traceId: hexFromBytes(normalizeBytes(span.traceId)),
+		spanId: hexFromBytes(normalizeBytes(span.spanId)),
+		parentSpanId: span.parentSpanId
+			? hexFromBytes(normalizeBytes(span.parentSpanId))
+			: undefined,
+		name: span.name,
+		kind: span.kind,
+		traceState: span.traceState ?? undefined,
+		flags: span.flags || undefined,
+		startTimeUnixNano: span.startTimeUnixNs.toString(),
+		endTimeUnixNano: span.endTimeUnixNs
+			? span.endTimeUnixNs.toString()
+			: undefined,
+		attributes: attributes.length > 0 ? attributes : undefined,
+		droppedAttributesCount: span.droppedAttributesCount || undefined,
+		events: events.length > 0 ? events : undefined,
+		links: links.length > 0 ? links : undefined,
+		droppedLinksCount: span.droppedLinksCount || undefined,
+		status,
+	};
+}
+
+function toOtlpEvent(event: SpanEventState): OtlpSpanEvent {
+	const attributes = mapToOtlpAttributes(event.attributes);
+	return {
+		timeUnixNano: event.timeUnixNs.toString(),
+		name: event.name,
+		attributes: attributes.length > 0 ? attributes : undefined,
+		droppedAttributesCount: event.droppedAttributesCount || undefined,
+	};
+}
+
+function toOtlpLink(link: LinkState): OtlpSpanLink {
+	const attributes = mapToOtlpAttributes(link.attributes);
+	return {
+		traceId: hexFromBytes(normalizeBytes(link.traceId)),
+		spanId: hexFromBytes(normalizeBytes(link.spanId)),
+		traceState: link.traceState ?? undefined,
+		attributes: attributes.length > 0 ? attributes : undefined,
+		droppedAttributesCount: link.droppedAttributesCount || undefined,
+	};
+}
+
+function toOtlpStatus(status: SpanStatus): OtlpSpanStatus {
+	const code =
+		status.code === SpanStatusCode.OK
+			? 1
+			: status.code === SpanStatusCode.ERROR
+				? 2
+				: 0;
+	return {
+		code,
+		message: status.message ?? undefined,
+	};
+}
+
+function mapToOtlpAttributes(map: AttributeMap): OtlpKeyValue[] {
+	const list: OtlpKeyValue[] = [];
+	for (const [key, value] of map.entries()) {
+		if (value === undefined || typeof value === "function") {
+			continue;
+		}
+		if (typeof value === "symbol") {
+			continue;
+		}
+		list.push({ key, value: anyValueFromJs(value) });
+	}
+	return list;
+}
+
+function emptyExport(
+	resourceValue?: OtlpResource,
+): OtlpExportTraceServiceRequestJson {
+	return buildExport([], resourceValue);
+}
+
+function buildExport(
+	spans: OtlpSpan[],
+	resourceValue?: OtlpResource,
+): OtlpExportTraceServiceRequestJson {
+	return {
+		resourceSpans: [
+			{
+				resource: resourceValue,
+				scopeSpans: [{ spans }],
+			},
+		],
+	};
+}