@kitlangton/motel 0.2.6 → 0.2.8

package/AGENTS.md

@@ -132,7 +132,7 @@ The repo is wired up with `@effect/language-service` as a `tsconfig.json` `plugi
 
 ## Env Vars
 - `MOTEL_OTEL_ENABLED`: defaults to `false` (set to `true` to emit self-traces for debugging motel itself)
-- `MOTEL_OTEL_SERVICE_NAME`: defaults to `motel-otel-tui`
+- `MOTEL_OTEL_SERVICE_NAME`: defaults to `motel-otel-tui`; a nonblank explicit value also selects the initial TUI service, overriding the remembered selection (unset or blank values keep the remembered selection)
 - `MOTEL_OTEL_BASE_URL`: defaults to `http://127.0.0.1:27686`
 - `MOTEL_OTEL_HOST`: defaults to `127.0.0.1`
 - `MOTEL_OTEL_PORT`: defaults to `27686`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitlangton/motel",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "A local OpenTelemetry ingest + TUI viewer for development, backed by SQLite.",
   "type": "module",
   "license": "MIT",

package/src/config.ts

@@ -22,10 +22,13 @@ const parsedBaseUrl = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`)
 export const resolveOtelUrl = (path: string) => new URL(path.startsWith("/") ? path.slice(1) : path, parsedBaseUrl).toString()
 const serverPort = parsePositiveInt(process.env.MOTEL_OTEL_PORT, Number.parseInt(parsedBaseUrl.port || "80", 10))
 
+// Preserve whether a service was requested so the TUI can override remembered state.
+export const explicitServiceName = process.env.MOTEL_OTEL_SERVICE_NAME?.trim() || null
+
 export const config = {
 	otel: {
 		enabled: parseBoolean(process.env.MOTEL_OTEL_ENABLED, false),
-		serviceName: process.env.MOTEL_OTEL_SERVICE_NAME?.trim() || "motel-otel-tui",
+		serviceName: explicitServiceName ?? "motel-otel-tui",
 		baseUrl,
 		host: process.env.MOTEL_OTEL_HOST?.trim() || parsedBaseUrl.hostname,
 		port: serverPort,

package/src/services/TelemetryStore.ts

@@ -614,6 +614,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 					CREATE INDEX IF NOT EXISTS idx_logs_trace_time ON logs(trace_id, timestamp_ms DESC);
 					CREATE INDEX IF NOT EXISTS idx_logs_span_time ON logs(span_id, timestamp_ms DESC);
 					CREATE INDEX IF NOT EXISTS idx_logs_severity_time ON logs(severity_text, timestamp_ms DESC);
+					CREATE INDEX IF NOT EXISTS idx_logs_severity_nocase_time ON logs(severity_text COLLATE NOCASE, timestamp_ms DESC);
 
 					CREATE TABLE IF NOT EXISTS trace_summaries (
 						trace_id TEXT PRIMARY KEY,
@@ -1673,7 +1674,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 					params.push(input.serviceName)
 				}
 				if (input.severity) {
-					clauses.push(`severity_text = ?`)
+					clauses.push(`severity_text = ? COLLATE NOCASE`)
 					params.push(input.severity.toUpperCase())
 				}
 				if (input.traceId) {
@@ -1886,7 +1887,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 					const group = input.groupBy === "service"
 						? log.serviceName
 						: input.groupBy === "severity"
-							? log.severityText
+							? log.severityText.toUpperCase()
 							: input.groupBy === "scope"
 								? log.scopeName ?? "unknown"
 								: isAttrGroupBy
@@ -1932,7 +1933,7 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 				const groupExpr = input.groupBy === "service"
 					? "service_name"
 					: input.groupBy === "severity"
-						? "severity_text"
+						? "UPPER(severity_text)"
 						: input.groupBy === "scope"
 							? "COALESCE(scope_name, 'unknown')"
 							: "'unknown'"
@@ -1976,11 +1977,11 @@ const makeTelemetryStoreEffect = (opts: TelemetryStoreOptions) =>
 					}
 					if (input.field === "severity") {
 						const rows = db.query(`
