@monocle.sh/studio 0.1.0

package/dist/services/otlp_parser.js

@@ -0,0 +1,121 @@
+//#region src/services/otlp_parser.ts
+const SPAN_KIND_MAP = {
+	0: "UNSPECIFIED",
+	1: "INTERNAL",
+	2: "SERVER",
+	3: "CLIENT",
+	4: "PRODUCER",
+	5: "CONSUMER"
+};
+const STATUS_CODE_MAP = {
+	0: "UNSET",
+	1: "OK",
+	2: "ERROR"
+};
+/**
+* Recursively extracts a typed value from an OTLP AnyValue union.
+*/
+function extractValue(value) {
+	if (value.stringValue !== void 0) return value.stringValue;
+	if (value.intValue !== void 0) return Number(value.intValue);
+	if (value.doubleValue !== void 0) return value.doubleValue;
+	if (value.boolValue !== void 0) return value.boolValue;
+	if (value.arrayValue) return value.arrayValue.values.map(extractValue);
+	if (value.kvlistValue) return flattenAttributes(value.kvlistValue.values);
+	return null;
+}
+/**
+* Flattens an array of OTLP key-value attributes into a plain object.
+*/
+function flattenAttributes(attrs) {
+	if (!attrs?.length) return {};
+	const result = {};
+	for (const attr of attrs) result[attr.key] = extractValue(attr.value);
+	return result;
+}
+/**
+* Extracts the service.name from a resource's attribute list.
+*/
+function findServiceName(attrs) {
+	if (!attrs) return null;
+	return attrs.find((a) => a.key === "service.name")?.value?.stringValue ?? null;
+}
+/**
+* Converts an OTLP trace export request into flat span models
+* ready for DuckDB insertion.
+*/
+function parseTraceRequest(body) {
+	const spans = [];
+	for (const resourceSpan of body.resourceSpans ?? []) {
+		const resourceAttrs = flattenAttributes(resourceSpan.resource?.attributes);
+		const serviceName = findServiceName(resourceSpan.resource?.attributes);
+		for (const scopeSpan of resourceSpan.scopeSpans ?? []) {
+			const scopeName = scopeSpan.scope?.name ?? null;
+			const scopeVersion = scopeSpan.scope?.version ?? null;
+			for (const span of scopeSpan.spans ?? []) {
+				const startTimeUnix = BigInt(span.startTimeUnixNano);
+				const endTimeUnix = BigInt(span.endTimeUnixNano);
+				const events = span.events?.length ? span.events.map((e) => ({
+					name: e.name,
+					timeUnixNano: e.timeUnixNano ?? "0",
+					attributes: flattenAttributes(e.attributes)
+				})) : null;
+				spans.push({
+					traceId: span.traceId,
+					spanId: span.spanId,
+					parentSpanId: span.parentSpanId || null,
+					spanName: span.name,
+					spanKind: SPAN_KIND_MAP[span.kind ?? 0] ?? "UNSPECIFIED",
+					serviceName,
+					statusCode: STATUS_CODE_MAP[span.status?.code ?? 0] ?? "UNSET",
+					statusMessage: span.status?.message ?? null,
+					startTimeUnix,
+					endTimeUnix,
+					durationNs: endTimeUnix - startTimeUnix,
+					resourceAttributes: Object.keys(resourceAttrs).length ? resourceAttrs : null,
+					spanAttributes: span.attributes?.length ? flattenAttributes(span.attributes) : null,
+					scopeName,
+					scopeVersion,
+					events
+				});
+			}
+		}
+	}
+	return spans;
+}
+/**
+* Converts an OTLP log export request into flat log models
+* ready for DuckDB insertion.
+*/
+function parseLogRequest(body) {
+	const logs = [];
+	for (const resourceLog of body.resourceLogs ?? []) {
+		const resourceAttrs = flattenAttributes(resourceLog.resource?.attributes);
+		const serviceName = findServiceName(resourceLog.resource?.attributes);
+		for (const scopeLog of resourceLog.scopeLogs ?? []) {
+			const scopeName = scopeLog.scope?.name ?? null;
+			const scopeVersion = scopeLog.scope?.version ?? null;
+			for (const logRecord of scopeLog.logRecords ?? []) {
+				const timestamp = logRecord.timeUnixNano ?? logRecord.observedTimeUnixNano ?? "0";
+				let body = null;
+				if (logRecord.body) body = logRecord.body.stringValue ?? JSON.stringify(extractValue(logRecord.body));
+				logs.push({
+					timestampUnix: BigInt(timestamp),
+					traceId: logRecord.traceId || null,
+					spanId: logRecord.spanId || null,
+					severityText: logRecord.severityText ?? null,
+					severityNumber: logRecord.severityNumber ?? null,
+					serviceName,
+					body,
+					resourceAttributes: Object.keys(resourceAttrs).length ? resourceAttrs : null,
+					logAttributes: logRecord.attributes?.length ? flattenAttributes(logRecord.attributes) : null,
+					scopeName,
+					scopeVersion
+				});
+			}
+		}
+	}
+	return logs;
+}
+//#endregion
+export { flattenAttributes, parseLogRequest, parseTraceRequest };

