@cybermem/dashboard 0.1.0

package/lib/data/production-strategy.ts

@@ -0,0 +1,152 @@
+
+import { DashboardData, DataSourceStrategy, TimeSeriesData } from "./types"
+
+export class ProductionDataSource implements DataSourceStrategy {
+  async fetchGlobalStats(): Promise<DashboardData> {
+    const res = await fetch(`/api/metrics`)
+    if (!res.ok) throw new Error("Failed to fetch metrics")
+    const data = await res.json()
+
+    const logsRes = await fetch(`/api/audit-logs`)
+    const logsData = logsRes.ok ? await logsRes.json() : { logs: [] }
+
+    // Helper to resolve logs
+    const resolveOperation = (log: any) => {
+      const normalizedOp = (log.operation || "").toString().toLowerCase()
+      if (normalizedOp === "read") return "Read"
+      if (normalizedOp === "write" || normalizedOp === "create") return "Write"
+      if (normalizedOp === "update") return "Update"
+      if (normalizedOp === "delete") return "Delete"
+      const method = (log.method || "").toString().toUpperCase()
+      if (method === "GET") return "Read"
+      if (method === "DELETE") return "Delete"
+      if (method === "PATCH" || method === "PUT") return "Update"
+      return "Write"
+    }
+
+    const mappedLogs = (logsData.logs || []).map((log: any, index: number) => {
+      const operation = resolveOperation(log)
+      // Use rawStatus if available (from our API), otherwise fallback to status
+      const statusCode = parseInt(log.rawStatus || log.status)
+      let status = "Success"
+      let description = ""
+      if (statusCode >= 500) { status = "Error"; description = "Server error" }
+      else if (statusCode >= 400) { status = "Error"; description = statusCode === 401 ? "Unauthorized" : statusCode === 403 ? "Forbidden" : "Client error" }
+      else if (statusCode >= 300) { status = "Warning"; description = "Redirect" }
+      else if (log.status === "Error") { status = "Error"; description = "Error" }
+
+      return {
+        id: index,
+        date: new Date(log.timestamp),
+        client: log.client || "Unknown",
+        operation,
+        status,
+        description,
+        timestamp: new Date(log.timestamp).getTime()
+      }
+    })
+
+    // Calculate Latest & Tops from logs if available
+    const sortedByDate = [...mappedLogs].sort((a, b) => b.timestamp - a.timestamp)
+
+    // Writers
+    const wLog = sortedByDate.find(l => ["Write", "Update", "Delete", "Create"].includes(l.operation))
+    const lastWriter = wLog ? { name: wLog.client, timestamp: wLog.timestamp } : { name: "N/A", timestamp: 0 }
+
+    // Readers
+    const rLog = sortedByDate.find(l => l.operation === "Read")
+    const lastReader = rLog ? { name: rLog.client, timestamp: rLog.timestamp } : { name: "N/A", timestamp: 0 }
+
+    // Tops
+    const writerCounts: Record<string, number> = {}
+    const readerCounts: Record<string, number> = {}
+    mappedLogs.forEach((log: any) => {
+      if (["Write", "Update", "Delete", "Create"].includes(log.operation)) {
+        writerCounts[log.client] = (writerCounts[log.client] || 0) + 1
+      } else if (log.operation === "Read") {
+        readerCounts[log.client] = (readerCounts[log.client] || 0) + 1
+      }
+    })
+    const getTop = (counts: Record<string, number>) => {
+      const entries = Object.entries(counts)
+      if (entries.length === 0) return { name: "N/A", count: 0 }
+      entries.sort((a, b) => b[1] - a[1])
+      return { name: entries[0][0], count: entries[0][1] }
+    }
+
+    const topWriter = logsRes.ok ? getTop(writerCounts) : (data.stats.topWriter ?? { name: "N/A", count: 0 })
+    const topReader = logsRes.ok ? getTop(readerCounts) : (data.stats.topReader ?? { name: "N/A", count: 0 })
+
+    // Trends calculation
+    const calculateTrend = (series: number[]) => {
+       if (!series || series.length < 2) return { change: "0", trend: "neutral" as const, hasData: false, data: [] }
+       const first = series[0]
+       const last = series[series.length - 1]
+       const diff = last - first
+       const prefix = diff > 0 ? "+" : ""
+       return {
+           change: `${prefix}${diff.toLocaleString()}`,
+           trend: (diff > 0 ? "up" : diff < 0 ? "down" : "neutral") as "up" | "down" | "neutral",
+           hasData: true,
+           data: series
+       }
+    }
+
+    // Success Rate Trend
+    let successTrend = { change: "0%", trend: "neutral" as "neutral" | "up" | "down", hasData: false, data: [] as number[] }
+    if (data.sparklines?.successRate) {
+        const sData = data.sparklines.successRate
+        const sFirst = sData[0] || 0
+        const sLast = sData[sData.length - 1] || 0
+        const sDiff = sLast - sFirst
+        successTrend = {
+            change: `${sDiff > 0 ? "+" : ""}${sDiff.toFixed(1)}%`,
+           trend: (sDiff >= 0 ? "up" : "down"),
+            hasData: true,
+            data: sData
+        }
+    }
+
+    return {
+      stats: {
+        memoryRecords: data.stats.memoryRecords ?? 0,
+        totalClients: data.stats.totalClients ?? 0,
+        successRate: data.stats.successRate ?? 0,
+        totalRequests: data.stats.totalRequests ?? 0,
+        topWriter,
+        topReader,
+        lastWriter,
+        lastReader,
+      },
+      trends: {
+        memory: calculateTrend(data.sparklines?.memoryRecords),
+        clients: calculateTrend(data.sparklines?.totalClients),
+        success: successTrend,
+        requests: calculateTrend(data.sparklines?.totalRequests),
+      },
+      logs: mappedLogs,
+    }
+  }
+
+  async getChartData(period: string): Promise<TimeSeriesData> {
+    const res = await fetch(`/api/metrics?period=${period}`)
+    if (!res.ok) throw new Error("Failed to fetch chart data")
+    const apiData = await res.json()
+
+    // Fetch clients metadata separately or use what's in apiData
+    // Ideally we merge them here
+    let metadata = {}
+    if (apiData.metadata) {
+        metadata = apiData.metadata
+    }
+
+    // apiData.timeSeries needs to be returned.
+    return {
+        creates: apiData.timeSeries?.creates || [],
+        reads: apiData.timeSeries?.reads || [],
+        updates: apiData.timeSeries?.updates || [],
+        deletes: apiData.timeSeries?.deletes || [],
+        metadata
+    }
+  }
+}

