@kitlangton/motel 0.2.7 → 0.2.8

package/package.json

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

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) =>