qa360 1.4.5 → 2.0.1

package/dist/core/slo/sli-calculator.js

@@ -0,0 +1,364 @@
+/**
+ * SLI Calculator
+ *
+ * Calculates Service Level Indicators from various data sources.
+ * Supports ratio-based, threshold-based, and percentile-based SLIs.
+ */
+/**
+ * SLI Calculator class
+ */
+export class SLICalculator {
+    /**
+     * Calculate SLI from good/bad events (ratio-based)
+     */
+    calculateFromEvents(sli, events) {
+        const total = events.good + events.bad;
+        const value = total > 0 ? (events.good / total) * 100 : 0;
+        return {
+            sliId: sli.id,
+            timestamp: Date.now(),
+            value,
+            total,
+            good: events.good,
+            bad: events.bad,
+            unit: sli.unit,
+            windowStart: Date.now(),
+            windowEnd: Date.now()
+        };
+    }
+    /**
+     * Calculate SLI from time series data
+     */
+    calculateFromTimeSeries(sli, data, windowMs) {
+        const now = Date.now();
+        const windowStart = now - windowMs;
+        // Filter data within window
+        const windowData = data.filter(p => p.timestamp >= windowStart && p.timestamp <= now);
+        if (windowData.length === 0) {
+            return this.emptyMeasurement(sli, windowStart, now);
+        }
+        let value;
+        switch (sli.aggregation) {
+            case 'count':
+                value = windowData.length;
+                break;
+            case 'sum':
+                value = windowData.reduce((sum, p) => sum + p.value, 0);
+                break;
+            case 'avg':
+                value = windowData.reduce((sum, p) => sum + p.value, 0) / windowData.length;
+                break;
+            case 'max':
+                value = Math.max(...windowData.map(p => p.value));
+                break;
+            case 'min':
+                value = Math.min(...windowData.map(p => p.value));
+                break;
+            case 'p50':
+                value = this.percentile(windowData.map(p => p.value), 50);
+                break;
+            case 'p95':
+                value = this.percentile(windowData.map(p => p.value), 95);
+                break;
+            case 'p99':
+                value = this.percentile(windowData.map(p => p.value), 99);
+                break;
+            case 'p99_9':
+                value = this.percentile(windowData.map(p => p.value), 99.9);
+                break;
+            case 'rate':
+                // Calculate rate per second
+                const durationSec = windowMs / 1000;
+                value = windowData.length / durationSec;
+                break;
+            case 'ratio':
+                // Calculate success ratio
+                const successes = windowData.filter(p => p.success !== false).length;
+                value = (successes / windowData.length) * 100;
+                break;
+            default:
+                value = windowData[windowData.length - 1].value;
+        }
+        return {
+            sliId: sli.id,
+            timestamp: now,
+            value,
+            total: windowData.length,
+            unit: sli.unit,
+            windowStart,
+            windowEnd: now
+        };
+    }
+    /**
+     * Calculate SLI from QA360 test results
+     */
+    calculateFromTestResults(sli, results) {
+        const totalTests = results.total;
+        const passedTests = results.passed;
+        // For quality SLIs, we typically use passed/total
+        let value;
+        switch (sli.type) {
+            case 'quality':
+            case 'availability':
+                value = totalTests > 0 ? (passedTests / totalTests) * 100 : 0;
+                break;
+            case 'error_rate':
+                value = totalTests > 0 ? (results.failed / totalTests) * 100 : 0;
+                break;
+            case 'coverage':
+                // Assume results include coverage percentage
+                value = results.passed; // Treat passed as coverage percentage
+                break;
+            default:
+                value = totalTests > 0 ? (passedTests / totalTests) * 100 : 0;
+        }
+        return {
+            sliId: sli.id,
+            timestamp: Date.now(),
+            value,
+            total: totalTests,
+            good: passedTests,
+            bad: results.failed,
+            unit: sli.unit,
+            windowStart: Date.now(),
+            windowEnd: Date.now()
+        };
+    }
+    /**
+     * Calculate SLI from latency measurements
+     */
+    calculateLatency(sli, latencies, percentile = 'p95') {
+        if (latencies.length === 0) {
+            return this.emptyMeasurement(sli, Date.now(), Date.now());
+        }
+        const value = this.percentile(latencies, this.parsePercentile(percentile));
+        return {
+            sliId: sli.id,
+            timestamp: Date.now(),
+            value,
+            total: latencies.length,
+            unit: sli.unit,
+            windowStart: Date.now(),
+            windowEnd: Date.now()
+        };
+    }
+    /**
+     * Calculate multiple SLIs from a single data source
+     */
+    calculateBatch(slis, data) {
+        const measurements = [];
+        for (const sli of slis) {
+            if (Array.isArray(data) && data.length > 0 && 'timestamp' in data[0]) {
+                measurements.push(this.calculateFromTimeSeries(sli, data, 86400000));
+            }
+            else if ('good' in data && 'bad' in data) {
+                measurements.push(this.calculateFromEvents(sli, data));
+            }
+            else if ('total' in data) {
+                measurements.push(this.calculateFromTestResults(sli, data));
+            }
+        }
+        return measurements;
+    }
+    /**
+     * Calculate percentile value
+     */
+    percentile(values, p) {
+        if (values.length === 0)
+            return 0;
+        const sorted = [...values].sort((a, b) => a - b);
+        const index = (p / 100) * (sorted.length - 1);
+        if (index === Math.floor(index)) {
+            return sorted[index];
+        }
+        const lower = sorted[Math.floor(index)];
+        const upper = sorted[Math.ceil(index)];
+        return lower + (upper - lower) * (index - Math.floor(index));
+    }
+    /**
+     * Parse percentile string to number
+     */
+    parsePercentile(p) {
+        const match = p.match(/p(\d+(\.\d+)?)/);
+        if (match) {
+            return parseFloat(match[1]);
+        }
+        return 95; // Default to p95
+    }
+    /**
+     * Create empty measurement
+     */
+    emptyMeasurement(sli, windowStart, windowEnd) {
+        return {
+            sliId: sli.id,
+            timestamp: Date.now(),
+            value: 0,
+            total: 0,
+            unit: sli.unit,
+            windowStart,
+            windowEnd
+        };
+    }
+    /**
+     * Aggregate measurements over time
+     */
+    aggregateMeasurements(measurements, aggregation) {
+        if (measurements.length === 0) {
+            throw new Error('No measurements to aggregate');
+        }
+        const values = measurements.map(m => m.value);
+        const sliId = measurements[0].sliId;
+        const unit = measurements[0].unit;
+        const windowStart = Math.min(...measurements.map(m => m.windowStart));
+        const windowEnd = Math.max(...measurements.map(m => m.windowEnd));
+        let value;
+        switch (aggregation) {
+            case 'sum':
+                value = values.reduce((sum, v) => sum + v, 0);
+                break;
+            case 'avg':
+                value = values.reduce((sum, v) => sum + v, 0) / values.length;
+                break;
+            case 'max':
+                value = Math.max(...values);
+                break;
+            case 'min':
+                value = Math.min(...values);
+                break;
+            case 'p50':
+                value = this.percentile(values, 50);
+                break;
+            case 'p95':
+                value = this.percentile(values, 95);
+                break;
+            case 'p99':
+                value = this.percentile(values, 99);
+                break;
+            case 'p99_9':
+                value = this.percentile(values, 99.9);
+                break;
+            default:
+                value = values[values.length - 1];
+        }
+        return {
+            sliId,
+            timestamp: Date.now(),
+            value,
+            total: measurements.reduce((sum, m) => sum + (m.total || 0), 0),
+            unit,
+            windowStart,
+            windowEnd
+        };
+    }
+    /**
+     * Check if measurement meets threshold
+     */
+    meetsThreshold(measurement, threshold) {
+        const { operator, value } = threshold;
+        switch (operator) {
+            case 'gt':
+                return measurement.value > value;
+            case 'gte':
+                return measurement.value >= value;
+            case 'lt':
+                return measurement.value < value;
+            case 'lte':
+                return measurement.value <= value;
+            case 'eq':
+                return measurement.value === value;
+            case 'ne':
+                return measurement.value !== value;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Calculate burn rate for error budget
+     */
+    calculateBurnRate(measurements, target, windowMs) {
+        if (measurements.length < 2) {
+            return {
+                current: 0,
+                status: 'healthy',
+                history: []
+            };
+        }
+        const now = Date.now();
+        const windowStart = now - windowMs;
+        // Filter measurements within window
+        const recentMeasurements = measurements.filter(m => m.timestamp >= windowStart);
+        if (recentMeasurements.length === 0) {
+            return {
+                current: 0,
+                status: 'healthy',
+                history: []
+            };
+        }
+        // Calculate error budget burn
+        // Each measurement below target contributes to burn
+        let totalBudgetDeficit = 0;
+        for (const m of recentMeasurements) {
+            if (m.value < target) {
+                totalBudgetDeficit += (target - m.value);
+            }
+        }
+        // Expected burn rate (assuming uniform distribution)
+        const expectedDeficit = (100 - target) * recentMeasurements.length;
+        const burnRate = expectedDeficit > 0 ? totalBudgetDeficit / expectedDeficit : 0;
+        // Determine status
+        let status;
+        if (burnRate >= 5) {
+            status = 'critical';
+        }
+        else if (burnRate >= 2) {
+            status = 'warning';
+        }
+        else {
+            status = 'healthy';
+        }
+        // Project exhaustion if burning fast
+        let projectedExhaustion;
+        if (burnRate > 1) {
+            const remainingBudget = 100 - target - totalBudgetDeficit / recentMeasurements.length;
+            if (remainingBudget > 0 && burnRate > 0) {
+                const burnPerMs = (100 - target) / windowMs * burnRate;
+                projectedExhaustion = now + (remainingBudget / burnPerMs);
+            }
+        }
+        // Build history
+        const history = recentMeasurements.map(m => {
+            const deficit = Math.max(0, target - m.value);
+            const rate = deficit > 0 ? deficit / (100 - target) : 0;
+            return {
+                timestamp: m.timestamp,
+                rate
+            };
+        });
+        return {
+            current: burnRate,
+            status,
+            projectedExhaustion,
+            history
+        };
+    }
+    /**
+     * Determine SLO status from current value and target
+     */
+    determineStatus(current, target, warningThreshold = 0.95) {
+        if (current >= target) {
+            return 'healthy';
+        }
+        else if (current >= target * warningThreshold) {
+            return 'warning';
+        }
+        else {
+            return 'breached';
+        }
+    }
+}
+/**
+ * Create an SLI calculator
+ */
+export function createSLICalculator() {
+    return new SLICalculator();
+}

package/dist/core/slo/slo-tracker.d.ts

@@ -0,0 +1,148 @@
+/**
+ * SLO Tracker
+ *
+ * Tracks Service Level Objectives and manages error budgets.
+ * Monitors SLO compliance and generates reports.
+ */
+import type { SLO, SLI, SLIMeasurement, SLOResult, SLOReport, SLOViolation, ErrorBudget, BurnRate } from './types.js';
+/**
+ * SLO Tracker Options
+ */
+export interface SLOTrackerOptions {
+    /** Warning threshold as % of target */
+    warningThreshold?: number;
+    /** Enable violation tracking */
+    trackViolations?: boolean;
+    /** Enable alerting */
+    enableAlerts?: boolean;
+    /** Alert callback */
+    onAlert?: (alert: SLOAlert) => void;
+}
+/**
+ * SLO Alert
+ */
+export interface SLOAlert {
+    sloId: string;
+    sloName: string;
+    severity: 'warning' | 'critical';
+    message: string;
+    currentValue: number;
+    target: number;
+    errorBudgetRemaining: number;
+    timestamp: number;
+}
+/**
+ * SLO Tracker class
+ */
+export declare class SLOTracker {
+    private slos;
+    private slis;
+    private measurements;
+    private violations;
+    private calculator;
+    private options;
+    constructor(options?: SLOTrackerOptions);
+    /**
+     * Register an SLO
+     */
+    registerSLO(slo: SLO): void;
+    /**
+     * Register an SLI
+     */
+    registerSLI(sli: SLI): void;
+    /**
+     * Register multiple SLOs
+     */
+    registerSLOs(slos: SLO[]): void;
+    /**
+     * Register multiple SLIs
+     */
+    registerSLIs(slis: SLI[]): void;
+    /**
+     * Get an SLO by ID
+     */
+    getSLO(id: string): SLO | undefined;
+    /**
+     * Get an SLI by ID
+     */
+    getSLI(id: string): SLI | undefined;
+    /**
+     * Get all registered SLOs
+     */
+    getAllSLOs(): SLO[];
+    /**
+     * Get all registered SLIs
+     */
+    getAllSLIs(): SLI[];
+    /**
+     * Record a measurement for an SLI
+     */
+    recordMeasurement(measurement: SLIMeasurement): void;
+    /**
+     * Get measurements for an SLI
+     */
+    getMeasurements(sliId: string, windowMs?: number): SLIMeasurement[];
+    /**
+     * Calculate SLO result
+     */
+    calculateSLOResult(sloId: string): SLOResult | null;
+    /**
+     * Calculate all SLO results
+     */
+    calculateAllResults(): SLOResult[];
+    /**
+     * Generate SLO report
+     */
+    generateReport(period?: {
+        start: number;
+        end: number;
+    }): SLOReport;
+    /**
+     * Get error budget for an SLO
+     */
+    getErrorBudget(sloId: string): ErrorBudget | null;
+    /**
+     * Calculate burn rate for an SLO
+     */
+    calculateBurnRate(sloId: string): BurnRate | null;
+    /**
+     * Get violations for an SLO
+     */
+    getViolations(sloId?: string): SLOViolation[];
+    /**
+     * Clear violations
+     */
+    clearViolations(sloId?: string): void;
+    /**
+     * Resolve a violation
+     */
+    resolveViolation(violationId: string): void;
+    /**
+     * Calculate error budget from current value and target
+     */
+    private calculateErrorBudget;
+    /**
+     * Update SLOs that depend on an SLI
+     */
+    private updateDependentSLOs;
+    /**
+     * Check for SLO violation
+     */
+    private checkForViolation;
+    /**
+     * Generate alerts for SLO status
+     */
+    private generateAlerts;
+    /**
+     * Get the longest window from all SLOs
+     */
+    private getLongestWindow;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Create an SLO tracker
+ */
+export declare function createSLOTracker(options?: SLOTrackerOptions): SLOTracker;