@kitlangton/motel 0.2.5 → 0.2.6

package/src/services/TraceQueryService.ts

@@ -2,6 +2,10 @@ import { Effect, Layer, Context } from "effect"
 import type { AiCallDetail, SpanItem, TraceItem, TraceSummaryItem } from "../domain.js"
 import { TelemetryStore } from "./TelemetryStore.js"
 
+/**
+ * Compatibility adapter for consumers importing the historical trace query module.
+ * New internal callers should use TelemetryStoreReadonly directly.
+ */
 export class TraceQueryService extends Context.Service<
 	TraceQueryService,
 	{
@@ -22,56 +26,18 @@ export class TraceQueryService extends Context.Service<
 
 export const TraceQueryServiceLive = Layer.effect(
 	TraceQueryService,
-	Effect.gen(function* () {
-		const store = yield* TelemetryStore
-
-		const listServices = Effect.fn("motel/TraceQueryService.listServices")(function* () {
-			const services = yield* store.listServices
-			yield* Effect.annotateCurrentSpan("trace.service_count", services.length)
-			return services
-		})()
-
-		const listRecentTraces = Effect.fn("motel/TraceQueryService.listRecentTraces")(function* (serviceName: string, options?: { readonly lookbackMinutes?: number; readonly limit?: number; readonly cursorStartedAtMs?: number; readonly cursorTraceId?: string }) {
-			yield* Effect.annotateCurrentSpan({
-				"trace.service_name": serviceName,
-			})
-			const traces = yield* store.listRecentTraces(serviceName, options)
-			yield* Effect.annotateCurrentSpan("trace.result_count", traces.length)
-			return traces
-		})
-
-		const listTraceSummaries = Effect.fn("motel/TraceQueryService.listTraceSummaries")(function* (serviceName: string | null, options?: { readonly lookbackMinutes?: number; readonly limit?: number; readonly cursorStartedAtMs?: number; readonly cursorTraceId?: string }) {
-			yield* Effect.annotateCurrentSpan({
-				"trace.service_name": serviceName,
-			})
-			const traces = yield* store.listTraceSummaries(serviceName, options)
-			yield* Effect.annotateCurrentSpan("trace.result_count", traces.length)
-			return traces
-		})
-
-		const getTrace = Effect.fn("motel/TraceQueryService.getTrace")(function* (traceId: string) {
-			yield* Effect.annotateCurrentSpan("trace.trace_id", traceId)
-			return yield* store.getTrace(traceId)
-		})
-
-		const getSpan = Effect.fn("motel/TraceQueryService.getSpan")(function* (spanId: string) {
-			yield* Effect.annotateCurrentSpan("trace.span_id", spanId)
-			return yield* store.getSpan(spanId)
-		})
-
-		return TraceQueryService.of({
-			listServices,
-			listRecentTraces,
-			listTraceSummaries,
-			searchTraceSummaries: store.searchTraceSummaries,
-			listFacets: store.listFacets,
-			searchTraces: store.searchTraces,
-			traceStats: store.traceStats,
-			getTrace,
-			getSpan,
-			getAiCall: store.getAiCall,
-			listTraceSpans: store.listTraceSpans,
-			searchSpans: store.searchSpans,
-		})
-	}),
+	Effect.map(TelemetryStore, (store) => TraceQueryService.of({
+		listServices: store.listServices,
+		listRecentTraces: store.listRecentTraces,
+		listTraceSummaries: store.listTraceSummaries,
+		searchTraceSummaries: store.searchTraceSummaries,
+		listFacets: store.listFacets,
+		searchTraces: store.searchTraces,
+		traceStats: store.traceStats,
+		getTrace: store.getTrace,
+		getSpan: store.getSpan,
+		getAiCall: store.getAiCall,
+		listTraceSpans: store.listTraceSpans,
+		searchSpans: store.searchSpans,
+	})),
 )

package/src/services/ingestRpc.ts

@@ -5,10 +5,8 @@
  *
  * Only ingestTraces and ingestLogs run through RPC — those are the
  * methods whose SQLite writes used to block the main event loop for
- * seconds at a time. Every other TelemetryStore method stays on the
- * main thread with its own direct DB connection; SQLite's WAL mode
- * lets the reader (main) and writer (worker) hold independent
- * connections to the same file concurrently without contention.
+ * seconds at a time. Read-only TelemetryStore methods use the separate
+ * query RPC worker so no synchronous SQLite call runs on the HTTP thread.
  *
  * Payloads are typed as Schema.Unknown because OTLP's protobuf-JSON
  * shape is enormous and nested — the store validates structurally

package/src/services/queryRpc.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect"
+import * as Rpc from "effect/unstable/rpc/Rpc"
+import * as RpcGroup from "effect/unstable/rpc/RpcGroup"
+
+export class QueryError extends Schema.TaggedErrorClass<QueryError>()("QueryError", {
+	message: Schema.String,
+}) {}
+
+export const QueryRpcs = RpcGroup.make(
+	Rpc.make("query", {
+		payload: { method: Schema.String, args: Schema.Array(Schema.Unknown) },
+		success: Schema.Unknown,
+		error: QueryError,
+	}),
+)

package/src/services/telemetryQueryWorker.ts

@@ -0,0 +1,32 @@
+import { BunRuntime } from "@effect/platform-bun"
+import * as BunWorkerRunner from "@effect/platform-bun/BunWorkerRunner"
+import { Effect, Layer } from "effect"
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import * as RpcServer from "effect/unstable/rpc/RpcServer"
+import { TelemetryStoreQueryWorkerLive, TelemetryStoreReadonly, type TelemetryStoreReader } from "./TelemetryStore.js"
+import { QueryError, QueryRpcs } from "./queryRpc.js"
+
+type QueryMethod = keyof TelemetryStoreReader
+
+const QueryHandlers = QueryRpcs.toLayer(Effect.gen(function*() {
+	const store = yield* TelemetryStoreReadonly
+	return {
+		query: ({ method, args }) => {
+			const member = Reflect.get(store, method as QueryMethod) as unknown
+			const result = typeof member === "function" ? Reflect.apply(member, store, args) : member
+			return (result as Effect.Effect<unknown, Error>).pipe(
+				Effect.mapError((error) => new QueryError({ message: String(error) })),
+			)
+		},
+	}
+}))
+
+const WorkerLive = RpcServer.layer(QueryRpcs).pipe(
+	Layer.provide(QueryHandlers),
+	Layer.provide(TelemetryStoreQueryWorkerLive),
+	Layer.provide(RpcServer.layerProtocolWorkerRunner),
+	Layer.provide(RpcSerialization.layerMsgPack),
+	Layer.provide(BunWorkerRunner.layer),
+)
+
+Layer.launch(WorkerLive).pipe(BunRuntime.runMain)

package/src/services/telemetryWorker.ts

@@ -6,15 +6,12 @@
  * evaluated in a FRESH module graph on the worker side. In particular
  * `TelemetryStoreWorkerLive` opens its own SQLite connection here — the main
  * thread's store connection is unrelated. SQLite's WAL journal mode
- * lets both connections coexist against the same `.sqlite` file: the
- * worker writes, the main thread reads, and neither blocks the other.
+ * lets writer and query-worker connections coexist against the same
+ * `.sqlite` file without blocking the HTTP event loop.
  *
- * The worker only exposes `ingestTraces` / `ingestLogs` (see
- * ingestRpc.ts). Query methods stay on the main thread because they're
- * already fast (1-14ms) and round-tripping them through structured-
- * clone would add more overhead than it saves. This is a deliberately
- * narrow interface — the payoff is that main-thread HTTP queries
- * never queue behind a heavy OTLP batch again.
+ * The worker exposes only `ingestTraces` / `ingestLogs` (see ingestRpc.ts)
+ * and owns writer maintenance. Read queries run in telemetryQueryWorker.ts;
+ * neither path can block the HTTP event loop.
  */
 
 import { BunRuntime } from "@effect/platform-bun"

package/src/storybook/aiChatStory.tsx

@@ -18,7 +18,7 @@ import { useEffect, useMemo, useRef, useState } from "react"
 import { buildChunks, type Chunk } from "../ui/aiChatModel.ts"
 import { AiChatView } from "../ui/AiChatView.tsx"
 import { Divider, TextLine } from "../ui/primitives.tsx"
-import type { AiCallDetailState } from "../ui/state.ts"
+import type { AiCallDetailState } from "../ui/aiState.ts"
 import { applyTheme, colors, SEPARATOR } from "../ui/theme.ts"
 import type { ChatFixture } from "./fixtures/index.ts"
 import { errorFixture } from "./fixtures/errorState.ts"