@kitlangton/motel 0.1.0

package/src/otlp.ts

@@ -0,0 +1,142 @@
+export interface OtlpAnyValue {
+	readonly stringValue?: string
+	readonly boolValue?: boolean
+	readonly intValue?: string | number
+	readonly doubleValue?: number
+	readonly bytesValue?: string
+	readonly arrayValue?: {
+		readonly values?: readonly OtlpAnyValue[]
+	}
+	readonly kvlistValue?: {
+		readonly values?: readonly OtlpKeyValue[]
+	}
+}
+
+export interface OtlpKeyValue {
+	readonly key: string
+	readonly value?: OtlpAnyValue
+}
+
+export interface OtlpSpanEvent {
+	readonly timeUnixNano?: string
+	readonly name?: string
+	readonly attributes?: readonly OtlpKeyValue[]
+}
+
+export interface OtlpSpan {
+	readonly traceId: string
+	readonly spanId: string
+	readonly parentSpanId?: string
+	readonly name?: string
+	readonly kind?: number
+	readonly startTimeUnixNano?: string
+	readonly endTimeUnixNano?: string
+	readonly attributes?: readonly OtlpKeyValue[]
+	readonly status?: {
+		readonly code?: number
+		readonly message?: string
+	}
+	readonly events?: readonly OtlpSpanEvent[]
+}
+
+export interface OtlpScopeSpans {
+	readonly scope?: {
+		readonly name?: string
+	}
+	readonly spans?: readonly OtlpSpan[]
+}
+
+export interface OtlpResourceSpans {
+	readonly resource?: {
+		readonly attributes?: readonly OtlpKeyValue[]
+	}
+	readonly scopeSpans?: readonly OtlpScopeSpans[]
+}
+
+export interface OtlpTraceExportRequest {
+	readonly resourceSpans?: readonly OtlpResourceSpans[]
+}
+
+export interface OtlpLogRecord {
+	readonly timeUnixNano?: string
+	readonly observedTimeUnixNano?: string
+	readonly severityText?: string
+	readonly body?: OtlpAnyValue
+	readonly attributes?: readonly OtlpKeyValue[]
+	readonly traceId?: string
+	readonly spanId?: string
+}
+
+export interface OtlpScopeLogs {
+	readonly scope?: {
+		readonly name?: string
+	}
+	readonly logRecords?: readonly OtlpLogRecord[]
+}
+
+export interface OtlpResourceLogs {
+	readonly resource?: {
+		readonly attributes?: readonly OtlpKeyValue[]
+	}
+	readonly scopeLogs?: readonly OtlpScopeLogs[]
+}
+
+export interface OtlpLogExportRequest {
+	readonly resourceLogs?: readonly OtlpResourceLogs[]
+}
+
+export const parseAnyValue = (value: OtlpAnyValue | undefined): unknown => {
+	if (!value) return null
+	if (value.stringValue !== undefined) return value.stringValue
+	if (value.boolValue !== undefined) return value.boolValue
+	if (value.intValue !== undefined) return Number(value.intValue)
+	if (value.doubleValue !== undefined) return value.doubleValue
+	if (value.bytesValue !== undefined) return value.bytesValue
+	if (value.arrayValue?.values) return value.arrayValue.values.map(parseAnyValue)
+	if (value.kvlistValue?.values) {
+		return Object.fromEntries(value.kvlistValue.values.map((entry) => [entry.key, parseAnyValue(entry.value)]))
+	}
+	return null
+}
+
+export const stringifyValue = (value: unknown): string => {
+	if (value === null || value === undefined) return ""
+	if (typeof value === "string") return value
+	if (typeof value === "number" || typeof value === "boolean") return String(value)
+	if (Array.isArray(value)) {
+		return value.map((entry) => stringifyValue(entry)).filter((entry) => entry.length > 0).join(" ")
+	}
+	return JSON.stringify(value)
+}
+
+export const attributeMap = (attributes: readonly OtlpKeyValue[] | undefined): Record<string, string> =>
+	Object.fromEntries((attributes ?? []).map((attribute) => [attribute.key, stringifyValue(parseAnyValue(attribute.value))]))
+
+export const nanosToMilliseconds = (value: string | undefined): number => {
+	if (!value) return 0
+	try {
+		return Number(BigInt(value) / 1_000_000n)
+	} catch {
+		const parsed = Number.parseInt(value, 10)
+		return Number.isFinite(parsed) ? Math.floor(parsed / 1_000_000) : 0
+	}
+}
+
+export const spanKindLabel = (kind: number | undefined): string | null => {
+	switch (kind) {
+		case 1:
+			return "internal"
+		case 2:
+			return "server"
+		case 3:
+			return "client"
+		case 4:
+			return "producer"
+		case 5:
+			return "consumer"
+		default:
+			return null
+	}
+}
+
+export const spanStatusLabel = (code: number | undefined): "ok" | "error" => (code === 2 ? "error" : "ok")