package/lib/data/types.ts

@@ -0,0 +1,52 @@
+export interface TrendState {
+  change: string
+  trend: "up" | "down" | "neutral"
+  hasData: boolean
+  data: number[]
+}
+
+export interface DashboardStats {
+  memoryRecords: number
+  totalClients: number
+  successRate: number
+  totalRequests: number
+  topWriter: { name: string; count: number }
+  topReader: { name: string; count: number }
+  lastWriter: { name: string; timestamp: number }
+  lastReader: { name: string; timestamp: number }
+}
+
+export interface AuditLogEntry {
+  id: number
+  date: Date
+  client: string
+  operation: string
+  status: string
+  description: string
+  timestamp: number
+}
+
+export interface DashboardData {
+  stats: DashboardStats
+  trends: {
+    memory: TrendState
+    clients: TrendState
+    success: TrendState
+    requests: TrendState
+  }
+  logs: AuditLogEntry[]
+}
+
+
+export interface TimeSeriesData {
+  creates: any[]
+  reads: any[]
+  updates: any[]
+  deletes: any[]
+  metadata?: Record<string, any>
+}
+
+export interface DataSourceStrategy {
+  fetchGlobalStats(): Promise<DashboardData>
+  getChartData(period: string): Promise<TimeSeriesData>
+}

package/lib/prometheus/client.ts

