@monocle.sh/studio 0.1.0

package/dist/repositories/span_repository.d.ts

@@ -0,0 +1,136 @@
+import { FlatSpan } from "../types/spans.js";
+
+//#region src/repositories/span_repository.d.ts
+/**
+ * Data-access layer for distributed trace spans stored in DuckDB.
+ * Provides queries for traces, jobs, commands, database queries,
+ * and exceptions.
+ */
+declare class SpanRepository {
+  #private;
+  /**
+   * Upserts a batch of flat spans into the spans table.
+   * Uses ON CONFLICT to update existing spans (same trace_id + span_id).
+   */
+  insertSpans(spans: FlatSpan[]): Promise<void>;
+  /**
+   * Returns all distinct service names that have emitted spans.
+   */
+  listServices(): Promise<string[]>;
+  /**
+   * Lists HTTP request root spans with their span counts,
+   * optionally filtered by trace ID or service name.
+   */
+  listTraces(options?: {
+    limit?: number;
+    offset?: number;
+    traceId?: string;
+    service?: string;
+  }): Promise<{
+    span_count: number;
+    trace_id: string;
+    span_name: string;
+    service_name: string | null;
+    status_code: string;
+    duration_ns: bigint;
+    start_time_unix: bigint;
+    span_attributes: string | null;
+  }[]>;
+  /**
+   * Lists background job root spans (messaging/queue consumers).
+   */
+  listJobs(options?: {
+    limit?: number;
+    offset?: number;
+    traceId?: string;
+  }): Promise<{
+    span_count: number;
+    trace_id: string;
+    span_name: string;
+    service_name: string | null;
+    status_code: string;
+    duration_ns: bigint;
+    start_time_unix: bigint;
+    span_attributes: string | null;
+  }[]>;
+  /**
+   * Lists CLI command root spans.
+   */
+  listCommands(options?: {
+    limit?: number;
+    offset?: number;
+    traceId?: string;
+  }): Promise<{
+    span_count: number;
+    trace_id: string;
+    span_name: string;
+    service_name: string | null;
+    status_code: string;
+    duration_ns: bigint;
+    start_time_unix: bigint;
+    span_attributes: string | null;
+  }[]>;
+  /**
+   * Lists database query spans, optionally filtered by DB system
+   * (postgresql, mysql, sqlite, etc.).
+   */
+  listQueries(options?: {
+    limit?: number;
+    offset?: number;
+    traceId?: string;
+    dbSystem?: string;
+  }): Promise<{
+    trace_id: string;
+    span_id: string;
+    span_name: string;
+    service_name: string | null;
+    status_code: string;
+    duration_ns: bigint;
+    start_time_unix: bigint;
+    span_attributes: string | null;
+  }[]>;
+  /**
+   * Lists exceptions extracted from span events by unnesting
+   * the JSON events array and filtering for "exception" events.
+   */
+  listExceptions(options?: {
+    limit?: number;
+    offset?: number;
+    traceId?: string;
+  }): Promise<{
+    trace_id: string;
+    span_id: string;
+    span_name: string;
+    service_name: string | null;
+    start_time_unix: bigint;
+    event_json: string;
+  }[]>;
+  /**
+   * Deletes all rows from the spans table.
+   */
+  clearAll(): Promise<void>;
+  /**
+   * Returns all spans belonging to a trace, ordered by start time,
+   * with parsed attributes and events.
+   */
+  getTraceSpans(traceId: string): Promise<{
+    trace_id: string;
+    span_id: string;
+    span_name: string;
+    service_name: string | null;
+    status_code: string;
+    duration_ns: bigint;
+    start_time_unix: bigint;
+    parent_span_id: string | null;
+    span_kind: string | null;
+    status_message: string | null;
+    end_time_unix: bigint;
+    span_attributes: string | null;
+    events: string | null;
+    resource_attributes: string | null;
+    scope_name: string | null;
+    scope_version: string | null;
+  }[]>;
+}
+//#endregion
+export { SpanRepository };

package/dist/repositories/span_repository.js