-							SELECT severity_text AS value, COUNT(*) AS count
+							SELECT UPPER(severity_text) AS value, COUNT(*) AS count
 							FROM logs
 							WHERE timestamp_ms >= ?
 							${input.serviceName ? "AND service_name = ?" : ""}
-							GROUP BY severity_text
+							GROUP BY value
 							ORDER BY count DESC, value ASC
 							LIMIT ?
 						`).all(...(input.serviceName ? [cutoff, input.serviceName, limit] : [cutoff, limit])) as Array<{ value: string; count: number }>

package/src/storybook/fixtures/index.ts

@@ -27,7 +27,7 @@ export const makeSpan = (overrides: Partial<TraceSpanItem> = {}): TraceSpanItem
 	depth: 0,
 	tags: {
 		"ai.operationId": "ai.streamText",
-		"ai.model.id": "claude-opus-4-7",
+		"ai.model.id": "example-chat-model",
 		"ai.model.provider": "anthropic",
 		"ai.prompt.messages": "[]",
 	},
@@ -43,7 +43,7 @@ export const makeDetail = (overrides: Partial<AiCallDetail> = {}): AiCallDetail
 	service: "storybook",
 	functionId: "story.demo",
 	provider: "anthropic",
-	model: "claude-opus-4-7",
+	model: "example-chat-model",
 	status: "ok",
 	startedAt: new Date().toISOString(),
 	durationMs: 2400,

package/src/telemetry.test.ts

@@ -668,6 +668,81 @@ describe("motel telemetry store", () => {
 		expect(result[0]?.severityText).toBe("ERROR")
 	})
 
+	describe("mixed-case stored log severities", () => {
+		const serviceName = "severity-case-test"
+		const severities = ["Info", "INFO", "info", "Error"]
+
+		beforeAll(async () => {
+			await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) =>
+				store.ingestLogs({
+					resourceLogs: [{
+						resource: { attributes: [{ key: "service.name", value: { stringValue: serviceName } }] },
+						scopeLogs: [{ logRecords: severities.map((severityText, index) => ({
+							timeUnixNano: String(BigInt(Date.now()) * 1_000_000n),
+							severityText,
+							body: { stringValue: `severity-case-${index}` },
+							attributes: [{ key: "batch", value: { stringValue: index < 2 ? "included" : "excluded" } }],
+						})) }],
+					}],
+				}),
+			).pipe(Effect.provideService(References.MinimumLogLevel, "None")))
+		})
+
+		for (const severity of ["INFO", "Info", "info"]) {
+			it(`filters ${severity} without changing returned severity text`, async () => {
+				const logs = await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) =>
+					store.searchLogs({ serviceName, severity }),
+				))
+				expect(logs.map((log) => log.severityText).sort()).toEqual(["INFO", "Info", "info"])
+			})
+		}
+
+		it("groups severity variants in SQL stats", async () => {
+			const stats = await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) =>
+				store.logStats({ serviceName, groupBy: "severity", agg: "count" }),
+			))
+			expect(stats).toEqual([
+				{ group: "INFO", value: 3, count: 3 },
+				{ group: "ERROR", value: 1, count: 1 },
+			])
+		})
+
+		it("groups severity variants in attribute-filtered stats", async () => {
+			const stats = await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) =>
+				store.logStats({ serviceName, groupBy: "severity", agg: "count", attributeFilters: { batch: "included" } }),
+			))
+			expect(stats).toEqual([{ group: "INFO", value: 2, count: 2 }])
+		})
+
+		it("indexes case-insensitive severity searches", () => {
+			const probe = new Database(dbPath, { readonly: true })
+			try {
+				const plan = probe.query<{ detail: string }, [string, number, number]>(`
+					EXPLAIN QUERY PLAN SELECT * FROM logs
+					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)
+			} finally {
+				probe.close()
+			}
+		})
+
+		it("groups severity facets without changing persisted text", async () => {
+			const facets = await storeRuntime.runPromise(Effect.flatMap(TelemetryStore, (store) =>
+				store.listFacets({ serviceName, type: "logs", field: "severity" }),
+			))
+			expect(facets).toEqual([{ value: "INFO", count: 3 }, { value: "ERROR", count: 1 }])
+			const probe = new Database(dbPath, { readonly: true })
+			try {
+				expect(probe.query("SELECT severity_text FROM logs WHERE service_name = ? ORDER BY id").all(serviceName))
+					.toEqual(severities.map((severity_text) => ({ severity_text })))
+			} finally {
+				probe.close()
+			}
+		})
+	})
+
 	it("searches log body case-insensitively", async () => {
 		const result = await storeRuntime.runPromise(
 			Effect.flatMap(TelemetryStore, (store) =>

package/src/ui/atoms.ts

@@ -1,5 +1,5 @@
 import * as Atom from "effect/unstable/reactivity/Atom"
-import { config } from "../config.ts"
+import { config, explicitServiceName } from "../config.ts"
 import type { LogItem, TraceItem, TraceSummaryItem } from "../domain.ts"
 import type { ThemeName } from "./theme.ts"
 import { readLastService, readLastTheme } from "./persistence.ts"
@@ -77,7 +77,7 @@ export const logStateAtom = Atom.make(initialLogState).pipe(Atom.keepAlive)
 export const serviceLogStateAtom = Atom.make(initialServiceLogState).pipe(Atom.keepAlive)
 export const selectedServiceLogIndexAtom = Atom.make(0).pipe(Atom.keepAlive)
 export const selectedTraceIndexAtom = Atom.make(0).pipe(Atom.keepAlive)
-export const selectedTraceServiceAtom = Atom.make<string | null>(readLastService() ?? config.otel.serviceName).pipe(Atom.keepAlive)
+export const selectedTraceServiceAtom = Atom.make<string | null>(explicitServiceName ?? readLastService() ?? config.otel.serviceName).pipe(Atom.keepAlive)
 export const refreshNonceAtom = Atom.make(0).pipe(Atom.keepAlive)
 export const noticeAtom = Atom.make<string | null>(null).pipe(Atom.keepAlive)
 export const selectedSpanIndexAtom = Atom.make<number | null>(null).pipe(Atom.keepAlive)

package/src/ui/serviceSelection.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+describe("initial TUI service selection", () => {
+	for (const remembered of [undefined, "svc-b", " \n"]) {
+		for (const explicit of [undefined, "", " \t ", "svc-a", " svc-a ", "motel-otel-tui"]) {
+			test(`env=${JSON.stringify(explicit)}, remembered=${JSON.stringify(remembered)}`, () => {
+				const dir = mkdtempSync(join(tmpdir(), "motel-service-selection-"))
+				try {
+					if (remembered !== undefined) writeFileSync(join(dir, "last-service.txt"), remembered)
+					const env = { ...process.env }
+					for (const key of Object.keys(env)) {
+						if (key.startsWith("MOTEL_")) delete env[key]
+					}
+					env.MOTEL_RUNTIME_DIR = dir
+					env.MOTEL_OTEL_DB_PATH = join(dir, "telemetry.sqlite")
+					if (explicit !== undefined) env.MOTEL_OTEL_SERVICE_NAME = explicit
+
+					// Fresh processes exercise import-time config and persistence without module-cache leakage.
+					const result = Bun.spawnSync([process.execPath, "--no-env-file", "--eval", `
+						import * as AtomRegistry from "effect/unstable/reactivity/AtomRegistry"
+						import { config } from "./src/config.ts"
+						import { selectedTraceServiceAtom } from "./src/ui/atoms.ts"
+						const registry = AtomRegistry.make()
+						const initial = registry.get(selectedTraceServiceAtom)
+						registry.set(selectedTraceServiceAtom, "switched-service")
+						console.log(JSON.stringify({
+							initial,
+							serviceName: config.otel.serviceName,
+							switched: registry.get(selectedTraceServiceAtom),
+						}))
+						registry.dispose()
+					`], { cwd: join(import.meta.dir, "../.."), env, timeout: 5_000 })
+
+					expect(result.exitCode).toBe(0)
+					expect(result.stderr.toString()).toBe("")
+					expect(JSON.parse(result.stdout.toString())).toEqual({
+						initial: explicit?.trim() || remembered?.trim() || "motel-otel-tui",
+						serviceName: explicit?.trim() || "motel-otel-tui",
+						switched: "switched-service",
+					})
+				} finally {
+					rmSync(dir, { recursive: true, force: true })
+				}
+			})
+		}
+	}
+})