package/src/queryFilters.ts

@@ -0,0 +1,39 @@
+export const ATTRIBUTE_FILTER_PREFIX = "attr."
+export const ATTRIBUTE_CONTAINS_PREFIX = "attrContains."
+
+export const isAttributeFilterToken = (value: string) => value.startsWith(ATTRIBUTE_FILTER_PREFIX) && value.includes("=")
+export const isAttributeContainsToken = (value: string) => value.startsWith(ATTRIBUTE_CONTAINS_PREFIX) && value.includes("=")
+
+export const attributeFiltersFromEntries = (entries: Iterable<readonly [string, string]>) =>
+	Object.fromEntries(
+		[...entries]
+			.filter(([key]) => key.startsWith(ATTRIBUTE_FILTER_PREFIX) && !key.startsWith(ATTRIBUTE_CONTAINS_PREFIX))
+			.map(([key, value]) => [key.slice(ATTRIBUTE_FILTER_PREFIX.length), value]),
+	)
+
+export const attributeContainsFiltersFromEntries = (entries: Iterable<readonly [string, string]>) =>
+	Object.fromEntries(
+		[...entries]
+			.filter(([key]) => key.startsWith(ATTRIBUTE_CONTAINS_PREFIX))
+			.map(([key, value]) => [key.slice(ATTRIBUTE_CONTAINS_PREFIX.length), value]),
+	)
+
+export const attributeFiltersFromArgs = (values: readonly string[]) =>
+	Object.fromEntries(
+		values
+			.filter((v) => isAttributeFilterToken(v) && !isAttributeContainsToken(v))
+			.map((value) => {
+				const index = value.indexOf("=")
+				return [value.slice(ATTRIBUTE_FILTER_PREFIX.length, index), value.slice(index + 1)]
+			}),
+	)
+
+export const attributeContainsFiltersFromArgs = (values: readonly string[]) =>
+	Object.fromEntries(
+		values
+			.filter(isAttributeContainsToken)
+			.map((value) => {
+				const index = value.indexOf("=")
+				return [value.slice(ATTRIBUTE_CONTAINS_PREFIX.length, index), value.slice(index + 1)]
+			}),
+	)

package/src/registry.ts

@@ -0,0 +1,86 @@
+import * as fs from "node:fs"
+import * as os from "node:os"
+import * as path from "node:path"
+
+export const MOTEL_VERSION = "0.1.0"
+export const MOTEL_SERVICE_ID = "motel-local-server"
+
+const stateHome = () =>
+	process.env.XDG_STATE_HOME?.trim() || path.join(os.homedir(), ".local", "state")
+
+export const registryDir = () => path.join(stateHome(), "motel", "instances")
+
+export type RegistryEntry = {
+	readonly pid: number
+	readonly url: string
+	readonly workdir: string
+	readonly startedAt: string
+	readonly version: string
+}
+
+const entryPath = (pid: number) => path.join(registryDir(), `${pid}.json`)
+
+let currentEntryPath: string | null = null
+let signalHandlersRegistered = false
+
+const cleanup = () => {
+	if (!currentEntryPath) return
+	try {
+		fs.unlinkSync(currentEntryPath)
+	} catch {
+		// already gone — ignore
+	}
+	currentEntryPath = null
+}
+
+export const isAlive = (pid: number): boolean => {
+	try {
+		process.kill(pid, 0)
+		return true
+	} catch (err) {
+		return (err as NodeJS.ErrnoException).code === "EPERM"
+	}
+}
+
+export const listAliveEntries = (): RegistryEntry[] => {
+	const dir = registryDir()
+	let files: string[]
+	try {
+		files = fs.readdirSync(dir)
+	} catch {
+		return []
+	}
+	const alive: RegistryEntry[] = []
+	for (const f of files) {
+		if (!f.endsWith(".json")) continue
+		const full = path.join(dir, f)
+		try {
+			const entry = JSON.parse(fs.readFileSync(full, "utf8")) as RegistryEntry
+			if (isAlive(entry.pid)) {
+				alive.push(entry)
+			} else {
+				try { fs.unlinkSync(full) } catch {}
+			}
+		} catch {
+			try { fs.unlinkSync(full) } catch {}
+		}
+	}
+	return alive
+}
+
+export const writeRegistryEntry = (entry: RegistryEntry) => {
+	fs.mkdirSync(registryDir(), { recursive: true })
+	const file = entryPath(entry.pid)
+	fs.writeFileSync(file, JSON.stringify(entry, null, 2), "utf8")
+	currentEntryPath = file
+	if (!signalHandlersRegistered) {
+		signalHandlersRegistered = true
+		process.on("exit", cleanup)
+		for (const sig of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+			process.on(sig, () => {
+				cleanup()
+				process.exit(0)
+			})
+		}
+	}
+}