@@ -0,0 +1,254 @@
+import { getDb } from "../db/connection.js";
+import { Semconv } from "../semconv.js";
+import { sql } from "kysely";
+//#region src/repositories/span_repository.ts
+const S = Semconv.Stable;
+const L = Semconv.Legacy;
+/**
+* Data-access layer for distributed trace spans stored in DuckDB.
+* Provides queries for traces, jobs, commands, database queries,
+* and exceptions.
+*/
+var SpanRepository = class {
+	/**
+	* Serializes a value to JSON, returning null for falsy values.
+	*/
+	#jsonOrNull(value) {
+		if (!value) return null;
+		return JSON.stringify(value);
+	}
+	/**
+	* SQL expression: json_extract checking both stable and legacy keys via COALESCE.
+	*/
+	#sqlAttr(stable, legacy) {
+		return sql`COALESCE(
+      json_extract_string(span_attributes, ${`$."${stable}"`}),
+      json_extract_string(span_attributes, ${`$."${legacy}"`})
+    )`;
+	}
+	/**
+	* SQL expression: check if at least one of the two keys exists (IS NOT NULL).
+	*/
+	#sqlAttrExists(stable, legacy) {
+		return sql`(
+      json_extract_string(span_attributes, ${`$."${stable}"`}) IS NOT NULL
+      OR json_extract_string(span_attributes, ${`$."${legacy}"`}) IS NOT NULL
+    )`;
+	}
+	/**
+	* SQL condition: root span (no parent).
+	*/
+	#whereRootSpan() {
+		return sql`(parent_span_id IS NULL OR parent_span_id = '')`;
+	}
+	/**
+	* SQL condition: entry is an HTTP request (has http.request.method attribute).
+	*/
+	#whereHttpRequest() {
+		return this.#sqlAttrExists(S.HTTP_METHOD, L.HTTP_METHOD);
+	}
+	/**
+	* SQL condition: entry is a job (has entry_point.type = 'job' or messaging.system attribute).
+	*/
+	#whereJob() {
+		return sql`(
+      json_extract_string(span_attributes, '$."entry_point.type"') = 'job'
+      OR json_extract_string(span_attributes, '$."messaging.system"') IS NOT NULL
+    )`;
+	}
+	/**
+	* SQL condition: entry is a CLI command (has entry_point.type = 'cli').
+	*/
+	#whereCommand() {
+		return sql`json_extract_string(span_attributes, '$."entry_point.type"') = 'cli'`;
+	}
+	/**
+	* Upserts a batch of flat spans into the spans table.
+	* Uses ON CONFLICT to update existing spans (same trace_id + span_id).
+	*/
+	async insertSpans(spans) {
+		const db = getDb();
+		for (const span of spans) await db.insertInto("spans").values({
+			trace_id: span.traceId,
+			span_id: span.spanId,
+			parent_span_id: span.parentSpanId,
+			span_name: span.spanName,
+			span_kind: span.spanKind,
+			service_name: span.serviceName,
+			status_code: span.statusCode,
+			status_message: span.statusMessage,
+			start_time_unix: span.startTimeUnix,
+			end_time_unix: span.endTimeUnix,
+			duration_ns: span.durationNs,
+			resource_attributes: this.#jsonOrNull(span.resourceAttributes),
+			span_attributes: this.#jsonOrNull(span.spanAttributes),
+			scope_name: span.scopeName,
+			scope_version: span.scopeVersion,
+			events: this.#jsonOrNull(span.events)
+		}).onConflict((oc) => oc.columns(["trace_id", "span_id"]).doUpdateSet({
+			parent_span_id: span.parentSpanId,
+			span_name: span.spanName,
+			span_kind: span.spanKind,
+			service_name: span.serviceName,
+			status_code: span.statusCode,
+			status_message: span.statusMessage,
+			start_time_unix: span.startTimeUnix,
+			end_time_unix: span.endTimeUnix,
+			duration_ns: span.durationNs,
+			resource_attributes: this.#jsonOrNull(span.resourceAttributes),
+			span_attributes: this.#jsonOrNull(span.spanAttributes),
+			scope_name: span.scopeName,
+			scope_version: span.scopeVersion,
+			events: this.#jsonOrNull(span.events)
+		})).execute();
+	}
+	/**
+	* Returns all distinct service names that have emitted spans.
+	*/
+	async listServices() {
+		return (await getDb().selectFrom("spans").select("service_name").distinct().where("service_name", "is not", null).orderBy("service_name").execute()).map((r) => r.service_name).filter(Boolean);
+	}
+	/**
+	* Lists HTTP request root spans with their span counts,
+	* optionally filtered by trace ID or service name.
+	*/
+	async listTraces(options = {}) {
+		const db = getDb();
+		const limit = options.limit ?? 50;
+		const offset = options.offset ?? 0;
+		let rootSpansQuery = db.selectFrom("spans").select([
+			"trace_id",
+			"span_name",
+			"service_name",
+			"status_code",
+			"start_time_unix",
+			"duration_ns",
+			"span_attributes"
+		]).where(this.#whereRootSpan()).where(this.#whereHttpRequest()).orderBy("start_time_unix", "desc").limit(limit).offset(offset);
+		if (options.traceId) rootSpansQuery = rootSpansQuery.where("trace_id", "=", options.traceId);
+		if (options.service) rootSpansQuery = rootSpansQuery.where("service_name", "=", options.service);
+		return await db.with("root_spans", () => rootSpansQuery).with("span_counts", (qb) => qb.selectFrom("spans").select(["trace_id", sql`COUNT(*)`.as("span_count")]).where("trace_id", "in", (eb) => eb.selectFrom("root_spans").select("trace_id")).groupBy("trace_id")).selectFrom("root_spans as r").leftJoin("span_counts as c", "r.trace_id", "c.trace_id").select([
+			"r.trace_id",
+			"r.span_name",
+			"r.service_name",
+			"r.status_code",
+			"r.start_time_unix",
+			"r.duration_ns",
+			"r.span_attributes",
+			sql`COALESCE(c.span_count, 1)`.as("span_count")
+		]).orderBy("r.start_time_unix", "desc").execute();
+	}
+	/**
+	* Lists background job root spans (messaging/queue consumers).
+	*/
+	async listJobs(options = {}) {
+		const db = getDb();
+		const limit = options.limit ?? 50;
+		const offset = options.offset ?? 0;
+		let rootSpansQuery = db.selectFrom("spans").select([
+			"trace_id",
+			"span_name",
+			"service_name",
+			"status_code",
+			"start_time_unix",
+			"duration_ns",
+			"span_attributes"
+		]).where(this.#whereRootSpan()).where(this.#whereJob()).orderBy("start_time_unix", "desc").limit(limit).offset(offset);
+		if (options.traceId) rootSpansQuery = rootSpansQuery.where("trace_id", "=", options.traceId);
+		return await db.with("root_spans", () => rootSpansQuery).with("span_counts", (qb) => qb.selectFrom("spans").select(["trace_id", sql`COUNT(*)`.as("span_count")]).where("trace_id", "in", (eb) => eb.selectFrom("root_spans").select("trace_id")).groupBy("trace_id")).selectFrom("root_spans as r").leftJoin("span_counts as c", "r.trace_id", "c.trace_id").select([
+			"r.trace_id",
+			"r.span_name",
+			"r.service_name",
+			"r.status_code",
+			"r.start_time_unix",
+			"r.duration_ns",
+			"r.span_attributes",
+			sql`COALESCE(c.span_count, 1)`.as("span_count")
+		]).orderBy("r.start_time_unix", "desc").execute();
+	}
+	/**
+	* Lists CLI command root spans.
+	*/
+	async listCommands(options = {}) {
+		const db = getDb();
+		const limit = options.limit ?? 50;
+		const offset = options.offset ?? 0;
+		let rootSpansQuery = db.selectFrom("spans").select([
+			"trace_id",
+			"span_name",
+			"service_name",
+			"status_code",
+			"start_time_unix",
+			"duration_ns",
+			"span_attributes"
+		]).where(this.#whereRootSpan()).where(this.#whereCommand()).orderBy("start_time_unix", "desc").limit(limit).offset(offset);
+		if (options.traceId) rootSpansQuery = rootSpansQuery.where("trace_id", "=", options.traceId);
+		return await db.with("root_spans", () => rootSpansQuery).with("span_counts", (qb) => qb.selectFrom("spans").select(["trace_id", sql`COUNT(*)`.as("span_count")]).where("trace_id", "in", (eb) => eb.selectFrom("root_spans").select("trace_id")).groupBy("trace_id")).selectFrom("root_spans as r").leftJoin("span_counts as c", "r.trace_id", "c.trace_id").select([
+			"r.trace_id",
+			"r.span_name",
+			"r.service_name",
+			"r.status_code",
+			"r.start_time_unix",
+			"r.duration_ns",
+			"r.span_attributes",
+			sql`COALESCE(c.span_count, 1)`.as("span_count")
+		]).orderBy("r.start_time_unix", "desc").execute();
+	}
+	/**
+	* Lists database query spans, optionally filtered by DB system
+	* (postgresql, mysql, sqlite, etc.).
+	*/
+	async listQueries(options = {}) {
+		const db = getDb();
+		const limit = options.limit ?? 100;
+		const offset = options.offset ?? 0;
+		let query = db.selectFrom("spans").select([
+			"trace_id",
+			"span_id",
+			"span_name",
+			"service_name",
+			"status_code",
+			"start_time_unix",
+			"duration_ns",
+			"span_attributes"
+		]).where(this.#sqlAttrExists(S.DB_SYSTEM, L.DB_SYSTEM)).orderBy("start_time_unix", "desc").limit(limit).offset(offset);
+		if (options.traceId) query = query.where("trace_id", "=", options.traceId);
+		if (options.dbSystem) query = query.where(this.#sqlAttr(S.DB_SYSTEM, L.DB_SYSTEM), "=", options.dbSystem);
+		return await query.execute();
+	}
+	/**
+	* Lists exceptions extracted from span events by unnesting
+	* the JSON events array and filtering for "exception" events.
+	*/
+	async listExceptions(options = {}) {
+		const db = getDb();
+		const limit = options.limit ?? 100;
+		const offset = options.offset ?? 0;
+		let query = db.selectFrom(sql`spans s, unnest(from_json(s.events, '["JSON"]')) AS e(json)`).select([
+			sql`s.trace_id`.as("trace_id"),
+			sql`s.span_id`.as("span_id"),
+			sql`s.span_name`.as("span_name"),
+			sql`s.service_name`.as("service_name"),
+			sql`s.start_time_unix`.as("start_time_unix"),
+			sql`e.json`.as("event_json")
+		]).where(sql`s.events`, "is not", null).where(sql`json_extract_string(e.json, '$.name')`, "=", "exception").orderBy(sql`s.start_time_unix`, "desc").limit(limit).offset(offset);
+		if (options.traceId) query = query.where(sql`s.trace_id`, "=", options.traceId);
+		return await query.execute();
+	}
+	/**
+	* Deletes all rows from the spans table.
+	*/
+	async clearAll() {
+		const db = getDb();
+		await sql`DELETE FROM spans`.execute(db);
+	}
+	/**
+	* Returns all spans belonging to a trace, ordered by start time,
+	* with parsed attributes and events.
+	*/
+	async getTraceSpans(traceId) {
+		return getDb().selectFrom("spans").selectAll().where("trace_id", "=", traceId).orderBy("start_time_unix", "asc").execute();
+	}
+};
+//#endregion
+export { SpanRepository };

package/dist/semconv.d.ts

@@ -0,0 +1,38 @@
+//#region src/semconv.d.ts
+/**
+ * OpenTelemetry Semantic Convention attribute constants.
+ *
+ * Re-exports from `@opentelemetry/semantic-conventions` organized by
+ * stability level. The official package splits stable vs incubating,
+ * but conflates deprecated and experimental under "incubating".
+ * We explicitly separate **Stable** (current spec) from **Legacy**
+ * (deprecated, kept for old ClickHouse data reference).
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/http/http-spans/
+ * @see https://opentelemetry.io/docs/specs/semconv/database/database-spans/
+ */
+declare const Semconv: {
+  readonly Stable: {
+    readonly HTTP_METHOD: "http.request.method";
+    readonly HTTP_STATUS_CODE: "http.response.status_code";
+    readonly HTTP_ROUTE: "http.route";
+    readonly HTTP_TARGET: "url.path";
+    readonly DB_SYSTEM: "db.system.name";
+    readonly DB_OPERATION: "db.operation.name";
+    readonly DB_STATEMENT: "db.query.text";
+    readonly DB_TABLE: "db.collection.name";
+    readonly DB_NAMESPACE: "db.namespace";
+  };
+  readonly Legacy: {
+    readonly HTTP_METHOD: "http.method";
+    readonly HTTP_STATUS_CODE: "http.status_code";
+    readonly HTTP_TARGET: "http.target";
+    readonly DB_SYSTEM: "db.system";
+    readonly DB_OPERATION: "db.operation";
+    readonly DB_STATEMENT: "db.statement";
+    readonly DB_TABLE: "db.sql.table";
+    readonly DB_NAME: "db.name";
+  };
+};
+//#endregion
+export { Semconv };

package/dist/semconv.js

@@ -0,0 +1,40 @@
+import { ATTR_DB_COLLECTION_NAME, ATTR_DB_NAMESPACE, ATTR_DB_OPERATION_NAME, ATTR_DB_QUERY_TEXT, ATTR_DB_SYSTEM_NAME, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_URL_PATH } from "@opentelemetry/semantic-conventions";
+import { ATTR_DB_NAME, ATTR_DB_OPERATION, ATTR_DB_SQL_TABLE, ATTR_DB_STATEMENT, ATTR_DB_SYSTEM, ATTR_HTTP_METHOD, ATTR_HTTP_STATUS_CODE, ATTR_HTTP_TARGET } from "@opentelemetry/semantic-conventions/incubating";
+//#region src/semconv.ts
+/**
+* OpenTelemetry Semantic Convention attribute constants.
+*
+* Re-exports from `@opentelemetry/semantic-conventions` organized by
+* stability level. The official package splits stable vs incubating,
+* but conflates deprecated and experimental under "incubating".
+* We explicitly separate **Stable** (current spec) from **Legacy**
+* (deprecated, kept for old ClickHouse data reference).
+*
+* @see https://opentelemetry.io/docs/specs/semconv/http/http-spans/
+* @see https://opentelemetry.io/docs/specs/semconv/database/database-spans/
+*/
+const Semconv = {
+	Stable: {
+		HTTP_METHOD: ATTR_HTTP_REQUEST_METHOD,
+		HTTP_STATUS_CODE: ATTR_HTTP_RESPONSE_STATUS_CODE,
+		HTTP_ROUTE: ATTR_HTTP_ROUTE,
+		HTTP_TARGET: ATTR_URL_PATH,
+		DB_SYSTEM: ATTR_DB_SYSTEM_NAME,
+		DB_OPERATION: ATTR_DB_OPERATION_NAME,
+		DB_STATEMENT: ATTR_DB_QUERY_TEXT,
+		DB_TABLE: ATTR_DB_COLLECTION_NAME,
+		DB_NAMESPACE: ATTR_DB_NAMESPACE
+	},
+	Legacy: {
+		HTTP_METHOD: ATTR_HTTP_METHOD,
+		HTTP_STATUS_CODE: ATTR_HTTP_STATUS_CODE,
+		HTTP_TARGET: ATTR_HTTP_TARGET,
+		DB_SYSTEM: ATTR_DB_SYSTEM,
+		DB_OPERATION: ATTR_DB_OPERATION,
+		DB_STATEMENT: ATTR_DB_STATEMENT,
+		DB_TABLE: ATTR_DB_SQL_TABLE,
+		DB_NAME: ATTR_DB_NAME
+	}
+};
+//#endregion
+export { Semconv };

package/dist/server.d.ts

@@ -0,0 +1,16 @@
+//#region src/server.d.ts
+/**
+ * Configuration options for the local DevTools server.
+ */
+interface DevToolsOptions {
+  port?: number;
+  host?: string;
+  dbPath?: string;
+}
+/**
+ * Boots the AdonisJS-based DevTools HTTP server with DuckDB
+ * storage, OTLP ingestion, and the Studio UI.
+ */
+declare function startServer(options?: DevToolsOptions): Promise<void>;
+//#endregion
+export { DevToolsOptions, startServer };

package/dist/server.js

@@ -0,0 +1,68 @@
+import { closeConnection, initConnection } from "./db/connection.js";
+import { initializeSchema } from "./db/schema.js";
+import { Ignitor, prettyPrintError } from "@adonisjs/core";
+import { join } from "node:path";
+import "reflect-metadata";
+import { homedir } from "node:os";
+//#region src/server.ts
+function printStartupBanner(options) {
+	const dim = (s) => `\x1B[2m${s}\x1B[22m`;
+	const bold = (s) => `\x1B[1m${s}\x1B[22m`;
+	const cyan = (s) => `\x1B[36m${s}\x1B[39m`;
+	const green = (s) => `\x1B[32m${s}\x1B[39m`;
+	const local = `http://localhost:${options.port}`;
+	console.log();
+	console.log(`  ${cyan(bold("Monocle Studio"))} ${dim("v0.1.0")}`);
+	console.log(`  ${dim("Local observability for your app. Traces, logs, queries & more.")}`);
+	console.log();
+	console.log(`  ${green("➜")}  ${bold("Dashboard:")}  ${cyan(local)}`);
+	console.log(`  ${green("➜")}  ${bold("OTLP:")}       ${dim(`http://localhost:${options.port}/v1/traces`)}`);
+	console.log(`  ${green("➜")}  ${bold("Docs:")}       ${dim("https://docs.monocle.sh/studio/overview")}`);
+	console.log();
+}
+/**
+* Boots the AdonisJS-based DevTools HTTP server with DuckDB
+* storage, OTLP ingestion, and the Studio UI.
+*/
+async function startServer(options = {}) {
+	const port = options.port ?? 4200;
+	const host = options.host ?? "0.0.0.0";
+	const dbPath = options.dbPath ?? join(homedir(), ".config", "monocle", "studio.db");
+	const APP_ROOT = new URL("./", import.meta.url);
+	const IMPORTER = (filePath) => {
+		if (filePath.startsWith("./") || filePath.startsWith("../")) return import(new URL(filePath, APP_ROOT).href);
+		return import(filePath);
+	};
+	process.env.PORT = String(port);
+	process.env.HOST = host;
+	process.env.NODE_ENV = "development";
+	process.env.APP_KEY = process.env.APP_KEY || "devtools-local-key-not-used-for-security";
+	/**
+	* Force exit on CTRL+C. Close DuckDB first.
+	*/
+	process.on("SIGINT", async () => {
+		console.log(`\n  \x1B[2mShutting down...\x1B[22m`);
+		await closeConnection();
+		process.exit(0);
+	});
+	process.on("SIGTERM", async () => {
+		await closeConnection();
+		process.exit(0);
+	});
+	new Ignitor(APP_ROOT, { importer: IMPORTER }).tap((app) => {
+		app.booting(async () => {
+			await initializeSchema(await initConnection(dbPath));
+		});
+		app.ready(async () => {
+			printStartupBanner({
+				port,
+				host
+			});
+		});
+	}).httpServer().start().catch((error) => {
+		process.exitCode = 1;
+		prettyPrintError(error);
+	});
+}
+//#endregion
+export { startServer };

package/dist/services/event_bus.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from "node:events";
+
+//#region src/services/event_bus.d.ts
+interface DevToolsEvent {
+  type: 'traces' | 'logs';
+  count: number;
+}
+/**
+ * In-process event bus for broadcasting telemetry ingestion
+ * events to SSE subscribers in real time.
+ */
+declare class DevToolsEventBus extends EventEmitter {
+  /**
+   * Broadcasts a new ingestion event to all listeners.
+   */
+  emitIngested(event: DevToolsEvent): void;
+  /**
+   * Subscribes to ingestion events. Returns an unsubscribe function.
+   */
+  onIngested(callback: (event: DevToolsEvent) => void): () => this;
+}
+declare const eventBus: DevToolsEventBus;
+//#endregion
+export { DevToolsEvent, eventBus };

package/dist/services/event_bus.js

@@ -0,0 +1,24 @@
+import { EventEmitter } from "node:events";
+//#region src/services/event_bus.ts
+/**
+* In-process event bus for broadcasting telemetry ingestion
+* events to SSE subscribers in real time.
+*/
+var DevToolsEventBus = class extends EventEmitter {
+	/**
+	* Broadcasts a new ingestion event to all listeners.
+	*/
+	emitIngested(event) {
+		this.emit("ingested", event);
+	}
+	/**
+	* Subscribes to ingestion events. Returns an unsubscribe function.
+	*/
+	onIngested(callback) {
+		this.on("ingested", callback);
+		return () => this.off("ingested", callback);
+	}
+};
+const eventBus = new DevToolsEventBus();
+//#endregion
+export { eventBus };

package/dist/services/otlp_parser.d.ts

@@ -0,0 +1,21 @@
+import { FlatLog } from "../types/logs.js";
+import { FlatSpan } from "../types/spans.js";
+import { OtlpAttribute, OtlpLogRequest, OtlpTraceRequest } from "../types/otlp.js";
+
+//#region src/services/otlp_parser.d.ts
+/**
+ * Flattens an array of OTLP key-value attributes into a plain object.
+ */
+declare function flattenAttributes(attrs?: OtlpAttribute[]): Record<string, unknown>;
+/**
+ * Converts an OTLP trace export request into flat span models
+ * ready for DuckDB insertion.
+ */
+declare function parseTraceRequest(body: OtlpTraceRequest): FlatSpan[];
+/**
+ * Converts an OTLP log export request into flat log models
+ * ready for DuckDB insertion.
+ */
+declare function parseLogRequest(body: OtlpLogRequest): FlatLog[];
+//#endregion
+export { flattenAttributes, parseLogRequest, parseTraceRequest };