@hasna/logs 0.0.1 → 0.1.0

package/src/lib/alerts.ts

@@ -0,0 +1,117 @@
+import type { Database } from "bun:sqlite"
+
+export interface AlertRule {
+  id: string
+  project_id: string
+  name: string
+  service: string | null
+  level: string
+  threshold_count: number
+  window_seconds: number
+  action: "webhook" | "log"
+  webhook_url: string | null
+  enabled: number
+  last_fired_at: string | null
+  created_at: string
+}
+
+export function createAlertRule(db: Database, data: {
+  project_id: string
+  name: string
+  service?: string
+  level?: string
+  threshold_count?: number
+  window_seconds?: number
+  action?: "webhook" | "log"
+  webhook_url?: string
+}): AlertRule {
+  return db.prepare(`
+    INSERT INTO alert_rules (project_id, name, service, level, threshold_count, window_seconds, action, webhook_url)
+    VALUES ($project_id, $name, $service, $level, $threshold_count, $window_seconds, $action, $webhook_url)
+    RETURNING *
+  `).get({
+    $project_id: data.project_id,
+    $name: data.name,
+    $service: data.service ?? null,
+    $level: data.level ?? "error",
+    $threshold_count: data.threshold_count ?? 10,
+    $window_seconds: data.window_seconds ?? 60,
+    $action: data.action ?? "webhook",
+    $webhook_url: data.webhook_url ?? null,
+  }) as AlertRule
+}
+
+export function listAlertRules(db: Database, projectId?: string): AlertRule[] {
+  if (projectId) {
+    return db.prepare("SELECT * FROM alert_rules WHERE project_id = $p ORDER BY created_at DESC").all({ $p: projectId }) as AlertRule[]
+  }
+  return db.prepare("SELECT * FROM alert_rules ORDER BY created_at DESC").all() as AlertRule[]
+}
+
+export function updateAlertRule(db: Database, id: string, data: Partial<Pick<AlertRule, "enabled" | "threshold_count" | "window_seconds" | "webhook_url">>): AlertRule | null {
+  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
+  if (!fields) return db.prepare("SELECT * FROM alert_rules WHERE id = $id").get({ $id: id }) as AlertRule | null
+  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
+  params.$id = id
+  return db.prepare(`UPDATE alert_rules SET ${fields} WHERE id = $id RETURNING *`).get(params) as AlertRule | null
+}
+
+export function deleteAlertRule(db: Database, id: string): void {
+  db.run("DELETE FROM alert_rules WHERE id = $id", { $id: id })
+}
+
+export async function evaluateAlerts(db: Database, projectId: string, service: string | null, level: string): Promise<void> {
+  const rules = db.prepare(`
+    SELECT * FROM alert_rules
+    WHERE project_id = $p AND level = $level AND enabled = 1
+    AND ($service IS NULL OR service IS NULL OR service = $service)
+  `).all({ $p: projectId, $level: level, $service: service }) as AlertRule[]
+
+  for (const rule of rules) {
+    const since = new Date(Date.now() - rule.window_seconds * 1000).toISOString()
+    const conditions = ["project_id = $p", "level = $level", "timestamp >= $since"]
+    const params: Record<string, unknown> = { $p: projectId, $level: rule.level, $since: since }
+    if (rule.service) { conditions.push("service = $service"); params.$service = rule.service }
+
+    const { count } = db.prepare(`SELECT COUNT(*) as count FROM logs WHERE ${conditions.join(" AND ")}`).get(params) as { count: number }
+
+    if (count >= rule.threshold_count) {
+      await fireAlert(db, rule, count)
+    }
+  }
+}
+
+async function fireAlert(db: Database, rule: AlertRule, count: number): Promise<void> {
+  // Debounce: don't fire more than once per window
+  if (rule.last_fired_at) {
+    const lastFired = new Date(rule.last_fired_at).getTime()
+    if (Date.now() - lastFired < rule.window_seconds * 1000) return
+  }
+
+  db.run("UPDATE alert_rules SET last_fired_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE id = $id", { $id: rule.id })
+
+  const payload = {
+    alert: rule.name,
+    project_id: rule.project_id,
+    level: rule.level,
+    service: rule.service,
+    count,
+    threshold: rule.threshold_count,
+    window_seconds: rule.window_seconds,
+    fired_at: new Date().toISOString(),
+  }
+
+  if (rule.action === "webhook" && rule.webhook_url) {
+    try {
+      await fetch(rule.webhook_url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      })
+    } catch (err) {
+      console.error(`Alert webhook failed for rule ${rule.id}:`, err)
+    }
+  } else {
+    console.warn(`[ALERT] ${rule.name}:`, JSON.stringify(payload))
+  }
+}

