@monocle.sh/studio 0.1.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024-present, Julien Ripouteau
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/adonisrc.d.ts

@@ -0,0 +1,6 @@
+import * as _adonisjs_core_types_app0 from "@adonisjs/core/types/app";
+
+//#region src/adonisrc.d.ts
+declare const _default: _adonisjs_core_types_app0.RcFileInput;
+//#endregion
+export { _default as default };

package/dist/adonisrc.js

@@ -0,0 +1,25 @@
+import { indexEntities } from "@adonisjs/core";
+import { defineConfig } from "@adonisjs/core/app";
+import { generateRegistry } from "@tuyau/core/hooks";
+//#region src/adonisrc.ts
+var adonisrc_default = defineConfig({
+	directories: { public: "../ui/dist" },
+	providers: [
+		() => import("@adonisjs/core/providers/app_provider"),
+		() => import("@adonisjs/core/providers/vinejs_provider"),
+		() => import("@adonisjs/static/static_provider")
+	],
+	preloads: [
+		() => import("./providers/api_provider.js"),
+		() => import("./start/kernel.js"),
+		() => import("./start/routes.js")
+	],
+	hooks: { init: [indexEntities({ transformers: {
+		enabled: true,
+		source: "./src",
+		glob: ["transformers/*_transformer.ts"],
+		importAlias: "#app"
+	} }), generateRegistry()] }
+});
+//#endregion
+export { adonisrc_default as default };

package/dist/config/app.d.ts

@@ -0,0 +1,6 @@
+import * as _adonisjs_core_types_http0 from "@adonisjs/core/types/http";
+
+//#region src/config/app.d.ts
+declare const http: _adonisjs_core_types_http0.ServerConfig;
+//#endregion
+export { http };

package/dist/config/app.js

@@ -0,0 +1,5 @@
+import { defineConfig } from "@adonisjs/core/http";
+//#region src/config/app.ts
+const http = defineConfig({});
+//#endregion
+export { http };

package/dist/config/bodyparser.d.ts

@@ -0,0 +1,4 @@
+//#region src/config/bodyparser.d.ts
+declare const config: any;
+//#endregion
+export { config as default };

package/dist/config/bodyparser.js

@@ -0,0 +1,5 @@
+import { defineConfig } from "@adonisjs/core/bodyparser";
+//#region src/config/bodyparser.ts
+const config = defineConfig({ json: { limit: "10mb" } });
+//#endregion
+export { config as default };

package/dist/config/encryption.d.ts

@@ -0,0 +1,12 @@
+import * as _adonisjs_core_types_encryption0 from "@adonisjs/core/types/encryption";
+import * as _adonisjs_core_types0 from "@adonisjs/core/types";
+
+//#region src/config/encryption.d.ts
+declare const _default: _adonisjs_core_types0.ConfigProvider<{
+  default?: "app" | undefined;
+  list: {
+    app: _adonisjs_core_types_encryption0.EncryptionConfig;
+  };
+}>;
+//#endregion
+export { _default as default };

package/dist/config/encryption.js

@@ -0,0 +1,11 @@
+import { defineConfig, drivers } from "@adonisjs/core/encryption";
+//#region src/config/encryption.ts
+var encryption_default = defineConfig({
+	default: "app",
+	list: { app: drivers.aes256gcm({
+		id: "app",
+		keys: [process.env.APP_KEY]
+	}) }
+});
+//#endregion
+export { encryption_default as default };

package/dist/config/logger.d.ts

@@ -0,0 +1,4 @@
+//#region src/config/logger.d.ts
+declare const config: any;
+//#endregion
+export { config as default };

package/dist/config/logger.js

@@ -0,0 +1,13 @@
+import { defineConfig, targets } from "@adonisjs/core/logger";
+//#region src/config/logger.ts
+const config = defineConfig({
+	default: "app",
+	loggers: { app: {
+		enabled: true,
+		name: "monocle-devtools",
+		level: "info",
+		transport: { targets: targets().push(targets.pretty()).toArray() }
+	} }
+});
+//#endregion
+export { config as default };

