qa360 1.4.5 → 2.0.1

package/dist/core/slo/slo-tracker.js

@@ -0,0 +1,379 @@
+/**
+ * SLO Tracker
+ *
+ * Tracks Service Level Objectives and manages error budgets.
+ * Monitors SLO compliance and generates reports.
+ */
+import { SLICalculator } from './sli-calculator.js';
+/**
+ * SLO Tracker class
+ */
+export class SLOTracker {
+    slos = new Map();
+    slis = new Map();
+    measurements = new Map();
+    violations = [];
+    calculator;
+    options;
+    constructor(options = {}) {
+        this.calculator = new SLICalculator();
+        this.options = {
+            warningThreshold: options.warningThreshold ?? 0.95,
+            trackViolations: options.trackViolations ?? true,
+            enableAlerts: options.enableAlerts ?? true,
+            onAlert: options.onAlert ?? (() => { })
+        };
+    }
+    /**
+     * Register an SLO
+     */
+    registerSLO(slo) {
+        this.slos.set(slo.id, slo);
+    }
+    /**
+     * Register an SLI
+     */
+    registerSLI(sli) {
+        this.slis.set(sli.id, sli);
+    }
+    /**
+     * Register multiple SLOs
+     */
+    registerSLOs(slos) {
+        for (const slo of slos) {
+            this.registerSLO(slo);
+        }
+    }
+    /**
+     * Register multiple SLIs
+     */
+    registerSLIs(slis) {
+        for (const sli of slis) {
+            this.registerSLI(sli);
+        }
+    }
+    /**
+     * Get an SLO by ID
+     */
+    getSLO(id) {
+        return this.slos.get(id);
+    }
+    /**
+     * Get an SLI by ID
+     */
+    getSLI(id) {
+        return this.slis.get(id);
+    }
+    /**
+     * Get all registered SLOs
+     */
+    getAllSLOs() {
+        return Array.from(this.slos.values());
+    }
+    /**
+     * Get all registered SLIs
+     */
+    getAllSLIs() {
+        return Array.from(this.slis.values());
+    }
+    /**
+     * Record a measurement for an SLI
+     */
+    recordMeasurement(measurement) {
+        const sli = this.slis.get(measurement.sliId);
+        if (!sli) {
+            throw new Error(`SLI not found: ${measurement.sliId}`);
+        }
+        if (!this.measurements.has(measurement.sliId)) {
+            this.measurements.set(measurement.sliId, []);
+        }
+        const measurements = this.measurements.get(measurement.sliId);
+        measurements.push(measurement);
+        // Keep only measurements within the longest SLO window
+        const longestWindow = this.getLongestWindow();
+        const cutoff = Date.now() - longestWindow;
+        const filtered = measurements.filter(m => m.timestamp >= cutoff);
+        this.measurements.set(measurement.sliId, filtered);
+        // Update dependent SLOs
+        this.updateDependentSLOs(measurement.sliId);
+    }
+    /**
+     * Get measurements for an SLI
+     */
+    getMeasurements(sliId, windowMs) {
+        const measurements = this.measurements.get(sliId) || [];
+        if (!windowMs) {
+            return measurements;
+        }
+        const cutoff = Date.now() - windowMs;
+        return measurements.filter(m => m.timestamp >= cutoff);
+    }
+    /**
+     * Calculate SLO result
+     */
+    calculateSLOResult(sloId) {
+        const slo = this.slos.get(sloId);
+        if (!slo) {
+            return null;
+        }
+        // Get measurements for all SLIs in the SLO
+        const windowStart = Date.now() - slo.windowMs;
+        const sliResults = [];
+        for (const sliId of slo.sliIds) {
+            const sli = this.slis.get(sliId);
+            if (!sli)
+                continue;
+            const measurements = this.getMeasurements(sliId, slo.windowMs);
+            if (measurements.length === 0)
+                continue;
+            // Get the most recent measurement or aggregate
+            const latest = measurements[measurements.length - 1];
+            sliResults.push({
+                sliId: sli.id,
+                name: sli.name,
+                value: latest.value,
+                target: slo.target,
+                contribution: 1 / slo.sliIds.length // Equal weight by default
+            });
+        }
+        if (sliResults.length === 0) {
+            return null;
+        }
+        // Calculate weighted average for SLO value
+        const current = sliResults.reduce((sum, s) => sum + s.value * s.contribution, 0);
+        // Calculate error budget
+        const errorBudget = this.calculateErrorBudget(slo, current);
+        // Determine status
+        const status = this.calculator.determineStatus(current, slo.target, this.options.warningThreshold);
+        // Update SLO
+        slo.currentValue = current;
+        slo.status = status;
+        slo.errorBudget = errorBudget;
+        return {
+            sloId: slo.id,
+            name: slo.name,
+            target: slo.target,
+            current,
+            status,
+            errorBudget: {
+                initial: errorBudget.initialBudget,
+                remaining: errorBudget.remainingBudget,
+                burned: errorBudget.initialBudget - errorBudget.remainingBudget,
+                burnRate: errorBudget.remainingBudget > 0
+                    ? (errorBudget.initialBudget - errorBudget.remainingBudget) / errorBudget.initialBudget
+                    : 1
+            },
+            slis: sliResults
+        };
+    }
+    /**
+     * Calculate all SLO results
+     */
+    calculateAllResults() {
+        const results = [];
+        for (const sloId of this.slos.keys()) {
+            const result = this.calculateSLOResult(sloId);
+            if (result) {
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    /**
+     * Generate SLO report
+     */
+    generateReport(period) {
+        const results = this.calculateAllResults();
+        const summary = {
+            total: results.length,
+            healthy: results.filter(r => r.status === 'healthy').length,
+            warning: results.filter(r => r.status === 'warning').length,
+            breached: results.filter(r => r.status === 'breached').length
+        };
+        const overallStatus = summary.breached > 0 ? 'breached'
+            : summary.warning > 0 ? 'warning'
+                : summary.healthy > 0 ? 'healthy'
+                    : 'unknown';
+        return {
+            id: `report_${Date.now()}`,
+            timestamp: Date.now(),
+            period: period || {
+                start: Date.now() - this.getLongestWindow(),
+                end: Date.now()
+            },
+            slos: results,
+            status: overallStatus,
+            summary
+        };
+    }
+    /**
+     * Get error budget for an SLO
+     */
+    getErrorBudget(sloId) {
+        const slo = this.slos.get(sloId);
+        if (!slo) {
+            return null;
+        }
+        const result = this.calculateSLOResult(sloId);
+        if (!result) {
+            return slo.errorBudget;
+        }
+        return slo.errorBudget;
+    }
+    /**
+     * Calculate burn rate for an SLO
+     */
+    calculateBurnRate(sloId) {
+        const slo = this.slos.get(sloId);
+        if (!slo) {
+            return null;
+        }
+        // Get all measurements for SLIs in this SLO
+        const allMeasurements = [];
+        for (const sliId of slo.sliIds) {
+            const measurements = this.getMeasurements(sliId, slo.windowMs);
+            allMeasurements.push(...measurements);
+        }
+        if (allMeasurements.length === 0) {
+            return null;
+        }
+        return this.calculator.calculateBurnRate(allMeasurements, slo.target, slo.windowMs);
+    }
+    /**
+     * Get violations for an SLO
+     */
+    getViolations(sloId) {
+        if (sloId) {
+            return this.violations.filter(v => v.sloId === sloId);
+        }
+        return this.violations;
+    }
+    /**
+     * Clear violations
+     */
+    clearViolations(sloId) {
+        if (sloId) {
+            this.violations = this.violations.filter(v => v.sloId !== sloId);
+        }
+        else {
+            this.violations = [];
+        }
+    }
+    /**
+     * Resolve a violation
+     */
+    resolveViolation(violationId) {
+        const violation = this.violations.find(v => v.id === violationId);
+        if (violation) {
+            violation.resolved = true;
+            violation.resolvedAt = Date.now();
+        }
+    }
+    /**
+     * Calculate error budget from current value and target
+     */
+    calculateErrorBudget(slo, currentValue) {
+        const initialBudget = 100 - slo.target;
+        const burned = Math.max(0, slo.target - currentValue);
+        const remaining = Math.max(0, initialBudget - burned);
+        return {
+            ...slo.errorBudget,
+            initialBudget,
+            remainingBudget: remaining
+        };
+    }
+    /**
+     * Update SLOs that depend on an SLI
+     */
+    updateDependentSLOs(sliId) {
+        for (const slo of this.slos.values()) {
+            if (!slo.sliIds.includes(sliId))
+                continue;
+            const result = this.calculateSLOResult(slo.id);
+            if (!result)
+                continue;
+            // Check for violations
+            if (this.options.trackViolations) {
+                this.checkForViolation(slo, result);
+            }
+            // Generate alerts
+            if (this.options.enableAlerts) {
+                this.generateAlerts(slo, result);
+            }
+        }
+    }
+    /**
+     * Check for SLO violation
+     */
+    checkForViolation(slo, result) {
+        const now = Date.now();
+        // Check if we just breached
+        if (result.status === 'breached' && slo.status !== 'breached') {
+            this.violations.push({
+                id: `violation_${now}_${slo.id}`,
+                sloId: slo.id,
+                timestamp: now,
+                value: result.current,
+                expected: result.target,
+                severity: 'critical',
+                resolved: false
+            });
+        }
+        // Check if we just hit warning
+        if (result.status === 'warning' && slo.status === 'healthy') {
+            this.violations.push({
+                id: `warning_${now}_${slo.id}`,
+                sloId: slo.id,
+                timestamp: now,
+                value: result.current,
+                expected: result.target,
+                severity: 'warning',
+                resolved: false
+            });
+        }
+    }
+    /**
+     * Generate alerts for SLO status
+     */
+    generateAlerts(slo, result) {
+        if (result.status === 'breached' || result.status === 'warning') {
+            this.options.onAlert({
+                sloId: slo.id,
+                sloName: slo.name,
+                severity: result.status === 'breached' ? 'critical' : 'warning',
+                message: `SLO "${slo.name}" is ${result.status}: ${result.current.toFixed(2)}% < ${result.target}%`,
+                currentValue: result.current,
+                target: result.target,
+                errorBudgetRemaining: result.errorBudget.remaining,
+                timestamp: Date.now()
+            });
+        }
+    }
+    /**
+     * Get the longest window from all SLOs
+     */
+    getLongestWindow() {
+        let max = 0;
+        for (const slo of this.slos.values()) {
+            if (slo.windowMs > max) {
+                max = slo.windowMs;
+            }
+        }
+        return max || 86400000 * 30; // Default 30 days
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this.slos.clear();
+        this.slis.clear();
+        this.measurements.clear();
+        this.violations = [];
+    }
+}
+/**
+ * Create an SLO tracker
+ */
+export function createSLOTracker(options) {
+    return new SLOTracker(options);
+}

package/dist/core/slo/types.d.ts

@@ -0,0 +1,281 @@
+/**
+ * QA360 SLO/SLI Management Module
+ *
+ * Types for Service Level Objectives and Service Level Indicators.
+ * Based on Google SRE methodology for reliability engineering.
+ */
+/**
+ * SLO (Service Level Objective) - Target goal for reliability
+ */
+export interface SLO {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** SLIs that contribute to this SLO */
+    sliIds: string[];
+    /** Target percentage (0-100) */
+    target: number;
+    /** Rolling window duration in milliseconds */
+    windowMs: number;
+    /** Error budget configuration */
+    errorBudget: ErrorBudget;
+    /** SLO status */
+    status: SLOStatus;
+    /** Current achievement */
+    currentValue?: number;
+    /** Metadata */
+    tags?: string[];
+    /** Owner/team */
+    owner?: string;
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+}
+/**
+ * Error Budget Configuration
+ */
+export interface ErrorBudget {
+    /** Initial budget percentage (100 - target) */
+    initialBudget: number;
+    /** Remaining budget percentage */
+    remainingBudget: number;
+    /** Burn rate alerting thresholds */
+    alertThresholds: {
+        warning: number;
+        critical: number;
+    };
+    /** Actions when budget is exhausted */
+    onExhaustion: 'stop_deployments' | 'alert_only' | 'freeze_features' | 'custom';
+}
+/**
+ * SLO Status
+ */
+export type SLOStatus = 'healthy' | 'warning' | 'breached' | 'unknown';
+/**
+ * SLI (Service Level Indicator) - Metric that measures reliability
+ */
+export interface SLI {
+    /** Unique identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** SLI type */
+    type: SLIType;
+    /** Metric source */
+    source: SLISource;
+    /** Query/fetch configuration */
+    query: SLIQuery;
+    /** Aggregation method */
+    aggregation: SLIAggregation;
+    /** Unit of measurement */
+    unit: SLIUnit;
+    /** Good/bad event definitions */
+    threshold: SLIThreshold;
+    /** SLI category */
+    category: SLICategory;
+    /** Metadata */
+    tags?: string[];
+    /** Creation timestamp */
+    createdAt: number;
+    /** Last update timestamp */
+    updatedAt: number;
+}
+/**
+ * SLI Types
+ */
+export type SLIType = 'availability' | 'latency' | 'error_rate' | 'throughput' | 'durability' | 'coverage' | 'performance' | 'quality' | 'custom';
+/**
+ * SLI Data Sources
+ */
+export type SLISource = 'qa360_tests' | 'prometheus' | 'cloudwatch' | 'datadog' | 'grafana' | 'custom_api' | 'file' | 'manual';
+/**
+ * SLI Query Configuration
+ */
+export interface SLIQuery {
+    /** Query string for the metric source */
+    queryString: string;
+    /** Filters to apply */
+    filters?: Record<string, string>;
+    /** Grouping keys */
+    groupBy?: string[];
+    /** Time window for aggregation */
+    timeWindow?: {
+        value: number;
+        unit: 'ms' | 's' | 'm' | 'h' | 'd';
+    };
+}
+/**
+ * SLI Aggregation Methods
+ */
+export type SLIAggregation = 'count' | 'sum' | 'avg' | 'p50' | 'p95' | 'p99' | 'p99_9' | 'max' | 'min' | 'rate' | 'ratio';
+/**
+ * SLI Units
+ */
+export type SLIUnit = 'percentage' | 'milliseconds' | 'seconds' | 'count' | 'bytes' | 'requests_per_sec' | 'ratio' | 'boolean';
+/**
+ * SLI Threshold Definition
+ */
+export interface SLIThreshold {
+    /** Comparison operator */
+    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'ne';
+    /** Threshold value */
+    value: number;
+    /** Optional upper bound for range checks */
+    upperBound?: number;
+}
+/**
+ * SLI Categories
+ */
+export type SLICategory = 'reliability' | 'performance' | 'quality' | 'security' | 'operational' | 'custom';
+/**
+ * SLI Measurement Result
+ */
+export interface SLIMeasurement {
+    /** SLI identifier */
+    sliId: string;
+    /** Timestamp of measurement */
+    timestamp: number;
+    /** Measured value */
+    value: number;
+    /** Total events (for ratios) */
+    total?: number;
+    /** Good events (for ratios) */
+    good?: number;
+    /** Bad events (for ratios) */
+    bad?: number;
+    /** Unit */
+    unit: SLIUnit;
+    /** Window start */
+    windowStart: number;
+    /** Window end: number */
+    windowEnd: number;
+}
+/**
+ * SLO Report
+ */
+export interface SLOReport {
+    /** Report identifier */
+    id: string;
+    /** Timestamp */
+    timestamp: number;
+    /** Reporting period */
+    period: {
+        start: number;
+        end: number;
+    };
+    /** SLO results */
+    slos: SLOResult[];
+    /** Overall status */
+    status: SLOStatus;
+    /** Summary metrics */
+    summary: {
+        total: number;
+        healthy: number;
+        warning: number;
+        breached: number;
+    };
+}
+/**
+ * SLO Result for a single SLO
+ */
+export interface SLOResult {
+    /** SLO identifier */
+    sloId: string;
+    /** SLO name */
+    name: string;
+    /** Target value */
+    target: number;
+    /** Current value */
+    current: number;
+    /** Achievement status */
+    status: SLOStatus;
+    /** Error budget info */
+    errorBudget: {
+        initial: number;
+        remaining: number;
+        burned: number;
+        burnRate: number;
+    };
+    /** Contributing SLI results */
+    slis: {
+        sliId: string;
+        name: string;
+        value: number;
+        target: number;
+        contribution: number;
+    }[];
+}
+/**
+ * Error Budget Burn Rate
+ */
+export interface BurnRate {
+    /** Current burn rate (multiple of normal) */
+    current: number;
+    /** Status */
+    status: 'healthy' | 'warning' | 'critical';
+    /** Projected exhaustion */
+    projectedExhaustion?: number;
+    /** Historical burn rates */
+    history: Array<{
+        timestamp: number;
+        rate: number;
+    }>;
+}
+/**
+ * SLO Configuration
+ */
+export interface SLOConfig {
+    /** Enable SLO/SLI tracking */
+    enabled: boolean;
+    /** Default rolling window */
+    defaultWindowMs: number;
+    /** Default error budget behavior */
+    defaultOnExhaustion: ErrorBudget['onExhaustion'];
+    /** Alert thresholds */
+    alertThresholds: {
+        warning: number;
+        critical: number;
+    };
+    /** Data retention */
+    retention: {
+        measurements: number;
+        aggregated: number;
+    };
+    /** SLO definitions */
+    slos: SLO[];
+    /** SLI definitions */
+    slis: SLI[];
+}
+/**
+ * SLO Violation Event
+ */
+export interface SLOViolation {
+    /** Unique identifier */
+    id: string;
+    /** SLO that was violated */
+    sloId: string;
+    /** Timestamp of violation */
+    timestamp: number;
+    /** Value at violation */
+    value: number;
+    /** Expected value */
+    expected: number;
+    /** Severity */
+    severity: 'warning' | 'critical';
+    /** Context */
+    context?: {
+        runId?: string;
+        gate?: string;
+        environment?: string;
+    };
+    /** Resolved flag */
+    resolved: boolean;
+    /** Resolution timestamp */
+    resolvedAt?: number;
+}

package/dist/core/slo/types.js

@@ -0,0 +1,7 @@
+/**
+ * QA360 SLO/SLI Management Module
+ *
+ * Types for Service Level Objectives and Service Level Indicators.
+ * Based on Google SRE methodology for reliability engineering.
+ */
+export {};