package/src/lib/compare.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { compare } from "./compare.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("compare", () => {
+  it("detects new errors in window B", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const dayAgo = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const halfDayAgo = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+
+    // Window A: old error
+    db.prepare("INSERT INTO logs (project_id, level, message, service, timestamp) VALUES (?, 'error', 'old bug', 'api', ?)").run(p.id, dayAgo)
+    // Window B: new error
+    db.prepare("INSERT INTO logs (project_id, level, message, service, timestamp) VALUES (?, 'error', 'new bug', 'api', ?)").run(p.id, now)
+
+    const result = compare(db, p.id, dayAgo, halfDayAgo, halfDayAgo, now)
+    expect(result.new_errors.some(e => e.message === "new bug")).toBe(true)
+    expect(result.resolved_errors.some(e => e.message === "old bug")).toBe(true)
+  })
+
+  it("returns empty diff when no changes", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const since = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const mid = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+    const result = compare(db, p.id, since, mid, mid, now)
+    expect(result.new_errors).toHaveLength(0)
+    expect(result.resolved_errors).toHaveLength(0)
+  })
+
+  it("has correct structure", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const since = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const mid = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+    const result = compare(db, p.id, since, mid, mid, now)
+    expect(result).toHaveProperty("project_id")
+    expect(result).toHaveProperty("new_errors")
+    expect(result).toHaveProperty("resolved_errors")
+    expect(result).toHaveProperty("error_delta_by_service")
+    expect(result).toHaveProperty("summary")
+  })
+})

package/src/lib/compare.ts

@@ -0,0 +1,85 @@
+import type { Database } from "bun:sqlite"
+
+export interface CompareResult {
+  project_id: string
+  window_a: { since: string; until: string }
+  window_b: { since: string; until: string }
+  new_errors: { message: string; service: string | null; count: number }[]
+  resolved_errors: { message: string; service: string | null; count: number }[]
+  error_delta_by_service: { service: string | null; errors_a: number; errors_b: number; delta: number }[]
+  perf_delta_by_page: { page_id: string; url: string; score_a: number | null; score_b: number | null; delta: number | null }[]
+  summary: string
+}
+
+function getErrorsByMessage(db: Database, projectId: string, since: string, until: string) {
+  return db.prepare(`
+    SELECT message, service, COUNT(*) as count
+    FROM logs
+    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since AND timestamp <= $until
+    GROUP BY message, service
+  `).all({ $p: projectId, $since: since, $until: until }) as { message: string; service: string | null; count: number }[]
+}
+
+function getErrorsByService(db: Database, projectId: string, since: string, until: string) {
+  return db.prepare(`
+    SELECT service, COUNT(*) as errors
+    FROM logs
+    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since AND timestamp <= $until
+    GROUP BY service
+  `).all({ $p: projectId, $since: since, $until: until }) as { service: string | null; errors: number }[]
+}
+
+export function compare(
+  db: Database,
+  projectId: string,
+  aSince: string, aUntil: string,
+  bSince: string, bUntil: string,
+): CompareResult {
+  const errorsA = getErrorsByMessage(db, projectId, aSince, aUntil)
+  const errorsB = getErrorsByMessage(db, projectId, bSince, bUntil)
+
+  const keyA = new Set(errorsA.map(e => `${e.service}|${e.message}`))
+  const keyB = new Set(errorsB.map(e => `${e.service}|${e.message}`))
+
+  const new_errors = errorsB.filter(e => !keyA.has(`${e.service}|${e.message}`))
+  const resolved_errors = errorsA.filter(e => !keyB.has(`${e.service}|${e.message}`))
+
+  // Service-level delta
+  const svcA = getErrorsByService(db, projectId, aSince, aUntil)
+  const svcB = getErrorsByService(db, projectId, bSince, bUntil)
+  const svcMapA = new Map(svcA.map(s => [s.service, s.errors]))
+  const svcMapB = new Map(svcB.map(s => [s.service, s.errors]))
+  const allSvcs = new Set([...svcMapA.keys(), ...svcMapB.keys()])
+  const error_delta_by_service = [...allSvcs].map(svc => ({
+    service: svc,
+    errors_a: svcMapA.get(svc) ?? 0,
+    errors_b: svcMapB.get(svc) ?? 0,
+    delta: (svcMapB.get(svc) ?? 0) - (svcMapA.get(svc) ?? 0),
+  })).sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta))
+
+  // Perf delta per page
+  const perf_delta_by_page = db.prepare(`
+    SELECT
+      pa.page_id, pg.url,
+      pa.score as score_a,
+      pb.score as score_b,
+      (pb.score - pa.score) as delta
+    FROM
+      (SELECT page_id, AVG(score) as score FROM performance_snapshots WHERE project_id = $p AND timestamp >= $as AND timestamp <= $au GROUP BY page_id) pa
+      JOIN pages pg ON pg.id = pa.page_id
+      LEFT JOIN (SELECT page_id, AVG(score) as score FROM performance_snapshots WHERE project_id = $p AND timestamp >= $bs AND timestamp <= $bu GROUP BY page_id) pb ON pb.page_id = pa.page_id
+    ORDER BY delta ASC
+  `).all({ $p: projectId, $as: aSince, $au: aUntil, $bs: bSince, $bu: bUntil }) as CompareResult["perf_delta_by_page"]
+
+  const summary = [
+    `${new_errors.length} new error type(s), ${resolved_errors.length} resolved.`,
+    error_delta_by_service.filter(s => s.delta > 0).map(s => `${s.service ?? "unknown"}: +${s.delta}`).join(", ") || "No error increases.",
+  ].join(" ")
+
+  return {
+    project_id: projectId,
+    window_a: { since: aSince, until: aUntil },
+    window_b: { since: bSince, until: bUntil },
+    new_errors, resolved_errors, error_delta_by_service, perf_delta_by_page, summary,
+  }
+}