package/dist/config/static.d.ts

@@ -0,0 +1,6 @@
+import * as _adonisjs_static_types0 from "@adonisjs/static/types";
+
+//#region src/config/static.d.ts
+declare const _default: _adonisjs_static_types0.AssetsConfig;
+//#endregion
+export { _default as default };

package/dist/config/static.js

@@ -0,0 +1,11 @@
+import { defineConfig } from "@adonisjs/static";
+//#region src/config/static.ts
+var static_default = defineConfig({
+	enabled: true,
+	immutable: true,
+	maxAge: "1y",
+	cacheControl: true,
+	etag: true
+});
+//#endregion
+export { static_default as default };

package/dist/controllers/api_controller.d.ts

@@ -0,0 +1,174 @@
+import { HttpContext } from "@adonisjs/core/http";
+//#region src/controllers/api_controller.d.ts
+/**
+ * HTTP API controller exposing telemetry data collected by the
+ * OTLP ingester. Serves paginated lists of traces, logs,
+ * exceptions, queries, jobs, and commands.
+ */
+declare class ApiController {
+  /**
+   * Returns all distinct service names that have emitted spans.
+   */
+  listServices({
+    response
+  }: HttpContext): Promise<{
+    __response: {
+      data: string[];
+    };
+    __status: 200;
+  }>;
+  /**
+   * Lists HTTP request traces with optional service and trace ID filters.
+   */
+  listTraces({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      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;
+    };
+  }>;
+  /**
+   * Returns the full span waterfall for a single trace.
+   */
+  getTrace({
+    params,
+    response,
+    serialize
+  }: HttpContext): Promise<{
+    __response: {
+      error: string;
+    };
+    __status: 404;
+  } | {
+    data: {
+      traceId: string;
+      serviceName: string;
+      statusCode: string;
+      durationMs: number;
+      spanId: string;
+      parentSpanId: string | null;
+      name: string;
+      kind: string;
+      statusMessage: string;
+      startTimeUnix: string;
+      endTimeUnix: string;
+      events?: any;
+      attributes?: any;
+    };
+  }>;
+  /**
+   * Lists exceptions extracted from span events.
+   */
+  listExceptions({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      traceId: string;
+      serviceName: string;
+      spanId: string;
+      spanName: string;
+      exceptionType: string;
+      exceptionMessage: string;
+      exceptionStacktrace: string;
+      timestamp: string;
+    };
+  }>;
+  /**
+   * Lists database query spans with optional DB system filter.
+   */
+  listQueries({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      traceId: string;
+      dbSystem: string | null;
+      serviceName: string;
+      statusCode: string;
+      durationMs: number;
+      startTime: string;
+      spanId: string;
+      spanName: string;
+      dbStatement: string | null;
+      dbOperation: string | null;
+    };
+  }>;
+  /**
+   * Lists background job traces.
+   */
+  listJobs({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      traceId: string;
+      rootSpanName: string;
+      serviceName: string;
+      statusCode: string;
+      durationMs: number;
+      startTime: string;
+      spanCount: number;
+      jobName: string;
+      queueName: string | null;
+    };
+  }>;
+  /**
+   * Lists CLI command traces.
+   */
+  listCommands({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      traceId: string;
+      rootSpanName: string;
+      serviceName: string;
+      statusCode: string;
+      durationMs: number;
+      startTime: string;
+      spanCount: number;
+      commandName: string;
+      commandDescription: string;
+    };
+  }>;
+  /**
+   * Clears all stored telemetry data.
+   */
+  clearData({}: HttpContext): Promise<{
+    success: boolean;
+  }>;
+  /**
+   * Lists application logs with severity, search, and trace filters.
+   */
+  listLogs({
+    request,
+    serialize
+  }: HttpContext): Promise<{
+    data: {
+      traceId: string | null;
+      body: string;
+      serviceName: string;
+      spanId: string | null;
+      timestamp: string;
+      timestampUnix: string;
+      severityText: string;
+      severityNumber: number | null;
+      attributes?: any;
+    };
+  }>;
+}
+//#endregion
+export { ApiController as default };