package/dist/start/kernel.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/start/kernel.js

@@ -0,0 +1,5 @@
+import server from "@adonisjs/core/services/server";
+//#region src/start/kernel.ts
+server.use([() => import("@adonisjs/static/static_middleware")]);
+//#endregion
+export {};

package/dist/start/routes.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/start/routes.js

@@ -0,0 +1,35 @@
+import { createReadStream, existsSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import router from "@adonisjs/core/services/router";
+//#region src/start/routes.ts
+router.post("/v1/traces", [() => import("../controllers/otlp_controller.js"), "traces"]).as("otlp.traces");
+router.post("/v1/logs", [() => import("../controllers/otlp_controller.js"), "logs"]).as("otlp.logs");
+router.get("/api/services", [() => import("../controllers/api_controller.js"), "listServices"]).as("services.index");
+router.get("/api/traces", [() => import("../controllers/api_controller.js"), "listTraces"]).as("traces.index");
+router.get("/api/traces/:traceId", [() => import("../controllers/api_controller.js"), "getTrace"]).as("traces.show");
+router.get("/api/queries", [() => import("../controllers/api_controller.js"), "listQueries"]).as("queries.index");
+router.get("/api/exceptions", [() => import("../controllers/api_controller.js"), "listExceptions"]).as("exceptions.index");
+router.get("/api/jobs", [() => import("../controllers/api_controller.js"), "listJobs"]).as("jobs.index");
+router.get("/api/commands", [() => import("../controllers/api_controller.js"), "listCommands"]).as("commands.index");
+router.get("/api/logs", [() => import("../controllers/api_controller.js"), "listLogs"]).as("logs.index");
+router.delete("/api/data", [() => import("../controllers/api_controller.js"), "clearData"]).as("data.clear");
+router.get("/api/events", [() => import("../controllers/sse_controller.js"), "stream"]).as("events.stream");
+router.post("/mcp", [() => import("../controllers/mcp_controller.js"), "handle"]).as("mcp.handle");
+router.get("/mcp", [() => import("../controllers/mcp_controller.js"), "handle"]).as("mcp.stream");
+router.delete("/mcp", [() => import("../controllers/mcp_controller.js"), "handle"]).as("mcp.delete");
+/**
+* SPA fallback — serve index.html for all non-API routes.
+* Static assets (js, css, etc.) are handled by @adonisjs/static middleware.
+*/
+const uiDistPath = join(fileURLToPath(import.meta.url), "..", "..", "..", "ui", "dist");
+router.get("*", ({ request, response }) => {
+	const url = request.url();
+	if (url.startsWith("/v1/") || url.startsWith("/api/")) return response.notFound("Not found");
+	const indexPath = join(uiDistPath, "index.html");
+	if (!existsSync(indexPath)) return response.ok("<html><body style=\"background:#222;color:#fff;font-family:monospace;display:flex;align-items:center;justify-content:center;height:100vh\"><div style=\"text-align:center\"><h2>Monocle DevTools</h2><p>UI not built yet. Run: cd packages/devtools/ui && pnpm build</p></div></body></html>");
+	response.header("content-type", "text/html");
+	response.stream(createReadStream(indexPath));
+});
+//#endregion
+export {};

package/dist/transformers/command_transformer.d.ts

@@ -0,0 +1,18 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/command_transformer.d.ts
+declare class CommandTransformer extends BaseTransformer<Record<string, any>> {
+  toObject(): {
+    traceId: string;
+    rootSpanName: string;
+    serviceName: string;
+    commandName: string;
+    commandDescription: string;
+    statusCode: string;
+    durationMs: number;
+    startTime: string;
+    spanCount: number;
+  };
+}
+//#endregion
+export { CommandTransformer as default };

package/dist/transformers/command_transformer.js

@@ -0,0 +1,20 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/command_transformer.ts
+var CommandTransformer = class extends BaseTransformer {
+	toObject() {
+		const attrs = this.resource.span_attributes ? JSON.parse(this.resource.span_attributes) : {};
+		return {
+			traceId: this.resource.trace_id,
+			rootSpanName: this.resource.span_name,
+			serviceName: this.resource.service_name ?? null,
+			commandName: attrs["cli.command.name"] ?? this.resource.span_name,
+			commandDescription: attrs["cli.command.description"] ?? null,
+			statusCode: this.resource.status_code,
+			durationMs: Number(this.resource.duration_ns) / 1e6,
+			startTime: (/* @__PURE__ */ new Date(Number(this.resource.start_time_unix) / 1e6)).toISOString(),
+			spanCount: Number(this.resource.span_count ?? 0)
+		};
+	}
+};
+//#endregion
+export { CommandTransformer as default };

package/dist/transformers/exception_transformer.d.ts

@@ -0,0 +1,17 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/exception_transformer.d.ts
+declare class ExceptionTransformer extends BaseTransformer<Record<string, any>> {
+  toObject(): {
+    traceId: string;
+    spanId: string;
+    spanName: string;
+    serviceName: string;
+    exceptionType: string;
+    exceptionMessage: string;
+    exceptionStacktrace: string;
+    timestamp: string;
+  };
+}
+//#endregion
+export { ExceptionTransformer as default };

package/dist/transformers/exception_transformer.js

@@ -0,0 +1,19 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/exception_transformer.ts
+var ExceptionTransformer = class extends BaseTransformer {
+	toObject() {
+		const attrs = (typeof this.resource.event_json === "string" ? JSON.parse(this.resource.event_json) : this.resource.event_json).attributes ?? {};
+		return {
+			traceId: this.resource.trace_id,
+			spanId: this.resource.span_id,
+			spanName: this.resource.span_name,
+			serviceName: this.resource.service_name ?? null,
+			exceptionType: attrs["exception.type"] ?? null,
+			exceptionMessage: attrs["exception.message"] ?? null,
+			exceptionStacktrace: attrs["exception.stacktrace"] ?? null,
+			timestamp: (/* @__PURE__ */ new Date(Number(this.resource.start_time_unix) / 1e6)).toISOString()
+		};
+	}
+};
+//#endregion
+export { ExceptionTransformer as default };

package/dist/transformers/job_transformer.d.ts

@@ -0,0 +1,18 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/job_transformer.d.ts
+declare class JobTransformer extends BaseTransformer<Record<string, any>> {
+  toObject(): {
+    traceId: string;
+    rootSpanName: string;
+    serviceName: string;
+    jobName: string;
+    queueName: string | null;
+    statusCode: string;
+    durationMs: number;
+    startTime: string;
+    spanCount: number;
+  };
+}
+//#endregion
+export { JobTransformer as default };

package/dist/transformers/job_transformer.js

@@ -0,0 +1,20 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/job_transformer.ts
+var JobTransformer = class extends BaseTransformer {
+	toObject() {
+		const attrs = this.resource.span_attributes ? JSON.parse(this.resource.span_attributes) : {};
+		return {
+			traceId: this.resource.trace_id,
+			rootSpanName: this.resource.span_name,
+			serviceName: this.resource.service_name ?? null,
+			jobName: attrs["messaging.job.name"] ?? this.resource.span_name,
+			queueName: attrs["messaging.destination.name"] ?? attrs["messaging.destination"] ?? null,
+			statusCode: this.resource.status_code,
+			durationMs: Number(this.resource.duration_ns) / 1e6,
+			startTime: (/* @__PURE__ */ new Date(Number(this.resource.start_time_unix) / 1e6)).toISOString(),
+			spanCount: Number(this.resource.span_count ?? 0)
+		};
+	}
+};
+//#endregion
+export { JobTransformer as default };

package/dist/transformers/log_transformer.d.ts

@@ -0,0 +1,18 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/log_transformer.d.ts
+declare class LogTransformer extends BaseTransformer<Record<string, any>> {
+  toObject(): {
+    timestampUnix: string;
+    traceId: string | null;
+    spanId: string | null;
+    severityText: string;
+    severityNumber: number | null;
+    serviceName: string;
+    body: string;
+    attributes: any;
+    timestamp: string;
+  };
+}
+//#endregion
+export { LogTransformer as default };

package/dist/transformers/log_transformer.js

@@ -0,0 +1,19 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/log_transformer.ts
+var LogTransformer = class extends BaseTransformer {
+	toObject() {
+		return {
+			timestampUnix: String(this.resource.timestamp_unix),
+			traceId: this.resource.trace_id || null,
+			spanId: this.resource.span_id || null,
+			severityText: this.resource.severity_text ?? null,
+			severityNumber: this.resource.severity_number,
+			serviceName: this.resource.service_name ?? null,
+			body: this.resource.body ?? null,
+			attributes: this.resource.log_attributes ? JSON.parse(this.resource.log_attributes) : {},
+			timestamp: (/* @__PURE__ */ new Date(Number(this.resource.timestamp_unix) / 1e6)).toISOString()
+		};
+	}
+};
+//#endregion
+export { LogTransformer as default };

package/dist/transformers/query_transformer.d.ts

@@ -0,0 +1,20 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/query_transformer.d.ts
+declare class QueryTransformer extends BaseTransformer<Record<string, any>> {
+  #private;
+  toObject(): {
+    traceId: string;
+    spanId: string;
+    spanName: string;
+    serviceName: string;
+    statusCode: string;
+    dbSystem: string | null;
+    dbStatement: string | null;
+    dbOperation: string | null;
+    durationMs: number;
+    startTime: string;
+  };
+}
+//#endregion
+export { QueryTransformer as default };

package/dist/transformers/query_transformer.js

@@ -0,0 +1,27 @@
+import { Semconv } from "../semconv.js";
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/query_transformer.ts
+const S = Semconv.Stable;
+const L = Semconv.Legacy;
+var QueryTransformer = class extends BaseTransformer {
+	#attr(stable, legacy) {
+		const attrs = this.resource.span_attributes ? JSON.parse(this.resource.span_attributes) : {};
+		return attrs[stable] ?? attrs[legacy] ?? null;
+	}
+	toObject() {
+		return {
+			traceId: this.resource.trace_id,
+			spanId: this.resource.span_id,
+			spanName: this.resource.span_name,
+			serviceName: this.resource.service_name ?? null,
+			statusCode: this.resource.status_code,
+			dbSystem: this.#attr(S.DB_SYSTEM, L.DB_SYSTEM),
+			dbStatement: this.#attr(S.DB_STATEMENT, L.DB_STATEMENT),
+			dbOperation: this.#attr(S.DB_OPERATION, L.DB_OPERATION),
+			durationMs: Number(this.resource.duration_ns) / 1e6,
+			startTime: (/* @__PURE__ */ new Date(Number(this.resource.start_time_unix) / 1e6)).toISOString()
+		};
+	}
+};
+//#endregion
+export { QueryTransformer as default };