package/src/lib/diagnose.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { diagnose } from "./diagnose.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("diagnose", () => {
+  it("returns empty diagnosis for project with no logs", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const result = diagnose(db, p.id)
+    expect(result.project_id).toBe(p.id)
+    expect(result.top_errors).toHaveLength(0)
+    expect(result.summary).toContain("No errors")
+  })
+
+  it("surfaces top errors", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    ingestBatch(db, [
+      { level: "error", message: "DB timeout", service: "api", project_id: p.id },
+      { level: "error", message: "DB timeout", service: "api", project_id: p.id },
+      { level: "error", message: "Auth failed", service: "auth", project_id: p.id },
+    ])
+    const result = diagnose(db, p.id)
+    expect(result.top_errors.length).toBeGreaterThan(0)
+    expect(result.top_errors[0]!.message).toBe("DB timeout")
+    expect(result.top_errors[0]!.count).toBe(2)
+  })
+
+  it("populates summary with error info", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    ingestBatch(db, [{ level: "error", message: "boom", service: "api", project_id: p.id }])
+    const result = diagnose(db, p.id)
+    expect(result.summary).toContain("error")
+  })
+
+  it("groups error_rate_by_service", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    ingestBatch(db, [
+      { level: "error", message: "e1", service: "api", project_id: p.id },
+      { level: "info", message: "i1", service: "api", project_id: p.id },
+      { level: "warn", message: "w1", service: "db", project_id: p.id },
+    ])
+    const result = diagnose(db, p.id)
+    const api = result.error_rate_by_service.find(s => s.service === "api")
+    expect(api?.errors).toBe(1)
+    expect(api?.total).toBe(2)
+  })
+})

package/src/lib/diagnose.ts

