@aryasaatvik/motel 0.3.5 → 0.4.0

package/src/services/telemetryQueryWorker.ts

@@ -1,32 +1,31 @@
 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 { Effect, Schema } from "effect"
 import { TelemetryStoreQueryWorkerLive, TelemetryStoreReadonly, type TelemetryStoreReader } from "./TelemetryStore.js"
-import { QueryError, QueryRpcs } from "./queryRpc.js"
+import { QueryRequest, type QueryReply } from "./queryRpc.js"
 
-type QueryMethod = keyof TelemetryStoreReader
+const send = (reply: QueryReply) => postMessage(reply)
 
-const QueryHandlers = QueryRpcs.toLayer(Effect.gen(function*() {
+// This thread owns only a readonly SQLite connection. Its enclosing process is
+// retired on query deadlines; the ingestion worker is never part of that process.
+Effect.scoped(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) })),
-			)
-		},
+	let busy = false
+	const receive = ({ data }: MessageEvent<unknown>) => {
+		const request = Schema.decodeUnknownSync(QueryRequest)(data)
+		if (!Object.hasOwn(store, request.method) || busy) {
+			send({ _tag: "error", id: request.id, message: "Invalid or concurrent query request" })
+			return
+		}
+		busy = true
+		const member = store[request.method as keyof TelemetryStoreReader]
+		const result = typeof member === "function" ? Reflect.apply(member, store, request.args) : member
+		void Effect.runPromise(result as Effect.Effect<unknown, Error>).then(
+			(value) => { busy = false; send({ _tag: "result", id: request.id, value }) },
+			(error) => { busy = false; send({ _tag: "error", id: request.id, 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)
+	addEventListener("message", receive)
+	yield* Effect.addFinalizer(() => Effect.sync(() => removeEventListener("message", receive)))
+	send({ _tag: "ready" })
+	return yield* Effect.never
+})).pipe(Effect.provide(TelemetryStoreQueryWorkerLive), BunRuntime.runMain)

package/src/services/telemetryWorker.ts

@@ -20,9 +20,14 @@ import { Effect, Layer } from "effect"
 import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
 import * as RpcServer from "effect/unstable/rpc/RpcServer"
 import type { OtlpLogExportRequest, OtlpTraceExportRequest } from "../otlp.ts"
+import { WriterDiagnostics, type WriterEvent } from "../ingestReadiness.ts"
 import { IngestError, IngestRpcs } from "./ingestRpc.ts"
 import { TelemetryStore, TelemetryStoreWorkerLive } from "./TelemetryStore.ts"
 
+const channelName = process.env.MOTEL_INGEST_DIAGNOSTICS_CHANNEL
+const channel = channelName ? new BroadcastChannel(channelName) : undefined
+const publish = (event: WriterEvent) => channel?.postMessage(event)
+
 // Wire the two RPC methods to the existing TelemetryStore service.
 // The store's ingest methods already carry their own Effect.fn spans,
 // so the worker-side traces show up correctly attributed — the RPC
@@ -32,13 +37,16 @@ import { TelemetryStore, TelemetryStoreWorkerLive } from "./TelemetryStore.ts"
 const IngestHandlers = IngestRpcs.toLayer(
 	Effect.gen(function*() {
 		const store = yield* TelemetryStore
+		publish({ _tag: "ready" })
 		return {
 			ingestTraces: ({ payload }) =>
 				store.ingestTraces(payload as OtlpTraceExportRequest).pipe(
+					Effect.tap((result) => Effect.sync(() => publish({ _tag: "commit", records: result.insertedSpans, at: Date.now() }))),
 					Effect.mapError((cause) => new IngestError({ message: String(cause) })),
 				),
 			ingestLogs: ({ payload }) =>
 				store.ingestLogs(payload as OtlpLogExportRequest).pipe(
+					Effect.tap((result) => Effect.sync(() => publish({ _tag: "commit", records: result.insertedLogs, at: Date.now() }))),
 					Effect.mapError((cause) => new IngestError({ message: String(cause) })),
 				),
 		}
@@ -56,4 +64,4 @@ const WorkerLive = RpcServer.layer(IngestRpcs).pipe(
 // BunRuntime.runMain installs signal handlers so the scope closes
 // cleanly on termination; the BunHttpServer layer pattern from the
 // main server carries over here.
-Layer.launch(WorkerLive).pipe(BunRuntime.runMain)
+Layer.launch(WorkerLive).pipe(Effect.provideService(WriterDiagnostics, publish), Effect.ensuring(Effect.sync(() => channel?.close())), BunRuntime.runMain)

package/src/telemetry.test.ts

@@ -326,6 +326,39 @@ describe("motel telemetry store", () => {
 		}
 	})
 
+	it("evicting traces stay hidden across public queries and reject late arrivals until cleanup completes", async () => {
+		const now = String(BigInt(Date.now()) * 1_000_000n)
+		const traceId = "eviction-visibility"
+		const trace = { resourceSpans: [{ resource: { attributes: [{ key: "service.name", value: { stringValue: "eviction-only" } }] }, scopeSpans: [{ spans: [{ traceId, spanId: "eviction-span", name: "ai.generateText", startTimeUnixNano: now, endTimeUnixNano: now }] }] }] }
+		const log = { resourceLogs: [{ resource: { attributes: [{ key: "service.name", value: { stringValue: "eviction-only" } }] }, scopeLogs: [{ logRecords: [{ traceId, spanId: "eviction-span", timeUnixNano: now, body: { stringValue: "hidden log" } }] }] }] }
+		await storeRuntime.runPromise(Effect.gen(function*() {
+			const store = yield* TelemetryStore
+			yield* store.ingestTraces(trace)
+			yield* store.ingestLogs(log)
+			const probe = new Database(dbPath)
+			try {
+				probe.query("INSERT INTO retention_traces VALUES (?)").run(traceId)
+				expect(yield* store.ingestTraces(trace)).toEqual({ insertedSpans: 0 })
+				expect(yield* store.ingestLogs(log)).toEqual({ insertedLogs: 0 })
+				expect(yield* store.searchSpans({ traceId })).toEqual([])
+				expect(yield* store.searchLogs({ traceId })).toEqual([])
+				expect(yield* store.searchTraces({ serviceName: "eviction-only" })).toEqual([])
+				expect(yield* store.searchAiCalls({ service: "eviction-only" })).toEqual([])
+				expect(yield* store.listServices).not.toContain("eviction-only")
+				expect(yield* store.getSpan("eviction-span")).toBeNull()
+				expect(yield* store.listFacets({ type: "traces", field: "service" })).not.toContainEqual({ value: "eviction-only", count: 1 })
+				yield* store.runRetentionNow
+				yield* store.runRetentionNow
+				expect(probe.query("SELECT 1 FROM retention_traces WHERE trace_id = ?").get(traceId)).toBeNull()
+				// Once deletion is complete, a later export can start a fresh trace as before.
+				expect(yield* store.ingestTraces(trace)).toEqual({ insertedSpans: 1 })
+				probe.query("INSERT INTO retention_traces VALUES (?)").run(traceId)
+				yield* store.runRetentionNow
+				yield* store.runRetentionNow
+			} finally { probe.close() }
+		}))
+	})
+
 	it("retention cleans orphan log indexes even when no logs are deleted", async () => {
 		const probe = new Database(dbPath)
 		try {
@@ -722,7 +755,7 @@ describe("motel telemetry store", () => {
 					WHERE severity_text = ? COLLATE NOCASE AND timestamp_ms >= ?
 					ORDER BY timestamp_ms DESC, id DESC LIMIT ?
 				`).all("INFO", 0, 80)
-				expect(plan.some((row) => row.detail.includes("idx_logs_severity_nocase_time (severity_text=?"))).toBe(true)
+				expect(plan.some((row) => row.detail.includes("idx_logs_severity_nocase_cursor (severity_text=?"))).toBe(true)
 			} finally {
 				probe.close()
 			}

package/src/ui/app/useTraceScreenData.ts

@@ -146,7 +146,6 @@ export const useTraceScreenData = () => {
 	}, [parsedFilter.aiText])
 
 	const selectedTraceRef = useRef<string | null>(null)
-	const cacheEpochRef = useRef(0)
 	const traceDetailCacheRef = useRef(new Map<string, { data: TraceItem | null; fetchedAt: Date }>())
 	const traceLogCacheRef = useRef(new Map<string, { data: readonly LogItem[]; fetchedAt: Date }>())
 	const serviceLogCacheRef = useRef(new Map<string, { data: readonly LogItem[]; fetchedAt: Date }>())
@@ -164,12 +163,9 @@ export const useTraceScreenData = () => {
 	}, [autoRefresh, setRefreshNonce])
 
 	useEffect(() => {
-		cacheEpochRef.current += 1
 		traceDetailCacheRef.current.clear()
 		traceLogCacheRef.current.clear()
 		serviceLogCacheRef.current.clear()
-		traceDetailInflightRef.current.clear()
-		traceLogInflightRef.current.clear()
 		invalidateAiCallDetailCache()
 	}, [refreshNonce])
 
@@ -181,13 +177,15 @@ export const useTraceScreenData = () => {
 	// actually opens the picker.
 	useEffect(() => {
 		if (!selectedTraceService) return
-		void ensureTraceAttributeKeys(selectedTraceService)
-			.then((entry) => Promise.allSettled(
-				entry.data
-					.slice(0, 6)
-					.map((row) => ensureTraceAttributeValues(selectedTraceService, row.value)),
-			))
-			.catch(() => {})
+		let cancelled = false
+		void (async () => {
+			const entry = await ensureTraceAttributeKeys(selectedTraceService)
+			for (const row of entry.data.slice(0, 2)) {
+				if (cancelled) return
+				await ensureTraceAttributeValues(selectedTraceService, row.value)
+			}
+		})().catch(() => {})
+		return () => { cancelled = true }
 	}, [selectedTraceService])
 
 	useEffect(() => {
@@ -278,10 +276,8 @@ export const useTraceScreenData = () => {
 			return existing
 		}
 
-		const epoch = cacheEpochRef.current
 		const request = loadTraceDetail(traceId)
 			.then((trace) => {
-				if (cacheEpochRef.current !== epoch) return { error: null }
 				const fetchedAt = new Date()
 				traceDetailCacheRef.current.set(traceId, { data: trace, fetchedAt })
 				if (hydrateSelection && selectedTraceRef.current === traceId) {
@@ -291,7 +287,7 @@ export const useTraceScreenData = () => {
 			})
 			.catch((error) => {
 				const message = error instanceof Error ? error.message : String(error)
-				if (cacheEpochRef.current === epoch && hydrateSelection && selectedTraceRef.current === traceId) {
+				if (hydrateSelection && selectedTraceRef.current === traceId) {
 					setTraceDetailState({ status: "error", traceId, data: null, error: message, fetchedAt: null })
 				}
 				return { error: message }
@@ -331,10 +327,8 @@ export const useTraceScreenData = () => {
 			return existing
 		}
 
-		const epoch = cacheEpochRef.current
 		const request = loadTraceLogs(traceId)
 			.then((logs) => {
-				if (cacheEpochRef.current !== epoch) return { error: null }
 				const fetchedAt = new Date()
 				traceLogCacheRef.current.set(traceId, { data: logs, fetchedAt })
 				if (hydrateSelection && selectedTraceRef.current === traceId) {
@@ -344,7 +338,7 @@ export const useTraceScreenData = () => {
 			})
 			.catch((error) => {
 				const message = error instanceof Error ? error.message : String(error)
-				if (cacheEpochRef.current === epoch && hydrateSelection && selectedTraceRef.current === traceId) {
+				if (hydrateSelection && selectedTraceRef.current === traceId) {
 					setLogState({ status: "error", traceId, data: [], error: message, fetchedAt: null })
 				}
 				return { error: message }

package/src/ui/cachedLoader.test.ts

@@ -21,3 +21,23 @@ describe("makeCachedLoader", () => {
 		expect(loader.get("key")).toBe(2)
 	})
 })
+
+it("refresh and invalidation coalesce an in-flight request without stale cleanup deleting its successor", async () => {
+	let resolve: (value: number) => void = () => {}
+	let loads = 0
+	const loader = makeCachedLoader<string, number>({ load: () => { loads++; return new Promise((done) => { resolve = done }) } })
+	const first = loader.ensure("key")
+	loader.invalidate()
+	expect(loader.refresh("key")).toBe(first)
+	expect(loader.ensure("key")).toBe(first)
+	expect(loads).toBe(1)
+	resolve(1)
+	expect(await first).toBe(1)
+	expect(loader.get("key")).toBe(1)
+	const second = loader.refresh("key")
+	expect(loads).toBe(2)
+	expect(loader.refresh("key")).toBe(second)
+	resolve(2)
+	await second
+	expect(loader.get("key")).toBe(2)
+})

package/src/ui/cachedLoader.ts

@@ -12,7 +12,7 @@ export interface CachedLoader<K, V> {
 	readonly ensure: (key: K) => Promise<V>
 	/** Loads the latest value while deduplicating any load already running for this key. */
 	readonly refresh: (key: K) => Promise<V>
-	/** Drops every cached value and aborts dedup tracking for in-flight loads. */
+	/** Drops cached values while preserving in-flight deduplication; refresh joins the current load. */
 	readonly invalidate: () => void
 }
 
@@ -53,7 +53,6 @@ export const makeCachedLoader = <K, V>(opts: CachedLoaderOptions<K, V>): CachedL
 
 	const invalidate = () => {
 		cache.clear()
-		inflight.clear()
 	}
 
 	return { get, ensure, refresh, invalidate }

package/src/ui/loaders.ts

@@ -4,11 +4,22 @@ import { queryRuntime } from "../runtime.ts"
 import { TelemetryStoreReadonly } from "../services/TelemetryStore.ts"
 import { makeCachedLoader } from "./cachedLoader.ts"
 
+// Refreshes join matching in-flight work; settled results are not retained here.
+const pendingLoads = new Map<string, Promise<unknown>>()
+const query = <A>(key: readonly unknown[], effect: Effect.Effect<A, Error, TelemetryStoreReadonly>): Promise<A> => {
+	const hash = JSON.stringify(key)
+	const existing = pendingLoads.get(hash)
+	if (existing) return existing as Promise<A>
+	const request = queryRuntime.runPromise(effect).finally(() => pendingLoads.delete(hash))
+	pendingLoads.set(hash, request)
+	return request
+}
+
 export const loadTraceServices = () =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.listServices))
+	query(["services"], Effect.flatMap(TelemetryStoreReadonly, (service) => service.listServices))
 
 export const loadRecentTraceSummaries = (serviceName: string) =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.listTraceSummaries(serviceName)))
+	query(["summaries", serviceName], Effect.flatMap(TelemetryStoreReadonly, (service) => service.listTraceSummaries(serviceName)))
 
 /**
  * Server-side trace summary search. Accepts any combination of:
@@ -29,7 +40,7 @@ export const loadFilteredTraceSummaries = (
 		readonly aiText?: string | null
 	},
 ) =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.searchTraceSummaries({
+	query(["summaries", serviceName, options], Effect.flatMap(TelemetryStoreReadonly, (service) => service.searchTraceSummaries({
 		serviceName,
 		attributeFilters: options.attributeFilters,
 		aiText: options.aiText ?? null,
@@ -92,10 +103,10 @@ export const invalidateFacetCaches = () => {
 }
 
 export const loadTraceDetail = (traceId: string) =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.getTrace(traceId)))
+	query(["trace", traceId], Effect.flatMap(TelemetryStoreReadonly, (service) => service.getTrace(traceId)))
 
 export const loadTraceLogs = (traceId: string) =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.listTraceLogs(traceId)))
+	query(["trace-logs", traceId], Effect.flatMap(TelemetryStoreReadonly, (service) => service.listTraceLogs(traceId)))
 
 export const loadServiceLogs = (serviceName: string) =>
-	queryRuntime.runPromise(Effect.flatMap(TelemetryStoreReadonly, (service) => service.listRecentLogs(serviceName)))
+	query(["service-logs", serviceName], Effect.flatMap(TelemetryStoreReadonly, (service) => service.listRecentLogs(serviceName)))