package/dist/transformers/span_transformer.d.ts

@@ -0,0 +1,22 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/span_transformer.d.ts
+declare class SpanTransformer extends BaseTransformer<Record<string, any>> {
+  toObject(): {
+    traceId: string;
+    spanId: string;
+    parentSpanId: string | null;
+    name: string;
+    kind: string;
+    serviceName: string;
+    statusCode: string;
+    statusMessage: string;
+    startTimeUnix: string;
+    endTimeUnix: string;
+    durationMs: number;
+    attributes: any;
+    events: any;
+  };
+}
+//#endregion
+export { SpanTransformer as default };

package/dist/transformers/span_transformer.js

@@ -0,0 +1,23 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/span_transformer.ts
+var SpanTransformer = class extends BaseTransformer {
+	toObject() {
+		return {
+			traceId: this.resource.trace_id,
+			spanId: this.resource.span_id,
+			parentSpanId: this.resource.parent_span_id || null,
+			name: this.resource.span_name,
+			kind: this.resource.span_kind ?? null,
+			serviceName: this.resource.service_name ?? null,
+			statusCode: this.resource.status_code,
+			statusMessage: this.resource.status_message ?? null,
+			startTimeUnix: String(this.resource.start_time_unix),
+			endTimeUnix: String(this.resource.end_time_unix),
+			durationMs: Number(this.resource.duration_ns) / 1e6,
+			attributes: this.resource.span_attributes ? JSON.parse(this.resource.span_attributes) : {},
+			events: this.resource.events ? JSON.parse(this.resource.events) : []
+		};
+	}
+};
+//#endregion
+export { SpanTransformer as default };