@@ -0,0 +1,76 @@
+import type { Database } from "bun:sqlite"
+
+export interface DiagnosisResult {
+  project_id: string
+  window: string
+  top_errors: { message: string; count: number; service: string | null; last_seen: string }[]
+  error_rate_by_service: { service: string | null; errors: number; warns: number; total: number }[]
+  failing_pages: { page_id: string; url: string; error_count: number }[]
+  perf_regressions: { page_id: string; url: string; score_now: number | null; score_prev: number | null; delta: number | null }[]
+  summary: string
+}
+
+export function diagnose(db: Database, projectId: string, since?: string): DiagnosisResult {
+  const window = since ?? new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+
+  // Top errors by message
+  const top_errors = db.prepare(`
+    SELECT message, COUNT(*) as count, service, MAX(timestamp) as last_seen
+    FROM logs
+    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since
+    GROUP BY message, service
+    ORDER BY count DESC
+    LIMIT 10
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["top_errors"]
+
+  // Error rate by service
+  const error_rate_by_service = db.prepare(`
+    SELECT service,
+      SUM(CASE WHEN level IN ('error','fatal') THEN 1 ELSE 0 END) as errors,
+      SUM(CASE WHEN level = 'warn' THEN 1 ELSE 0 END) as warns,
+      COUNT(*) as total
+    FROM logs
+    WHERE project_id = $p AND timestamp >= $since
+    GROUP BY service
+    ORDER BY errors DESC
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["error_rate_by_service"]
+
+  // Failing pages (most errors)
+  const failing_pages = db.prepare(`
+    SELECT l.page_id, p.url, COUNT(*) as error_count
+    FROM logs l
+    JOIN pages p ON p.id = l.page_id
+    WHERE l.project_id = $p AND l.level IN ('error','fatal') AND l.timestamp >= $since AND l.page_id IS NOT NULL
+    GROUP BY l.page_id, p.url
+    ORDER BY error_count DESC
+    LIMIT 10
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["failing_pages"]
+
+  // Perf regressions: compare latest vs previous snapshot per page
+  const perf_regressions = db.prepare(`
+    SELECT * FROM (
+      SELECT
+        cur.page_id,
+        p.url,
+        cur.score as score_now,
+        prev.score as score_prev,
+        (cur.score - prev.score) as delta
+      FROM performance_snapshots cur
+      JOIN pages p ON p.id = cur.page_id
+      LEFT JOIN performance_snapshots prev ON prev.page_id = cur.page_id AND prev.id != cur.id
+      WHERE cur.project_id = $p
+      AND cur.timestamp = (SELECT MAX(timestamp) FROM performance_snapshots WHERE page_id = cur.page_id)
+      AND (prev.timestamp = (SELECT MAX(timestamp) FROM performance_snapshots WHERE page_id = cur.page_id AND id != cur.id) OR prev.id IS NULL)
+    ) WHERE delta < -5 OR delta IS NULL
+    ORDER BY delta ASC
+    LIMIT 10
+  `).all({ $p: projectId }) as DiagnosisResult["perf_regressions"]
+
+  const totalErrors = top_errors.reduce((s, e) => s + e.count, 0)
+  const topService = error_rate_by_service[0]
+  const summary = totalErrors === 0
+    ? "No errors in this window. All looks good."
+    : `${totalErrors} error(s) detected. Worst service: ${topService?.service ?? "unknown"} (${topService?.errors ?? 0} errors). ${failing_pages.length} page(s) with errors. ${perf_regressions.length} perf regression(s).`
+
+  return { project_id: projectId, window, top_errors, error_rate_by_service, failing_pages, perf_regressions, summary }
+}

package/src/lib/export.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { exportToCsv, exportToJson } from "./export.ts"
+
+function seed(db: ReturnType<typeof createTestDb>) {
+  ingestBatch(db, [
+    { level: "error", message: "boom", service: "api" },
+    { level: "info", message: "ok", service: "web" },
+    { level: "warn", message: 'has "quotes"', service: "db" },
+  ])
+}
+
+describe("exportToJson", () => {
+  it("exports all logs as JSON array", () => {
+    const db = createTestDb()
+    seed(db)
+    const chunks: string[] = []
+    const count = exportToJson(db, {}, s => chunks.push(s))
+    expect(count).toBe(3)
+    const parsed = JSON.parse(chunks.join(""))
+    expect(Array.isArray(parsed)).toBe(true)
+    expect(parsed).toHaveLength(3)
+  })
+
+  it("filters by level", () => {
+    const db = createTestDb()
+    seed(db)
+    const chunks: string[] = []
+    const count = exportToJson(db, { level: "error" }, s => chunks.push(s))
+    expect(count).toBe(1)
+    const parsed = JSON.parse(chunks.join(""))
+    expect(parsed[0].level).toBe("error")
+  })
+})
+
+describe("exportToCsv", () => {
+  it("exports CSV with header", () => {
+    const db = createTestDb()
+    seed(db)
+    const chunks: string[] = []
+    const count = exportToCsv(db, {}, s => chunks.push(s))
+    expect(count).toBe(3)
+    const csv = chunks.join("")
+    expect(csv).toContain("id,timestamp,level")
+    expect(csv).toContain("error")
+    expect(csv).toContain("boom")
+  })
+
+  it("escapes CSV quotes", () => {
+    const db = createTestDb()
+    seed(db)
+    const chunks: string[] = []
+    exportToCsv(db, { level: "warn" }, s => chunks.push(s))
+    const csv = chunks.join("")
+    expect(csv).toContain('"has ""quotes"""')
+  })
+
+  it("filters by service", () => {
+    const db = createTestDb()
+    seed(db)
+    const chunks: string[] = []
+    const count = exportToCsv(db, { service: "api" }, s => chunks.push(s))
+    expect(count).toBe(1)
+  })
+})

package/src/lib/export.ts

@@ -0,0 +1,65 @@
+import type { Database } from "bun:sqlite"
+import type { LogRow } from "../types/index.ts"
+
+export interface ExportOptions {
+  project_id?: string
+  since?: string
+  until?: string
+  level?: string
+  service?: string
+  limit?: number
+}
+
+function* iterLogs(db: Database, opts: ExportOptions): Generator<LogRow> {
+  const conditions: string[] = []
+  const params: Record<string, unknown> = {}
+  if (opts.project_id) { conditions.push("project_id = $p"); params.$p = opts.project_id }
+  if (opts.since) { conditions.push("timestamp >= $since"); params.$since = opts.since }
+  if (opts.until) { conditions.push("timestamp <= $until"); params.$until = opts.until }
+  if (opts.level) { conditions.push("level = $level"); params.$level = opts.level }
+  if (opts.service) { conditions.push("service = $service"); params.$service = opts.service }
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
+  const limit = opts.limit ?? 100_000
+
+  // Batch in pages of 1000 to avoid memory issues
+  let offset = 0
+  while (offset < limit) {
+    const batch = db.prepare(`SELECT * FROM logs ${where} ORDER BY timestamp ASC LIMIT 1000 OFFSET $offset`)
+      .all({ ...params, $offset: offset }) as LogRow[]
+    if (!batch.length) break
+    yield* batch
+    offset += batch.length
+    if (batch.length < 1000) break
+  }
+}
+
+export function exportToJson(db: Database, opts: ExportOptions, writeLine: (s: string) => void): number {
+  writeLine("[")
+  let count = 0
+  for (const row of iterLogs(db, opts)) {
+    writeLine((count > 0 ? "," : "") + JSON.stringify(row))
+    count++
+  }
+  writeLine("]")
+  return count
+}
+
+const CSV_HEADER = "id,timestamp,level,service,message,trace_id,url\n"
+
+export function exportToCsv(db: Database, opts: ExportOptions, writeLine: (s: string) => void): number {
+  writeLine(CSV_HEADER)
+  let count = 0
+  for (const row of iterLogs(db, opts)) {
+    const fields = [row.id, row.timestamp, row.level, row.service ?? "", escapeCSV(row.message), row.trace_id ?? "", row.url ?? ""]
+    writeLine(fields.join(",") + "\n")
+    count++
+  }
+  return count
+}
+
+function escapeCSV(s: string): string {
+  if (s.includes(",") || s.includes('"') || s.includes("\n")) {
+    return `"${s.replace(/"/g, '""')}"`
+  }
+  return s
+}