@@ -0,0 +1,58 @@
+// Prefer explicit PROMETHEUS_URL, fall back to NEXT_PUBLIC, then local Prometheus default port (mapped to 9092 in docker-compose)
+export const PROMETHEUS_URL = process.env.PROMETHEUS_URL || process.env.NEXT_PUBLIC_PROMETHEUS_URL || 'http://localhost:9092'
+
+export interface PrometheusQueryResult {
+  status: string
+  data: {
+    resultType: string
+    result: Array<{
+      metric: Record<string, string>
+      value?: [number, string]
+      values?: Array<[number, string]>
+    }>
+  }
+}
+
+export async function query(promql: string): Promise<PrometheusQueryResult> {
+  try {
+    const controller = new AbortController()
+    const id = setTimeout(() => controller.abort(), 1500)
+
+    const response = await fetch(`${PROMETHEUS_URL}/api/v1/query?query=${encodeURIComponent(promql)}`, {
+      signal: controller.signal,
+      cache: 'no-store'
+    })
+    clearTimeout(id)
+
+    if (!response.ok) {
+      throw new Error(`Prometheus query failed: ${response.statusText}`)
+    }
+    return response.json()
+  } catch (error) {
+    console.error('Prometheus query failed:', error)
+    return { status: 'error', data: { resultType: 'vector', result: [] } }
+  }
+}
+
+export async function queryRange(promql: string, start: number, end: number, step: string = '1m'): Promise<PrometheusQueryResult> {
+  try {
+    const url = `${PROMETHEUS_URL}/api/v1/query_range?query=${encodeURIComponent(promql)}&start=${start}&end=${end}&step=${step}`
+
+    const controller = new AbortController()
+    const id = setTimeout(() => controller.abort(), 1500)
+
+    const response = await fetch(url, {
+      signal: controller.signal,
+      cache: 'no-store'
+    })
+    clearTimeout(id)
+
+    if (!response.ok) {
+       throw new Error(`Prometheus range query failed: ${response.statusText}`)
+    }
+    return response.json()
+  } catch (error) {
+    console.error('Prometheus range query failed:', error)
+    return { status: 'error', data: { resultType: 'matrix', result: [] } }
+  }
+}

package/lib/prometheus/index.ts

@@ -0,0 +1,6 @@
+export * from './client'
+export * from './metrics'
+export * from './sparklines'
+export * from './timeseries'
+export * from './utils'
+

package/lib/prometheus/metrics.ts