package/dist/transformers/trace_transformer.d.ts

@@ -0,0 +1,22 @@
+import { BaseTransformer } from "@adonisjs/core/transformers";
+
+//#region src/transformers/trace_transformer.d.ts
+declare class TraceTransformer extends BaseTransformer<Record<string, any>> {
+  #private;
+  toObject(): {
+    traceId: string;
+    rootSpanName: string;
+    serviceName: string;
+    method: string | null;
+    path: string | null;
+    route: string;
+    host: string | null;
+    statusCode: string;
+    httpStatus: number | null;
+    durationMs: number;
+    startTime: string;
+    spanCount: number;
+  };
+}
+//#endregion
+export { TraceTransformer as default };

package/dist/transformers/trace_transformer.js

@@ -0,0 +1,33 @@
+import { Semconv } from "../semconv.js";
+import { BaseTransformer } from "@adonisjs/core/transformers";
+//#region src/transformers/trace_transformer.ts
+const S = Semconv.Stable;
+const L = Semconv.Legacy;
+var TraceTransformer = class extends BaseTransformer {
+	#attr(stable, legacy) {
+		const attrs = this.#attrs();
+		return attrs[stable] ?? attrs[legacy] ?? null;
+	}
+	#attrs() {
+		return this.resource.span_attributes ? JSON.parse(this.resource.span_attributes) : {};
+	}
+	toObject() {
+		const attrs = this.#attrs();
+		return {
+			traceId: this.resource.trace_id,
+			rootSpanName: this.resource.span_name,
+			serviceName: this.resource.service_name ?? null,
+			method: this.#attr(S.HTTP_METHOD, L.HTTP_METHOD),
+			path: this.#attr(S.HTTP_TARGET, L.HTTP_TARGET),
+			route: attrs[S.HTTP_ROUTE] ?? null,
+			host: attrs["server.address"] ?? attrs["http.host"] ?? attrs["net.host.name"] ?? null,
+			statusCode: this.resource.status_code,
+			httpStatus: Number(this.#attr(S.HTTP_STATUS_CODE, L.HTTP_STATUS_CODE)) || null,
+			durationMs: Number(this.resource.duration_ns) / 1e6,
+			startTime: (/* @__PURE__ */ new Date(Number(this.resource.start_time_unix) / 1e6)).toISOString(),
+			spanCount: Number(this.resource.span_count ?? 0)
+		};
+	}
+};
+//#endregion
+export { TraceTransformer as default };