package/src/lib/health.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { getHealth } from "./health.ts"
+
+describe("getHealth", () => {
+  it("returns status ok", () => {
+    const db = createTestDb()
+    const h = getHealth(db)
+    expect(h.status).toBe("ok")
+  })
+
+  it("counts total logs", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "info", message: "a" }, { level: "error", message: "b" }])
+    const h = getHealth(db)
+    expect(h.total_logs).toBe(2)
+  })
+
+  it("returns logs_by_level breakdown", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "info", message: "a" }, { level: "error", message: "b" }, { level: "error", message: "c" }])
+    const h = getHealth(db)
+    expect(h.logs_by_level["error"]).toBe(2)
+    expect(h.logs_by_level["info"]).toBe(1)
+  })
+
+  it("counts projects", () => {
+    const db = createTestDb()
+    db.prepare("INSERT INTO projects (name) VALUES ('p1')").run()
+    db.prepare("INSERT INTO projects (name) VALUES ('p2')").run()
+    const h = getHealth(db)
+    expect(h.projects).toBe(2)
+  })
+
+  it("returns uptime_seconds >= 0", () => {
+    const h = getHealth(createTestDb())
+    expect(h.uptime_seconds).toBeGreaterThanOrEqual(0)
+  })
+
+  it("returns newest and oldest log timestamps", () => {
+    const db = createTestDb()
+    ingestBatch(db, [{ level: "info", message: "first" }, { level: "warn", message: "last" }])
+    const h = getHealth(db)
+    expect(h.oldest_log).toBeTruthy()
+    expect(h.newest_log).toBeTruthy()
+  })
+})

