@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-7YAOUUKK.js

@@ -0,0 +1,493 @@
+import {
+  redactPersistedTelemetryString
+} from "./chunk-WV3KQDPE.js";
+
+// src/telemetry/telemetry-health-tracker.ts
+import { randomUUID } from "crypto";
+var TelemetryHealthTracker = class _TelemetryHealthTracker {
+  db;
+  /** Operation count for error rate calculation. Thread-safe in Node.js single-threaded context. */
+  operationCount = 0;
+  static buildId(prefix) {
+    return `${prefix}-${randomUUID()}`;
+  }
+  lastResetTime = Date.now();
+  normalizeResolvedValue(resolved) {
+    if (typeof resolved === "boolean") {
+      return resolved;
+    }
+    if (typeof resolved === "number") {
+      return resolved !== 0;
+    }
+    if (typeof resolved === "string") {
+      const normalized = resolved.trim().toLowerCase();
+      return normalized === "1" || normalized === "true" || normalized === "yes";
+    }
+    return false;
+  }
+  normalizeErrorRow(row) {
+    return {
+      ...row,
+      resolved: this.normalizeResolvedValue(row.resolved)
+    };
+  }
+  /**
+   * Create a new health tracker
+   *
+   * @param db - SQLite database connection
+   */
+  constructor(db) {
+    this.db = db;
+    this.createSchema();
+  }
+  /**
+   * Create database schema for health tracking
+   */
+  createSchema() {
+    try {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS telemetry_errors (
+          id TEXT PRIMARY KEY,
+          timestamp TEXT NOT NULL,
+          operation TEXT NOT NULL,
+          error_type TEXT NOT NULL,
+          error_message TEXT NOT NULL,
+          context_json TEXT,
+          task_id TEXT,
+          resolved INTEGER DEFAULT 0,
+          resolved_at TEXT,
+          created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_telemetry_errors_timestamp
+          ON telemetry_errors(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_telemetry_errors_task_id
+          ON telemetry_errors(task_id);
+        CREATE INDEX IF NOT EXISTS idx_telemetry_errors_operation
+          ON telemetry_errors(operation);
+        CREATE INDEX IF NOT EXISTS idx_telemetry_errors_resolved
+          ON telemetry_errors(resolved);
+
+        -- Queue depth snapshots table
+        CREATE TABLE IF NOT EXISTS queue_depth_snapshots (
+          id TEXT PRIMARY KEY,
+          timestamp TEXT NOT NULL,
+          queue_depth INTEGER NOT NULL,
+          flush_interval_ms INTEGER,
+          fallback_active INTEGER DEFAULT 0
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_queue_snapshots_timestamp
+          ON queue_depth_snapshots(timestamp);
+
+        -- Fallback events table
+        CREATE TABLE IF NOT EXISTS fallback_events (
+          id TEXT PRIMARY KEY,
+          timestamp TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          reason TEXT,
+          duration_ms INTEGER
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_fallback_events_timestamp
+          ON fallback_events(timestamp);
+      `);
+    } catch (error) {
+      console.warn(
+        "Failed to create telemetry health tracking schema:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Log a telemetry error
+   *
+   * @param error - Error details (id will be auto-generated if not provided)
+   */
+  logError(error) {
+    const id = error.id || _TelemetryHealthTracker.buildId("err");
+    if (!this.isDbOpen()) {
+      return;
+    }
+    try {
+      this.db.prepare(
+        `
+        INSERT INTO telemetry_errors (
+          id, timestamp, operation, error_type, error_message,
+          context_json, task_id, resolved
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `
+      ).run(
+        id,
+        error.timestamp,
+        error.operation,
+        error.error_type,
+        redactPersistedTelemetryString(error.error_message),
+        typeof error.context_json === "string" ? redactPersistedTelemetryString(error.context_json) : error.context_json,
+        error.task_id || null,
+        error.resolved ? 1 : 0
+      );
+    } catch (dbError) {
+      console.warn("Failed to log telemetry error:", dbError);
+    }
+  }
+  /**
+   * Check whether the underlying DB connection is still open.
+   *
+   * better-sqlite3 exposes `Database#open` (boolean). We use optional chaining
+   * so this degrades gracefully when the DB is a noop adapter or mock.
+   */
+  isDbOpen() {
+    const db = this.db;
+    return db.open !== false;
+  }
+  /**
+   * Get recent errors since a specific timestamp
+   *
+   * @param sinceTimestamp - ISO 8601 timestamp
+   * @param limit - Maximum number of errors to return
+   * @returns Array of telemetry errors
+   */
+  getRecentErrors(sinceTimestamp, limit = 100) {
+    if (!this.isDbOpen()) {
+      return [];
+    }
+    try {
+      const rows = this.db.prepare(
+        `
+	        SELECT * FROM telemetry_errors
+	        WHERE timestamp >= ?
+	        ORDER BY timestamp DESC
+	        LIMIT ?
+	      `
+      ).all(sinceTimestamp, limit);
+      return rows.map((row) => this.normalizeErrorRow(row));
+    } catch (error) {
+      console.warn("Failed to query recent errors:", error);
+      return [];
+    }
+  }
+  /**
+   * Get errors for a specific task
+   *
+   * @param taskId - Task ID
+   * @returns Array of telemetry errors
+   */
+  getErrorsForTask(taskId) {
+    if (!this.isDbOpen()) {
+      return [];
+    }
+    try {
+      const rows = this.db.prepare(
+        `
+	        SELECT * FROM telemetry_errors
+	        WHERE task_id = ?
+	        ORDER BY timestamp DESC
+	      `
+      ).all(taskId);
+      return rows.map((row) => this.normalizeErrorRow(row));
+    } catch (error) {
+      console.warn("Failed to query task errors:", error);
+      return [];
+    }
+  }
+  /**
+   * Get health metrics for telemetry system
+   *
+   * @param queueDepth - Current event queue depth
+   * @param fallbackActive - Whether fallback mode is active
+   * @returns Health metrics
+   */
+  getHealthMetrics(queueDepth, fallbackActive) {
+    if (!this.isDbOpen()) {
+      return {
+        error_rate: 0,
+        fallback_mode_active: fallbackActive,
+        queue_depth: queueDepth,
+        last_error_timestamp: void 0,
+        errors_last_hour: 0,
+        unresolved_errors: 0,
+        database_healthy: false
+      };
+    }
+    const oneHourAgo = new Date(Date.now() - 36e5).toISOString();
+    let errorsLastHour = 0;
+    let unresolvedErrors = 0;
+    let lastErrorTimestamp;
+    let dbQueryFailed = false;
+    try {
+      const hourlyCount = this.db.prepare(
+        `
+        SELECT COUNT(*) as count FROM telemetry_errors
+        WHERE timestamp >= ?
+      `
+      ).get(oneHourAgo);
+      errorsLastHour = hourlyCount.count;
+      const unresolvedCount = this.db.prepare(
+        `
+        SELECT COUNT(*) as count FROM telemetry_errors
+        WHERE resolved = 0
+      `
+      ).get();
+      unresolvedErrors = unresolvedCount.count;
+      const lastError = this.db.prepare(
+        `
+        SELECT timestamp FROM telemetry_errors
+        ORDER BY timestamp DESC
+        LIMIT 1
+      `
+      ).get();
+      lastErrorTimestamp = lastError?.timestamp;
+    } catch (error) {
+      dbQueryFailed = true;
+      console.warn("Failed to calculate health metrics:", error);
+    }
+    const now = Date.now();
+    const operationCountSnapshot = this.operationCount;
+    const errorRate = operationCountSnapshot > 0 ? errorsLastHour / operationCountSnapshot : 0;
+    if (now - this.lastResetTime > 36e5) {
+      this.operationCount = 0;
+      this.lastResetTime = now;
+    }
+    return {
+      error_rate: errorRate,
+      fallback_mode_active: fallbackActive,
+      queue_depth: queueDepth,
+      last_error_timestamp: lastErrorTimestamp,
+      errors_last_hour: errorsLastHour,
+      unresolved_errors: unresolvedErrors,
+      database_healthy: !fallbackActive && !dbQueryFailed && unresolvedErrors === 0
+    };
+  }
+  /**
+   * Increment operation counter for error rate calculation
+   *
+   * Note: This operation is safe in Node.js single-threaded execution model.
+   * The increment is atomic within JavaScript's event loop.
+   */
+  incrementOperationCount() {
+    this.operationCount++;
+  }
+  /**
+   * Mark an error as resolved
+   *
+   * @param errorId - Error ID to mark as resolved
+   */
+  resolveError(errorId) {
+    if (!this.isDbOpen()) {
+      return;
+    }
+    try {
+      const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.db.prepare(
+        `
+        UPDATE telemetry_errors
+        SET resolved = 1, resolved_at = ?
+        WHERE id = ?
+      `
+      ).run(resolvedAt, errorId);
+    } catch (error) {
+      console.warn("Failed to resolve error:", error);
+    }
+  }
+  /**
+   * Mark all unresolved errors of a specific type as resolved
+   *
+   * @param errorType - Error type to resolve
+   * @returns Number of errors resolved
+   */
+  resolveErrorsByType(errorType) {
+    if (!this.isDbOpen()) {
+      return 0;
+    }
+    try {
+      const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const result = this.db.prepare(
+        `
+        UPDATE telemetry_errors
+        SET resolved = 1, resolved_at = ?
+        WHERE error_type = ? AND resolved = 0
+      `
+      ).run(resolvedAt, errorType);
+      return result.changes;
+    } catch (error) {
+      console.warn("Failed to resolve errors by type:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get error statistics by operation
+   *
+   * @returns Map of operation name to error count
+   */
+  getErrorStatsByOperation() {
+    const stats = /* @__PURE__ */ new Map();
+    if (!this.isDbOpen()) {
+      return stats;
+    }
+    try {
+      const results = this.db.prepare(
+        `
+        SELECT operation, COUNT(*) as count
+        FROM telemetry_errors
+        WHERE resolved = 0
+        GROUP BY operation
+        ORDER BY count DESC
+      `
+      ).all();
+      for (const row of results) {
+        stats.set(row.operation, row.count);
+      }
+    } catch (error) {
+      console.warn("Failed to get error stats:", error);
+    }
+    return stats;
+  }
+  /**
+   * Clean up old resolved errors
+   *
+   * @param olderThan - Delete errors older than this timestamp
+   * @returns Number of errors deleted
+   */
+  cleanupOldErrors(olderThan) {
+    if (!this.isDbOpen()) {
+      return 0;
+    }
+    try {
+      const result = this.db.prepare(
+        `
+        DELETE FROM telemetry_errors
+        WHERE resolved = 1 AND timestamp < ?
+      `
+      ).run(olderThan);
+      return result.changes;
+    } catch (error) {
+      console.warn("Failed to cleanup old errors:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get total error count
+   *
+   * @returns Total number of errors in database
+   */
+  getTotalErrorCount() {
+    if (!this.isDbOpen()) {
+      return 0;
+    }
+    try {
+      const result = this.db.prepare("SELECT COUNT(*) as count FROM telemetry_errors").get();
+      return result.count;
+    } catch (error) {
+      console.warn("Failed to get total error count:", error);
+      return 0;
+    }
+  }
+  /**
+   * Calculate MTTR (Mean Time To Resolution) metrics
+   *
+   * @param timeWindowHours - Time window in hours for calculation (default: 24)
+   * @returns MTTR metrics
+   */
+  calculateMTTR(timeWindowHours = 24) {
+    if (!this.isDbOpen()) {
+      return {
+        mean_time_to_resolution: 0,
+        median_resolution_time: 0,
+        p50_resolution_time: 0,
+        p95_resolution_time: 0,
+        p99_resolution_time: 0,
+        mtbf: 0,
+        error_count_last_24h: 0,
+        resolution_rate: 0,
+        resolved_count: 0,
+        unresolved_count: 0
+      };
+    }
+    const timeWindowMs = timeWindowHours * 36e5;
+    const cutoffTime = new Date(Date.now() - timeWindowMs).toISOString();
+    try {
+      const allErrors = this.db.prepare(
+        `
+        SELECT timestamp, resolved, resolved_at
+        FROM telemetry_errors
+        WHERE timestamp >= ?
+        ORDER BY timestamp ASC
+      `
+      ).all(cutoffTime);
+      const errorCount = allErrors.length;
+      const resolvedErrors = allErrors.filter((e) => e.resolved === 1 && e.resolved_at);
+      const unresolvedErrors = allErrors.filter((e) => e.resolved === 0);
+      const resolvedCount = resolvedErrors.length;
+      const unresolvedCount = unresolvedErrors.length;
+      const resolutionTimes = [];
+      for (const error of resolvedErrors) {
+        if (error.resolved_at) {
+          const detectionTime = new Date(error.timestamp).getTime();
+          const resolutionTime = new Date(error.resolved_at).getTime();
+          const duration = resolutionTime - detectionTime;
+          if (duration > 0 && duration < 30 * 24 * 36e5) {
+            resolutionTimes.push(duration);
+          }
+        }
+      }
+      let meanTimeToResolution = 0;
+      let medianResolutionTime = 0;
+      let p50ResolutionTime = 0;
+      let p95ResolutionTime = 0;
+      let p99ResolutionTime = 0;
+      if (resolutionTimes.length > 0) {
+        const sorted = [...resolutionTimes].sort((a, b) => a - b);
+        const sum = sorted.reduce((acc, val) => acc + val, 0);
+        meanTimeToResolution = sum / sorted.length;
+        medianResolutionTime = sorted[Math.floor(sorted.length / 2)] ?? 0;
+        p50ResolutionTime = medianResolutionTime;
+        p95ResolutionTime = sorted[Math.floor(sorted.length * 0.95)] ?? 0;
+        p99ResolutionTime = sorted[Math.floor(sorted.length * 0.99)] ?? 0;
+      }
+      let mtbf = 0;
+      if (allErrors.length > 1) {
+        const firstErrorTime = new Date(allErrors[0]?.timestamp ?? cutoffTime).getTime();
+        const lastErrorTime = new Date(
+          allErrors[allErrors.length - 1]?.timestamp ?? Date.now()
+        ).getTime();
+        const totalTime = lastErrorTime - firstErrorTime;
+        if (totalTime > 0) {
+          mtbf = totalTime / (allErrors.length - 1);
+        }
+      }
+      const resolutionRate = errorCount > 0 ? resolvedCount / errorCount : 0;
+      return {
+        mean_time_to_resolution: meanTimeToResolution,
+        median_resolution_time: medianResolutionTime,
+        p50_resolution_time: p50ResolutionTime,
+        p95_resolution_time: p95ResolutionTime,
+        p99_resolution_time: p99ResolutionTime,
+        mtbf,
+        error_count_last_24h: errorCount,
+        resolution_rate: resolutionRate,
+        resolved_count: resolvedCount,
+        unresolved_count: unresolvedCount
+      };
+    } catch (error) {
+      console.warn("Failed to calculate MTTR:", error);
+      return {
+        mean_time_to_resolution: 0,
+        median_resolution_time: 0,
+        p50_resolution_time: 0,
+        p95_resolution_time: 0,
+        p99_resolution_time: 0,
+        mtbf: 0,
+        error_count_last_24h: 0,
+        resolution_rate: 0,
+        resolved_count: 0,
+        unresolved_count: 0
+      };
+    }
+  }
+};
+
+export {
+  TelemetryHealthTracker
+};
+//# sourceMappingURL=chunk-7YAOUUKK.js.map