qa360 2.1.7 → 2.2.1

package/core/src/slo/vault.ts

@@ -0,0 +1,600 @@
+/**
+ * SLO/SLI Vault Integration
+ *
+ * Integrates SLO/SLI data storage and retrieval with the Evidence Vault.
+ */
+
+import type { Database } from 'sqlite3';
+import type { SLO, SLI, SLIMeasurement, SLOReport, SLOViolation, SLOStatus } from './types.js';
+import { promisify } from 'util';
+
+/**
+ * SLO record for storage
+ */
+interface SLORecord {
+  id: string;
+  name: string;
+  description?: string;
+  sli_ids: string; // JSON array
+  target: number;
+  window_ms: number;
+  error_budget_json: string;
+  status: string;
+  current_value?: number;
+  tags?: string; // JSON array
+  owner?: string;
+  created_at: number;
+  updated_at: number;
+}
+
+/**
+ * SLI record for storage
+ */
+interface SLIRecord {
+  id: string;
+  name: string;
+  description?: string;
+  type: string;
+  source: string;
+  query_json: string;
+  aggregation: string;
+  unit: string;
+  threshold_json: string;
+  category: string;
+  tags?: string; // JSON array
+  created_at: number;
+  updated_at: number;
+}
+
+/**
+ * SLI measurement record
+ */
+interface MeasurementRecord {
+  id?: number;
+  sli_id: string;
+  run_id?: string;
+  timestamp: number;
+  value: number;
+  total?: number;
+  good?: number;
+  bad?: number;
+  unit: string;
+  window_start: number;
+  window_end: number;
+}
+
+/**
+ * SLO violation record
+ */
+interface ViolationRecord {
+  id?: number;
+  slo_id: string;
+  timestamp: number;
+  value: number;
+  expected: number;
+  severity: 'warning' | 'critical';
+  context_json?: string;
+  resolved: number; // 0 or 1
+  resolved_at?: number;
+}
+
+/**
+ * SLO Vault class
+ */
+export class SLOVault {
+  private db: Database;
+  private dbRun: (sql: string, params: any[]) => Promise<any>;
+  private dbAll: (sql: string, params: any[]) => Promise<any[]>;
+  private dbGet: (sql: string, params: any[]) => Promise<any>;
+
+  constructor(db: Database) {
+    this.db = db;
+    this.dbRun = promisify(db.run.bind(db)) as any;
+    this.dbAll = promisify(db.all.bind(db)) as any;
+    this.dbGet = promisify(db.get.bind(db)) as any;
+  }
+
+  /**
+   * Initialize SLO/SLI tables
+   */
+  async initialize(): Promise<void> {
+    const schema = `
+      -- SLO definitions table
+      CREATE TABLE IF NOT EXISTS slo_definitions (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT,
+          sli_ids TEXT NOT NULL,
+          target REAL NOT NULL,
+          window_ms INTEGER NOT NULL,
+          error_budget_json TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'unknown',
+          current_value REAL,
+          tags TEXT,
+          owner TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_status ON slo_definitions(status);
+      CREATE INDEX IF NOT EXISTS idx_slo_owner ON slo_definitions(owner);
+      CREATE INDEX IF NOT EXISTS idx_slo_tags ON slo_definitions(tags);
+
+      -- SLI definitions table
+      CREATE TABLE IF NOT EXISTS sli_definitions (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          description TEXT,
+          type TEXT NOT NULL,
+          source TEXT NOT NULL,
+          query_json TEXT NOT NULL,
+          aggregation TEXT NOT NULL,
+          unit TEXT NOT NULL,
+          threshold_json TEXT NOT NULL,
+          category TEXT NOT NULL,
+          tags TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sli_type ON sli_definitions(type);
+      CREATE INDEX IF NOT EXISTS idx_sli_category ON sli_definitions(category);
+
+      -- SLI measurements table
+      CREATE TABLE IF NOT EXISTS sli_measurements (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          sli_id TEXT NOT NULL REFERENCES sli_definitions(id) ON DELETE CASCADE,
+          run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+          timestamp INTEGER NOT NULL,
+          value REAL NOT NULL,
+          total INTEGER,
+          good INTEGER,
+          bad INTEGER,
+          unit TEXT NOT NULL,
+          window_start INTEGER NOT NULL,
+          window_end INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_sli_id ON sli_measurements(sli_id);
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_run_id ON sli_measurements(run_id);
+      CREATE INDEX IF NOT EXISTS idx_sli_measurements_timestamp ON sli_measurements(timestamp);
+
+      -- SLO violations table
+      CREATE TABLE IF NOT EXISTS slo_violations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          slo_id TEXT NOT NULL REFERENCES slo_definitions(id) ON DELETE CASCADE,
+          timestamp INTEGER NOT NULL,
+          value REAL NOT NULL,
+          expected REAL NOT NULL,
+          severity TEXT NOT NULL,
+          context_json TEXT,
+          resolved INTEGER DEFAULT 0,
+          resolved_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_slo_id ON slo_violations(slo_id);
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_timestamp ON slo_violations(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_slo_violations_resolved ON slo_violations(resolved);
+
+      -- SLO snapshots (aggregated SLO status over time)
+      CREATE TABLE IF NOT EXISTS slo_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          slo_id TEXT NOT NULL REFERENCES slo_definitions(id) ON DELETE CASCADE,
+          run_id TEXT REFERENCES runs(id) ON DELETE SET NULL,
+          timestamp INTEGER NOT NULL,
+          current_value REAL NOT NULL,
+          target REAL NOT NULL,
+          status TEXT NOT NULL,
+          error_budget_remaining REAL NOT NULL,
+          burn_rate REAL,
+          window_start INTEGER NOT NULL,
+          window_end INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_slo_snapshots_slo_id ON slo_snapshots(slo_id);
+      CREATE INDEX IF NOT EXISTS idx_slo_snapshots_timestamp ON slo_snapshots(timestamp);
+    `;
+
+    const statements = schema
+      .split(';')
+      .map(s => s.trim())
+      .filter(s => s.length > 0);
+
+    for (const statement of statements) {
+      await this.dbRun(statement, []);
+    }
+  }
+
+  /**
+   * Store an SLO definition
+   */
+  async storeSLO(slo: SLO): Promise<void> {
+    await this.dbRun(
+      `INSERT OR REPLACE INTO slo_definitions (
+        id, name, description, sli_ids, target, window_ms,
+        error_budget_json, status, current_value, tags, owner,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        slo.id,
+        slo.name,
+        slo.description || null,
+        JSON.stringify(slo.sliIds),
+        slo.target,
+        slo.windowMs,
+        JSON.stringify(slo.errorBudget),
+        slo.status,
+        slo.currentValue || null,
+        slo.tags ? JSON.stringify(slo.tags) : null,
+        slo.owner || null,
+        slo.createdAt,
+        Date.now()
+      ]
+    );
+  }
+
+  /**
+   * Store an SLI definition
+   */
+  async storeSLI(sli: SLI): Promise<void> {
+    await this.dbRun(
+      `INSERT OR REPLACE INTO sli_definitions (
+        id, name, description, type, source, query_json,
+        aggregation, unit, threshold_json, category, tags,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        sli.id,
+        sli.name,
+        sli.description || null,
+        sli.type,
+        sli.source,
+        JSON.stringify(sli.query),
+        sli.aggregation,
+        sli.unit,
+        JSON.stringify(sli.threshold),
+        sli.category,
+        sli.tags ? JSON.stringify(sli.tags) : null,
+        sli.createdAt,
+        Date.now()
+      ]
+    );
+  }
+
+  /**
+   * Store an SLI measurement
+   */
+  async storeMeasurement(measurement: SLIMeasurement, runId?: string): Promise<void> {
+    await this.dbRun(
+      `INSERT INTO sli_measurements (
+        sli_id, run_id, timestamp, value, total, good, bad,
+        unit, window_start, window_end
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        measurement.sliId,
+        runId || null,
+        measurement.timestamp,
+        measurement.value,
+        measurement.total || null,
+        measurement.good || null,
+        measurement.bad || null,
+        measurement.unit,
+        measurement.windowStart,
+        measurement.windowEnd
+      ]
+    );
+  }
+
+  /**
+   * Store an SLO snapshot
+   */
+  async storeSLOSnapshot(
+    sloId: string,
+    data: {
+      currentValue: number;
+      target: number;
+      status: SLOStatus;
+      errorBudgetRemaining: number;
+      burnRate?: number;
+      windowStart: number;
+      windowEnd: number;
+    },
+    runId?: string
+  ): Promise<void> {
+    await this.dbRun(
+      `INSERT INTO slo_snapshots (
+        slo_id, run_id, timestamp, current_value, target, status,
+        error_budget_remaining, burn_rate, window_start, window_end
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        sloId,
+        runId || null,
+        Date.now(),
+        data.currentValue,
+        data.target,
+        data.status,
+        data.errorBudgetRemaining,
+        data.burnRate || null,
+        data.windowStart,
+        data.windowEnd
+      ]
+    );
+  }
+
+  /**
+   * Store an SLO violation
+   */
+  async storeViolation(violation: SLOViolation): Promise<void> {
+    await this.dbRun(
+      `INSERT INTO slo_violations (
+        slo_id, timestamp, value, expected, severity,
+        context_json, resolved, resolved_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        violation.sloId,
+        violation.timestamp,
+        violation.value,
+        violation.expected,
+        violation.severity,
+        violation.context ? JSON.stringify(violation.context) : null,
+        violation.resolved ? 1 : 0,
+        violation.resolvedAt || null
+      ]
+    );
+  }
+
+  /**
+   * Get all SLO definitions
+   */
+  async getSLOs(): Promise<SLO[]> {
+    const rows = await this.dbAll(`SELECT * FROM slo_definitions`, []);
+
+    return rows.map((r: SLORecord) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      sliIds: JSON.parse(r.sli_ids),
+      target: r.target,
+      windowMs: r.window_ms,
+      errorBudget: JSON.parse(r.error_budget_json),
+      status: r.status as SLOStatus,
+      currentValue: r.current_value,
+      tags: r.tags ? JSON.parse(r.tags) : undefined,
+      owner: r.owner,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    }));
+  }
+
+  /**
+   * Get an SLO by ID
+   */
+  async getSLO(id: string): Promise<SLO | null> {
+    const row = await this.dbGet(`SELECT * FROM slo_definitions WHERE id = ?`, [id]);
+
+    if (!row) return null;
+
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      sliIds: JSON.parse(row.sli_ids),
+      target: row.target,
+      windowMs: row.window_ms,
+      errorBudget: JSON.parse(row.error_budget_json),
+      status: row.status as SLOStatus,
+      currentValue: row.current_value,
+      tags: row.tags ? JSON.parse(row.tags) : undefined,
+      owner: row.owner,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+
+  /**
+   * Get all SLI definitions
+   */
+  async getSLIs(): Promise<SLI[]> {
+    const rows = await this.dbAll(`SELECT * FROM sli_definitions`, []);
+
+    return rows.map((r: SLIRecord) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      type: r.type as any,
+      source: r.source as any,
+      query: JSON.parse(r.query_json),
+      aggregation: r.aggregation as any,
+      unit: r.unit as any,
+      threshold: JSON.parse(r.threshold_json),
+      category: r.category as any,
+      tags: r.tags ? JSON.parse(r.tags) : undefined,
+      createdAt: r.created_at,
+      updatedAt: r.updated_at
+    }));
+  }
+
+  /**
+   * Get measurements for an SLI
+   */
+  async getMeasurements(
+    sliId: string,
+    windowStart?: number,
+    windowEnd?: number,
+    limit = 1000
+  ): Promise<SLIMeasurement[]> {
+    let sql = `SELECT * FROM sli_measurements WHERE sli_id = ?`;
+    const params: any[] = [sliId];
+
+    if (windowStart) {
+      sql += ` AND timestamp >= ?`;
+      params.push(windowStart);
+    }
+    if (windowEnd) {
+      sql += ` AND timestamp <= ?`;
+      params.push(windowEnd);
+    }
+
+    sql += ` ORDER BY timestamp DESC LIMIT ?`;
+    params.push(limit);
+
+    const rows = await this.dbAll(sql, params);
+
+    return rows.map((r: MeasurementRecord) => ({
+      sliId: r.sli_id,
+      timestamp: r.timestamp,
+      value: r.value,
+      total: r.total,
+      good: r.good,
+      bad: r.bad,
+      unit: r.unit as any,
+      windowStart: r.window_start,
+      windowEnd: r.window_end
+    }));
+  }
+
+  /**
+   * Get violations for an SLO
+   */
+  async getViolations(sloId?: string, resolved?: boolean): Promise<SLOViolation[]> {
+    let sql = `SELECT * FROM slo_violations WHERE 1=1`;
+    const params: any[] = [];
+
+    if (sloId) {
+      sql += ` AND slo_id = ?`;
+      params.push(sloId);
+    }
+    if (resolved !== undefined) {
+      sql += ` AND resolved = ?`;
+      params.push(resolved ? 1 : 0);
+    }
+
+    sql += ` ORDER BY timestamp DESC`;
+
+    const rows = await this.dbAll(sql, params);
+
+    return rows.map((r: ViolationRecord) => ({
+      id: r.id?.toString() || '',
+      sloId: r.slo_id,
+      timestamp: r.timestamp,
+      value: r.value,
+      expected: r.expected,
+      severity: r.severity,
+      context: r.context_json ? JSON.parse(r.context_json) : undefined,
+      resolved: r.resolved === 1,
+      resolvedAt: r.resolved_at
+    }));
+  }
+
+  /**
+   * Get SLO snapshots for trend analysis
+   */
+  async getSLOSnapshots(
+    sloId: string,
+    windowStart?: number,
+    windowEnd?: number,
+    limit = 100
+  ): Promise<Array<{
+    timestamp: number;
+    currentValue: number;
+    target: number;
+    status: SLOStatus;
+    errorBudgetRemaining: number;
+    burnRate?: number;
+  }>> {
+    let sql = `SELECT * FROM slo_snapshots WHERE slo_id = ?`;
+    const params: any[] = [sloId];
+
+    if (windowStart) {
+      sql += ` AND timestamp >= ?`;
+      params.push(windowStart);
+    }
+    if (windowEnd) {
+      sql += ` AND timestamp <= ?`;
+      params.push(windowEnd);
+    }
+
+    sql += ` ORDER BY timestamp DESC LIMIT ?`;
+    params.push(limit);
+
+    const rows = await this.dbAll(sql, params);
+
+    return rows.map((r: any) => ({
+      timestamp: r.timestamp,
+      currentValue: r.current_value,
+      target: r.target,
+      status: r.status as SLOStatus,
+      errorBudgetRemaining: r.error_budget_remaining,
+      burnRate: r.burn_rate
+    }));
+  }
+
+  /**
+   * Delete an SLO and its associated data
+   */
+  async deleteSLO(id: string): Promise<void> {
+    await this.dbRun(`DELETE FROM slo_definitions WHERE id = ?`, [id]);
+  }
+
+  /**
+   * Delete an SLI and its associated data
+   */
+  async deleteSLI(id: string): Promise<void> {
+    await this.dbRun(`DELETE FROM sli_definitions WHERE id = ?`, [id]);
+  }
+
+  /**
+   * Resolve a violation
+   */
+  async resolveViolation(violationId: string): Promise<void> {
+    await this.dbRun(
+      `UPDATE slo_violations SET resolved = 1, resolved_at = ? WHERE id = ?`,
+      [Date.now(), parseInt(violationId, 10)]
+    );
+  }
+
+  /**
+   * Get SLO statistics
+   */
+  async getStatistics(): Promise<{
+    totalSLOs: number;
+    totalSLIs: number;
+    statusCounts: Record<SLOStatus, number>;
+    activeViolations: number;
+    totalMeasurements: number;
+  }> {
+    const totalSLOs = await this.dbGet(`SELECT COUNT(*) as count FROM slo_definitions`, []);
+    const totalSLIs = await this.dbGet(`SELECT COUNT(*) as count FROM sli_definitions`, []);
+    const statusCounts = await this.dbAll(
+      `SELECT status, COUNT(*) as count FROM slo_definitions GROUP BY status`,
+      []
+    );
+    const activeViolations = await this.dbGet(
+      `SELECT COUNT(*) as count FROM slo_violations WHERE resolved = 0`,
+      []
+    );
+    const totalMeasurements = await this.dbGet(
+      `SELECT COUNT(*) as count FROM sli_measurements`,
+      []
+    );
+
+    const statusMap: Record<SLOStatus, number> = {
+      healthy: 0,
+      warning: 0,
+      breached: 0,
+      unknown: 0
+    };
+
+    for (const row of statusCounts) {
+      statusMap[row.status as SLOStatus] = row.count;
+    }
+
+    return {
+      totalSLOs: totalSLOs?.count || 0,
+      totalSLIs: totalSLIs?.count || 0,
+      statusCounts: statusMap,
+      activeViolations: activeViolations?.count || 0,
+      totalMeasurements: totalMeasurements?.count || 0
+    };
+  }
+}