@@ -0,0 +1,234 @@
+import { query } from './client'
+import { toPromDuration } from './utils'
+
+export async function getTotalRequests(duration: string = '15m'): Promise<number> {
+  const result = await query('sum(openmemory_requests_total)')
+  return result.data.result[0]?.value ? parseFloat(result.data.result[0].value[1]) : 0
+}
+
+export async function getRequestsByClient(duration: string = '15m'): Promise<Record<string, number>> {
+  const result = await query('sum by (client_name) (openmemory_requests_total)')
+  const byClient: Record<string, number> = {}
+  result.data.result.forEach((item) => {
+    const clientId = item.metric.client_name || 'unknown'
+    byClient[clientId] = item.value ? parseFloat(item.value[1]) : 0
+  })
+  return byClient
+}
+
+export async function getRequestsByMethod(duration: string = '15m'): Promise<{ reads: Record<string, number>, writes: Record<string, number> }> {
+  // Reads = operation="read", Writes = operation="create"/"update"/"delete"
+  const readsResult = await query('sum by (client_name) (openmemory_requests_total{operation="read"})')
+  const writesResult = await query('sum by (client_name) (openmemory_requests_total{operation=~"create|update|delete"})')
+  const writes: Record<string, number> = {}
+  const reads: Record<string, number> = {}
+
+  readsResult.data.result.forEach((item) => {
+    const clientId = item.metric.client_name || 'unknown'
+    reads[clientId] = item.value ? parseFloat(item.value[1]) : 0
+  })
+
+  writesResult.data.result.forEach((item) => {
+    const clientId = item.metric.client_name || 'unknown'
+    writes[clientId] = item.value ? parseFloat(item.value[1]) : 0
+  })
+
+  return { reads, writes }
+}
+
+export async function getSuccessRate(): Promise<number> {
+  const result = await query('openmemory_success_rate_aggregate')
+  return result.data.result[0]?.value ? parseFloat(result.data.result[0].value[1]) : 100
+}
+
+export async function getMemoryRecordsCount(): Promise<number> {
+  // Get total memories across all clients
+  const result = await query('sum(openmemory_memories_total)')
+  return result.data.result[0]?.value ? parseFloat(result.data.result[0].value[1]) : 0
+}
+
+export async function getClientCount(): Promise<number> {
+  const result = await query('count(count by (client_name) (openmemory_memories_total))')
+  return result.data.result[0]?.value ? parseFloat(result.data.result[0].value[1]) : 0
+}
+
+export async function getSuccessRateByClient(): Promise<Record<string, number>> {
+  // Calculate success rate from request status codes
+  // Success = not 4xx or 5xx, Failure = status 4xx or 5xx
+  const [totalResult, successResult] = await Promise.all([
+    query('sum by (client_name) (openmemory_requests_total)'),
+    query('sum by (client_name) (openmemory_requests_total{status=~"2..|3.."})')
+  ])
+
+  const rates: Record<string, number> = {}
+
+  // First, initialize all clients with 0% (in case they have no successful requests)
+  totalResult.data.result.forEach((item) => {
+    const clientId = item.metric.client_name || 'unknown'
+    rates[clientId] = 0
+  })
+
+  // Then calculate success rate for clients with successful requests
+  successResult.data.result.forEach((item) => {
+    const clientId = item.metric.client_name || 'unknown'
+    const successCount = item.value ? parseFloat(item.value[1]) : 0
+
+    // Find total count for this client
+    const totalItem = totalResult.data.result.find(t => (t.metric.client_name || 'unknown') === clientId)
+    const totalCount = totalItem?.value ? parseFloat(totalItem.value[1]) : 0
+
+    if (totalCount > 0) {
+      rates[clientId] = (successCount / totalCount) * 100
+    }
+  })
+
+  return rates
+}
+
+export async function getTopWriter(duration: string = '15m'): Promise<{ name: string, count: number }> {
+  // Get client with most write requests in the specified duration
+  const promDuration = toPromDuration(duration)
+
+  // Try with increase() first (deltas)
+  let queryStr = `topk(1, sum by (client_name) (increase(openmemory_requests_total{operation=~"create|update|delete"}[${promDuration}])))`
+  let result = await query(queryStr)
+
+  // Fallback: If no increase detected (singular data point or very low traffic),
+  if (result.data.result.length === 0) {
+     // First fallback: Check raw total requests
+     queryStr = `topk(1, sum by (client_name) (openmemory_requests_total{operation=~"create|update|delete"}))`
+     result = await query(queryStr)
+
+     // Second fallback: Check actual memories stored (from db-exporter, reliable)
+     if (result.data.result.length === 0) {
+        queryStr = `topk(1, sum by (client) (openmemory_memories_total))`
+        result = await query(queryStr)
+     }
+  }
+
+  if (result.data.result.length === 0) {
+    return { name: 'N/A', count: 0 }
+  }
+
+  const item = result.data.result[0]
+  let count = item.value ? Math.round(parseFloat(item.value[1])) : 0
+  const rawName = item.metric.client_name || item.metric.client || 'unknown'
+
+  return {
+    name: rawName,
+    count
+  }
+}
+
+export async function getTopReader(duration: string = '15m'): Promise<{ name: string, count: number }> {
+  // Get client with most read requests in the specified duration
+  const promDuration = toPromDuration(duration)
+  const result = await query(`topk(1, sum by (client_name) (increase(openmemory_requests_total{operation="read"}[${promDuration}])))`)
+
+  if (result.data.result.length === 0) {
+     // Fallback to raw total requests (Traefik) only
+     const valResult = await query(`topk(1, sum by (client_name) (openmemory_requests_total{operation="read"}))`)
+     result.data.result = valResult.data.result
+  }
+
+  if (result.data.result.length === 0) {
+      return { name: 'N/A', count: 0 }
+  }
+
+  const item = result.data.result[0]
+  const count = item.value ? Math.round(parseFloat(item.value[1])) : 0
+  const rawName = item.metric.client_name || 'unknown'
+
+  return {
+    name: rawName,
+    count
+  }
+}
+
+export async function getLastWriter(): Promise<{ name: string, timestamp: number }> {
+  try {
+    // Look for writers in the last 1h
+    const result = await query('topk(1, sum by (client_name) (increase(openmemory_requests_total{operation=~"create|update|delete"}[1h])))')
+
+    if (result.data.result.length > 0 && result.data.result[0].value) {
+      const item = result.data.result[0]
+      const count = item.value ? parseFloat(item.value[1]) : 0
+      if (count > 0) {
+         const rawName = item.metric.client_name || 'unknown'
+         return {
+          name: rawName,
+          timestamp: Date.now()
+        }
+      }
+    }
+
+    // Fallback: Check total requests (lifetime) - still within Traefik source
+    const totalResult = await query('topk(1, sum by (client_name) (openmemory_requests_total{operation=~"create|update|delete"}))')
+    if (totalResult.data.result.length > 0) {
+        const item = totalResult.data.result[0]
+        if (item?.value) {
+          const rawName = item.metric.client_name || 'unknown'
+          return {
+              name: rawName,
+              timestamp: Date.now() // Approximate
+          }
+        }
+    }
+
+  } catch (e) {
+    console.error('getLastWriter error:', e)
+  }
+  return { name: 'N/A', timestamp: 0 }
+}
+
+export async function getLastReader(): Promise<{ name: string, timestamp: number }> {
+  try {
+    // Look for readers in the last 5 minutes to identify "current/last" activity
+    const result = await query('topk(1, sum by (client_name) (increase(openmemory_requests_total{operation="read"}[5m])))')
+
+    if (result.data.result.length > 0 && result.data.result[0].value) {
+      const count = parseFloat(result.data.result[0].value[1])
+      if (count > 0) {
+        const rawName = result.data.result[0].metric.client_name || 'unknown'
+        return {
+          name: rawName,
+          timestamp: Date.now()
+        }
+      }
+    }
+
+    // Fallback: look at total reads (lifetime) if no recent increase
+    const totalResult = await query('topk(1, sum by (client_name) (openmemory_requests_total{operation="read"}))')
+    if (totalResult.data.result.length > 0) {
+       const item = totalResult.data.result[0]
+       if (item?.value) {
+          const rawName = item.metric.client_name || 'unknown'
+          return {
+             name: rawName,
+             timestamp: Date.now() // Approximate
+          }
+       }
+    }
+  } catch (e) {
+    console.error('getLastReader error:', e)
+  }
+  return { name: 'N/A', timestamp: 0 }
+}
+
+// Get all active clients in a period
+export async function getAllActiveClients(duration: string = '1h'): Promise<string[]> {
+  const promDuration = toPromDuration(duration)
+
+  // Use instant query with increase() over the whole duration to find clients with ANY activity
+  const result = await query(
+    `sum by (client_name) (increase(openmemory_requests_total[${promDuration}])) > 0`
+  )
+
+  const clients = new Set<string>()
+  result.data.result.forEach((series) => {
+    const clientName = series.metric.client_name || 'unknown'
+    clients.add(clientName)
+  })
+
+  return Array.from(clients)
+}