package/src/lib/health.ts

@@ -0,0 +1,51 @@
+import type { Database } from "bun:sqlite"
+
+const startTime = Date.now()
+
+export interface HealthResult {
+  status: "ok"
+  uptime_seconds: number
+  db_size_bytes: number | null
+  projects: number
+  total_logs: number
+  logs_by_level: Record<string, number>
+  oldest_log: string | null
+  newest_log: string | null
+  scheduler_jobs: number
+  open_issues: number
+}
+
+export function getHealth(db: Database): HealthResult {
+  const projects = (db.prepare("SELECT COUNT(*) as c FROM projects").get() as { c: number }).c
+  const total_logs = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
+  const scheduler_jobs = (db.prepare("SELECT COUNT(*) as c FROM scan_jobs WHERE enabled = 1").get() as { c: number }).c
+  const open_issues = (db.prepare("SELECT COUNT(*) as c FROM issues WHERE status = 'open'").get() as { c: number }).c
+
+  const levelRows = db.prepare("SELECT level, COUNT(*) as c FROM logs GROUP BY level").all() as { level: string; c: number }[]
+  const logs_by_level = Object.fromEntries(levelRows.map(r => [r.level, r.c]))
+
+  const oldest = db.prepare("SELECT MIN(timestamp) as t FROM logs").get() as { t: string | null }
+  const newest = db.prepare("SELECT MAX(timestamp) as t FROM logs").get() as { t: string | null }
+
+  let db_size_bytes: number | null = null
+  try {
+    const dbPath = process.env.LOGS_DB_PATH
+    if (dbPath) {
+      const { statSync } = require("node:fs")
+      db_size_bytes = statSync(dbPath).size
+    }
+  } catch { /* in-memory or not accessible */ }
+
+  return {
+    status: "ok",
+    uptime_seconds: Math.floor((Date.now() - startTime) / 1000),
+    db_size_bytes,
+    projects,
+    total_logs,
+    logs_by_level,
+    oldest_log: oldest.t,
+    newest_log: newest.t,
+    scheduler_jobs,
+    open_issues,
+  }
+}

package/src/lib/ingest.ts

@@ -1,5 +1,9 @@
 import type { Database } from "bun:sqlite"
 import type { LogEntry, LogRow } from "../types/index.ts"
+import { upsertIssue } from "./issues.ts"
+import { evaluateAlerts } from "./alerts.ts"
+
+const ERROR_LEVELS = new Set(["warn", "error", "fatal"])
 
 export function ingestLog(db: Database, entry: LogEntry): LogRow {
   const stmt = db.prepare(`
@@ -7,7 +11,7 @@ export function ingestLog(db: Database, entry: LogEntry): LogRow {
     VALUES ($project_id, $page_id, $level, $source, $service, $message, $trace_id, $session_id, $agent, $url, $stack_trace, $metadata)
     RETURNING *
   `)
-  return stmt.get({
+  const row = stmt.get({
     $project_id: entry.project_id ?? null,
     $page_id: entry.page_id ?? null,
     $level: entry.level,
@@ -21,6 +25,16 @@ export function ingestLog(db: Database, entry: LogEntry): LogRow {
     $stack_trace: entry.stack_trace ?? null,
     $metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
   }) as LogRow
+
+  // Side effects: issue grouping + alert evaluation (fire-and-forget)
+  if (ERROR_LEVELS.has(entry.level)) {
+    if (entry.project_id) {
+      upsertIssue(db, { project_id: entry.project_id, level: entry.level, service: entry.service, message: entry.message, stack_trace: entry.stack_trace })
+      evaluateAlerts(db, entry.project_id, entry.service ?? null, entry.level).catch(() => {})
+    }
+  }
+
+  return row
 }
 
 export function ingestBatch(db: Database, entries: LogEntry[]): LogRow[] {
@@ -47,5 +61,14 @@ export function ingestBatch(db: Database, entries: LogEntry[]): LogRow[] {
       }) as LogRow
     )
   )
-  return tx(entries)
+  const rows = tx(entries)
+
+  // Issue grouping for error-level entries (outside transaction for perf)
+  for (const entry of entries) {
+    if (ERROR_LEVELS.has(entry.level) && entry.project_id) {
+      upsertIssue(db, { project_id: entry.project_id, level: entry.level, service: entry.service, message: entry.message, stack_trace: entry.stack_trace })
+    }
+  }
+
+  return rows
 }