package/src/runtime.ts

@@ -0,0 +1,38 @@
+import * as NodeSdk from "@effect/opentelemetry/NodeSdk"
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http"
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"
+import { SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs"
+import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base"
+import { Layer, ManagedRuntime } from "effect"
+import { config } from "./config.js"
+import { LogQueryServiceLive } from "./services/LogQueryService.js"
+import { TelemetryStoreLive } from "./services/TelemetryStore.js"
+import { TraceQueryServiceLive } from "./services/TraceQueryService.js"
+
+const telemetryLayer = NodeSdk.layer(() => ({
+	spanProcessor: new SimpleSpanProcessor(
+		new OTLPTraceExporter({
+			url: config.otel.exporterUrl,
+		}),
+	),
+	logRecordProcessor: new SimpleLogRecordProcessor(
+		new OTLPLogExporter({
+			url: config.otel.logsExporterUrl,
+		}),
+	),
+	loggerMergeWithExisting: false,
+	resource: {
+		serviceName: config.otel.serviceName,
+		attributes: {
+			"deployment.environment.name": "local",
+			"service.instance.id": "motel.local",
+		},
+	},
+}))
+
+const QueryServicesLive = Layer.mergeAll(TraceQueryServiceLive, LogQueryServiceLive).pipe(Layer.provideMerge(TelemetryStoreLive))
+
+const QueryRuntimeLive = config.otel.enabled ? Layer.mergeAll(QueryServicesLive, telemetryLayer) : QueryServicesLive
+
+export const queryRuntime = ManagedRuntime.make(QueryRuntimeLive)
+export const storeRuntime = ManagedRuntime.make(TelemetryStoreLive)

package/src/server.ts

@@ -0,0 +1,10 @@
+import { config } from "./config.js"
+import { startLocalServer } from "./localServer.js"
+
+await startLocalServer()
+
+console.log(`motel local telemetry server listening on ${config.otel.queryUrl}`)
+
+await new Promise(() => {
+	// keep process alive
+})

package/src/services/LogQueryService.ts

@@ -0,0 +1,43 @@
+import { Effect, Layer, Context } from "effect"
+import type { LogItem } from "../domain.js"
+import { TelemetryStore } from "./TelemetryStore.js"
+
+export class LogQueryService extends Context.Service<
+	LogQueryService,
+	{
+		readonly listRecentLogs: (serviceName: string) => Effect.Effect<readonly LogItem[], Error>
+		readonly listTraceLogs: (traceId: string) => Effect.Effect<readonly LogItem[], Error>
+		readonly searchLogs: (input: { readonly serviceName?: string; readonly traceId?: string; readonly spanId?: string; readonly body?: string; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly LogItem[], Error>
+		readonly logStats: (input: { readonly groupBy: string; readonly agg: "count"; readonly serviceName?: string | null; readonly traceId?: string | null; readonly spanId?: string | null; readonly body?: string | null; readonly limit?: number; readonly attributeFilters?: Readonly<Record<string, string>> }) => Effect.Effect<readonly { readonly group: string; readonly value: number; readonly count: number }[], Error>
+		readonly listFacets: (input: { readonly type: "traces" | "logs"; readonly field: string; readonly serviceName?: string | null; readonly lookbackMinutes?: number; readonly limit?: number }) => Effect.Effect<readonly { readonly value: string; readonly count: number }[], Error>
+	}
+>()("motel/LogQueryService") {}
+
+export const LogQueryServiceLive = Layer.effect(
+	LogQueryService,
+	Effect.gen(function* () {
+		const store = yield* TelemetryStore
+
+		const listRecentLogs = Effect.fn("motel/LogQueryService.listRecentLogs")(function* (serviceName: string) {
+			yield* Effect.annotateCurrentSpan("log.service_name", serviceName)
+			const logs = yield* store.listRecentLogs(serviceName)
+			yield* Effect.annotateCurrentSpan("log.result_count", logs.length)
+			return logs
+		})
+
+		const listTraceLogs = Effect.fn("motel/LogQueryService.listTraceLogs")(function* (traceId: string) {
+			yield* Effect.annotateCurrentSpan("log.trace_id", traceId)
+			const logs = yield* store.listTraceLogs(traceId)
+			yield* Effect.annotateCurrentSpan("log.result_count", logs.length)
+			return logs
+		})
+
+		return LogQueryService.of({
+			listRecentLogs,
+			listTraceLogs,
+			searchLogs: store.searchLogs,
+			logStats: store.logStats,
+			listFacets: store.listFacets,
+		})
+	}),
+)