package/dist/types/logs.d.ts

@@ -0,0 +1,19 @@
+//#region src/types/logs.d.ts
+/**
+ * Internal flat log type for DuckDB storage.
+ */
+interface FlatLog {
+  timestampUnix: bigint;
+  traceId: string | null;
+  spanId: string | null;
+  severityText: string | null;
+  severityNumber: number | null;
+  serviceName: string | null;
+  body: string | null;
+  resourceAttributes: Record<string, unknown> | null;
+  logAttributes: Record<string, unknown> | null;
+  scopeName: string | null;
+  scopeVersion: string | null;
+}
+//#endregion
+export { FlatLog };

package/dist/types/logs.js

@@ -0,0 +1 @@
+export {};

package/dist/types/otlp.d.ts

@@ -0,0 +1,105 @@
+//#region src/types/otlp.d.ts
+/**
+ * OTLP JSON wire format types.
+ * Based on the OpenTelemetry Protocol specification.
+ */
+interface OtlpAnyValue {
+  stringValue?: string;
+  intValue?: string | number;
+  doubleValue?: number;
+  boolValue?: boolean;
+  arrayValue?: {
+    values: OtlpAnyValue[];
+  };
+  kvlistValue?: {
+    values: OtlpAttribute[];
+  };
+  bytesValue?: string;
+}
+interface OtlpAttribute {
+  key: string;
+  value: OtlpAnyValue;
+}
+interface OtlpResource {
+  attributes?: OtlpAttribute[];
+  droppedAttributesCount?: number;
+}
+interface OtlpInstrumentationScope {
+  name?: string;
+  version?: string;
+  attributes?: OtlpAttribute[];
+}
+interface OtlpSpanEvent {
+  timeUnixNano?: string;
+  name: string;
+  attributes?: OtlpAttribute[];
+  droppedAttributesCount?: number;
+}
+interface OtlpSpanLink {
+  traceId: string;
+  spanId: string;
+  traceState?: string;
+  attributes?: OtlpAttribute[];
+  droppedAttributesCount?: number;
+}
+interface OtlpSpanStatus {
+  code?: number;
+  message?: string;
+}
+interface OtlpSpan {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  traceState?: string;
+  name: string;
+  kind?: number;
+  startTimeUnixNano: string;
+  endTimeUnixNano: string;
+  attributes?: OtlpAttribute[];
+  droppedAttributesCount?: number;
+  events?: OtlpSpanEvent[];
+  droppedEventsCount?: number;
+  links?: OtlpSpanLink[];
+  droppedLinksCount?: number;
+  status?: OtlpSpanStatus;
+}
+interface OtlpScopeSpans {
+  scope?: OtlpInstrumentationScope;
+  spans: OtlpSpan[];
+  schemaUrl?: string;
+}
+interface OtlpResourceSpans {
+  resource?: OtlpResource;
+  scopeSpans: OtlpScopeSpans[];
+  schemaUrl?: string;
+}
+interface OtlpTraceRequest {
+  resourceSpans: OtlpResourceSpans[];
+}
+interface OtlpLogRecord {
+  timeUnixNano?: string;
+  observedTimeUnixNano?: string;
+  severityNumber?: number;
+  severityText?: string;
+  traceId?: string;
+  spanId?: string;
+  body?: OtlpAnyValue;
+  attributes?: OtlpAttribute[];
+  droppedAttributesCount?: number;
+  flags?: number;
+}
+interface OtlpScopeLogs {
+  scope?: OtlpInstrumentationScope;
+  logRecords: OtlpLogRecord[];
+  schemaUrl?: string;
+}
+interface OtlpResourceLogs {
+  resource?: OtlpResource;
+  scopeLogs: OtlpScopeLogs[];
+  schemaUrl?: string;
+}
+interface OtlpLogRequest {
+  resourceLogs: OtlpResourceLogs[];
+}
+//#endregion
+export { OtlpAnyValue, OtlpAttribute, OtlpInstrumentationScope, OtlpLogRecord, OtlpLogRequest, OtlpResource, OtlpResourceLogs, OtlpResourceSpans, OtlpScopeLogs, OtlpScopeSpans, OtlpSpan, OtlpSpanEvent, OtlpSpanLink, OtlpSpanStatus, OtlpTraceRequest };

package/dist/types/otlp.js

@@ -0,0 +1 @@
+export {};

package/dist/types/spans.d.ts

@@ -0,0 +1,29 @@
+//#region src/types/spans.d.ts
+/**
+ * Internal flat span type for DuckDB storage.
+ */
+interface FlatSpan {
+  traceId: string;
+  spanId: string;
+  parentSpanId: string | null;
+  spanName: string;
+  spanKind: string | null;
+  serviceName: string | null;
+  statusCode: string;
+  statusMessage: string | null;
+  startTimeUnix: bigint;
+  endTimeUnix: bigint;
+  durationNs: bigint;
+  resourceAttributes: Record<string, unknown> | null;
+  spanAttributes: Record<string, unknown> | null;
+  scopeName: string | null;
+  scopeVersion: string | null;
+  events: SpanEvent[] | null;
+}
+interface SpanEvent {
+  name: string;
+  timeUnixNano: string;
+  attributes: Record<string, unknown>;
+}
+//#endregion
+export { FlatSpan, SpanEvent };

package/dist/types/spans.js

@@ -0,0 +1 @@
+export {};