package/lib/prometheus/sparklines.ts

@@ -0,0 +1,71 @@
+import { queryRange } from './client'
+import { fillSparklineData, parseDuration } from './utils'
+
+// Sparkline data - cumulative counts over time
+export async function getMemoryRecordsSparkline(duration: string = '15m'): Promise<number[]> {
+  const now = Math.floor(Date.now() / 1000)
+  const start = now - parseDuration(duration)
+
+  const result = await queryRange(
+    'sum(openmemory_memories_total)',
+    start,
+    now,
+    '30s'
+  )
+
+  const series = result.data.result[0]
+  if (!series || !series.values) return Array(Math.ceil((now - start) / 30)).fill(0)
+
+  return fillSparklineData(series.values, start, now, 30)
+}
+
+export async function getTotalRequestsSparkline(duration: string = '15m'): Promise<number[]> {
+  const now = Math.floor(Date.now() / 1000)
+  const start = now - parseDuration(duration)
+
+  const result = await queryRange(
+    'sum(openmemory_requests_total)',
+    start,
+    now,
+    '30s'
+  )
+
+  const series = result.data.result[0]
+  if (!series || !series.values) return Array(Math.ceil((now - start) / 30)).fill(0)
+
+  return fillSparklineData(series.values, start, now, 30)
+}
+
+export async function getTotalClientsSparkline(duration: string = '15m'): Promise<number[]> {
+  const now = Math.floor(Date.now() / 1000)
+  const start = now - parseDuration(duration)
+
+  const result = await queryRange(
+    'count(count by (client_name) (openmemory_memories_total))',
+    start,
+    now,
+    '30s'
+  )
+
+  const series = result.data.result[0]
+  if (!series || !series.values) return Array(Math.ceil((now - start) / 30)).fill(0)
+
+  return fillSparklineData(series.values, start, now, 30)
+}
+
+export async function getSuccessRateSparkline(duration: string = '15m'): Promise<number[]> {
+  const now = Math.floor(Date.now() / 1000)
+  const start = now - parseDuration(duration)
+
+  const result = await queryRange(
+    'openmemory_success_rate_aggregate',
+    start,
+    now,
+    '30s'
+  )
+
+  const series = result.data.result[0]
+  if (!series || !series.values) return Array(Math.ceil((now - start) / 30)).fill(100)
+
+  return fillSparklineData(series.values, start, now, 30, 100)
+}