package/dist/controllers/api_controller.js

@@ -0,0 +1,118 @@
+import { SpanRepository } from "../repositories/span_repository.js";
+import SpanTransformer from "../transformers/span_transformer.js";
+import { LogRepository } from "../repositories/log_repository.js";
+import LogTransformer from "../transformers/log_transformer.js";
+import { listLogsValidator, listQueriesValidator, listTracesValidator, paginationValidator } from "../validators.js";
+import TraceTransformer from "../transformers/trace_transformer.js";
+import QueryTransformer from "../transformers/query_transformer.js";
+import ExceptionTransformer from "../transformers/exception_transformer.js";
+import JobTransformer from "../transformers/job_transformer.js";
+import CommandTransformer from "../transformers/command_transformer.js";
+import "@adonisjs/core/providers/vinejs_provider";
+//#region src/controllers/api_controller.ts
+const spanRepo = new SpanRepository();
+const logRepo = new LogRepository();
+/**
+* HTTP API controller exposing telemetry data collected by the
+* OTLP ingester. Serves paginated lists of traces, logs,
+* exceptions, queries, jobs, and commands.
+*/
+var ApiController = class {
+	/**
+	* Returns all distinct service names that have emitted spans.
+	*/
+	async listServices({ response }) {
+		const services = await spanRepo.listServices();
+		return response.ok({ data: services });
+	}
+	/**
+	* Lists HTTP request traces with optional service and trace ID filters.
+	*/
+	async listTraces({ request, serialize }) {
+		const { limit = 50, offset = 0, ...filters } = await request.validateUsing(listTracesValidator);
+		const rows = await spanRepo.listTraces({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(TraceTransformer.transform(rows)) };
+	}
+	/**
+	* Returns the full span waterfall for a single trace.
+	*/
+	async getTrace({ params, response, serialize }) {
+		const rows = await spanRepo.getTraceSpans(params.traceId);
+		if (!rows.length) return response.notFound({ error: "Trace not found" });
+		return { data: await serialize(SpanTransformer.transform(rows)) };
+	}
+	/**
+	* Lists exceptions extracted from span events.
+	*/
+	async listExceptions({ request, serialize }) {
+		const { limit = 100, offset = 0, ...filters } = await request.validateUsing(paginationValidator);
+		const rows = await spanRepo.listExceptions({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(ExceptionTransformer.transform(rows)) };
+	}
+	/**
+	* Lists database query spans with optional DB system filter.
+	*/
+	async listQueries({ request, serialize }) {
+		const { limit = 100, offset = 0, ...filters } = await request.validateUsing(listQueriesValidator);
+		const rows = await spanRepo.listQueries({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(QueryTransformer.transform(rows)) };
+	}
+	/**
+	* Lists background job traces.
+	*/
+	async listJobs({ request, serialize }) {
+		const { limit = 50, offset = 0, ...filters } = await request.validateUsing(paginationValidator);
+		const rows = await spanRepo.listJobs({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(JobTransformer.transform(rows)) };
+	}
+	/**
+	* Lists CLI command traces.
+	*/
+	async listCommands({ request, serialize }) {
+		const { limit = 50, offset = 0, ...filters } = await request.validateUsing(paginationValidator);
+		const rows = await spanRepo.listCommands({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(CommandTransformer.transform(rows)) };
+	}
+	/**
+	* Clears all stored telemetry data.
+	*/
+	async clearData({}) {
+		await spanRepo.clearAll();
+		await logRepo.clearAll();
+		return { success: true };
+	}
+	/**
+	* Lists application logs with severity, search, and trace filters.
+	*/
+	async listLogs({ request, serialize }) {
+		const { limit = 100, offset = 0, ...filters } = await request.validateUsing(listLogsValidator);
+		const rows = await logRepo.listLogs({
+			limit,
+			offset,
+			...filters
+		});
+		return { data: await serialize(LogTransformer.transform(rows)) };
+	}
+};
+//#endregion
+export { ApiController as default };

package/dist/controllers/mcp_controller.d.ts

@@ -0,0 +1,20 @@
+import { HttpContext } from "@adonisjs/core/http";
+
+//#region src/controllers/mcp_controller.d.ts
+/**
+ * Model Context Protocol controller. Creates a stateless MCP server
+ * per request with all registered tools, then handles the HTTP
+ * streaming transport handshake.
+ */
+declare class McpController {
+  /**
+   * Handles an incoming MCP HTTP request by spinning up a
+   * short-lived MCP server with all devtools tools registered.
+   */
+  handle({
+    request,
+    response
+  }: HttpContext): Promise<void>;
+}
+//#endregion
+export { McpController as default };

package/dist/controllers/mcp_controller.js

@@ -0,0 +1,29 @@
+import { registerAllTools } from "../mcp/tools/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+//#region src/controllers/mcp_controller.ts
+/**
+* Model Context Protocol controller. Creates a stateless MCP server
+* per request with all registered tools, then handles the HTTP
+* streaming transport handshake.
+*/
+var McpController = class {
+	/**
+	* Handles an incoming MCP HTTP request by spinning up a
+	* short-lived MCP server with all devtools tools registered.
+	*/
+	async handle({ request, response }) {
+		const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+		const server = new McpServer({
+			name: "monocle-devtools",
+			version: "0.1.0"
+		});
+		registerAllTools(server);
+		await server.connect(transport);
+		await transport.handleRequest(request.request, response.response);
+		await server.close();
+		if (!response.response.writableEnded) response.response.end();
+	}
+};
+//#endregion
+export { McpController as default };

package/dist/controllers/otlp_controller.d.ts

@@ -0,0 +1,52 @@
+import { HttpContext } from "@adonisjs/core/http";
+
+//#region src/controllers/otlp_controller.d.ts
+/**
+ * OTLP receiver controller. Accepts OpenTelemetry trace and log
+ * exports (JSON + optional gzip), parses them into flat models,
+ * persists to DuckDB, and emits real-time events via the EventBus.
+ */
+declare class OtlpController {
+  /**
+   * Ingests an OTLP trace export request.
+   */
+  traces({
+    request,
+    response
+  }: HttpContext): Promise<{
+    __response: {
+      partialSuccess: {
+        rejectedSpans: number;
+        errorMessage: string;
+      };
+    };
+    __status: 200;
+  } | {
+    __response: {
+      error: string;
+    };
+    __status: 400;
+  }>;
+  /**
+   * Ingests an OTLP log export request.
+   */
+  logs({
+    request,
+    response
+  }: HttpContext): Promise<{
+    __response: {
+      partialSuccess: {
+        rejectedLogRecords: number;
+        errorMessage: string;
+      };
+    };
+    __status: 200;
+  } | {
+    __response: {
+      error: string;
+    };
+    __status: 400;
+  }>;
+}
+//#endregion
+export { OtlpController as default };

package/dist/controllers/otlp_controller.js

@@ -0,0 +1,92 @@
+import { SpanRepository } from "../repositories/span_repository.js";
+import { LogRepository } from "../repositories/log_repository.js";
+import { eventBus } from "../services/event_bus.js";
+import { parseLogRequest, parseTraceRequest } from "../services/otlp_parser.js";
+import { gunzipSync } from "node:zlib";
+//#region src/controllers/otlp_controller.ts
+const spanRepo = new SpanRepository();
+const logRepo = new LogRepository();
+/**
+* Reads the full request body into a Buffer with a timeout
+* guard to prevent hung connections.
+*/
+function readRawBody(req, timeoutMs = 5e3) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const timer = setTimeout(() => {
+			req.destroy();
+			reject(/* @__PURE__ */ new Error("Body read timeout"));
+		}, timeoutMs);
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => {
+			clearTimeout(timer);
+			resolve(Buffer.concat(chunks));
+		});
+		req.on("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+/**
+* Reads and decompresses (gzip) an OTLP JSON request body.
+*/
+async function parseOtlpBody(ctx) {
+	const raw = await readRawBody(ctx.request.request);
+	if (!raw.length) return {};
+	const body = ctx.request.header("content-encoding") === "gzip" ? gunzipSync(raw) : raw;
+	return JSON.parse(body.toString("utf-8"));
+}
+/**
+* OTLP receiver controller. Accepts OpenTelemetry trace and log
+* exports (JSON + optional gzip), parses them into flat models,
+* persists to DuckDB, and emits real-time events via the EventBus.
+*/
+var OtlpController = class {
+	/**
+	* Ingests an OTLP trace export request.
+	*/
+	async traces({ request, response }) {
+		try {
+			const spans = parseTraceRequest(await parseOtlpBody({ request }));
+			if (spans.length) {
+				await spanRepo.insertSpans(spans);
+				eventBus.emitIngested({
+					type: "traces",
+					count: spans.length
+				});
+			}
+			return response.ok({ partialSuccess: {
+				rejectedSpans: 0,
+				errorMessage: ""
+			} });
+		} catch (error) {
+			console.error("[DevTools] Failed to ingest traces:", error);
+			return response.badRequest({ error: "Failed to parse OTLP traces" });
+		}
+	}
+	/**
+	* Ingests an OTLP log export request.
+	*/
+	async logs({ request, response }) {
+		try {
+			const logs = parseLogRequest(await parseOtlpBody({ request }));
+			if (logs.length) {
+				await logRepo.insertLogs(logs);
+				eventBus.emitIngested({
+					type: "logs",
+					count: logs.length
+				});
+			}
+			return response.ok({ partialSuccess: {
+				rejectedLogRecords: 0,
+				errorMessage: ""
+			} });
+		} catch (error) {
+			console.error("[DevTools] Failed to ingest logs:", error);
+			return response.badRequest({ error: "Failed to parse OTLP logs" });
+		}
+	}
+};
+//#endregion
+export { OtlpController as default };

package/dist/controllers/sse_controller.d.ts

@@ -0,0 +1,18 @@
+import { HttpContext } from "@adonisjs/core/http";
+
+//#region src/controllers/sse_controller.d.ts
+/**
+ * Server-Sent Events controller that streams real-time
+ * telemetry ingestion events to connected browser clients.
+ */
+declare class SseController {
+  /**
+   * Establishes a persistent SSE connection and forwards
+   * ingested trace/log events until the client disconnects.
+   */
+  stream({
+    response
+  }: HttpContext): Promise<void>;
+}
+//#endregion
+export { SseController as default };

package/dist/controllers/sse_controller.js

@@ -0,0 +1,36 @@
+import { eventBus } from "../services/event_bus.js";
+//#region src/controllers/sse_controller.ts
+/**
+* Server-Sent Events controller that streams real-time
+* telemetry ingestion events to connected browser clients.
+*/
+var SseController = class {
+	/**
+	* Establishes a persistent SSE connection and forwards
+	* ingested trace/log events until the client disconnects.
+	*/
+	async stream({ response }) {
+		const nodeRes = response.response;
+		nodeRes.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"Access-Control-Allow-Origin": "*"
+		});
+		nodeRes.write(": connected\n\n");
+		const onEvent = (event) => {
+			nodeRes.write(`event: ingested\ndata: ${JSON.stringify(event)}\n\n`);
+		};
+		const unsubscribe = eventBus.onIngested(onEvent);
+		/**
+		* Keep-alive every 30s to prevent connection timeout.
+		*/
+		const keepAlive = setInterval(() => nodeRes.write(": ping\n\n"), 3e4);
+		nodeRes.on("close", () => {
+			unsubscribe();
+			clearInterval(keepAlive);
+		});
+	}
+};
+//#endregion
+export { SseController as default };