qa360 2.1.2 → 2.1.4

package/dist/core/slo/sli-calculator.d.ts

@@ -1,92 +0,0 @@
-/**
- * SLI Calculator
- *
- * Calculates Service Level Indicators from various data sources.
- * Supports ratio-based, threshold-based, and percentile-based SLIs.
- */
-import type { SLI, SLIMeasurement, SLIAggregation, SLOStatus, BurnRate } from './types.js';
-/**
- * Event data for ratio calculation
- */
-export interface GoodBadEvents {
-    good: number;
-    bad: number;
-}
-/**
- * Time series data point
- */
-export interface TimeSeriesPoint {
-    timestamp: number;
-    value: number;
-    success?: boolean;
-}
-/**
- * SLI Calculator class
- */
-export declare class SLICalculator {
-    /**
-     * Calculate SLI from good/bad events (ratio-based)
-     */
-    calculateFromEvents(sli: SLI, events: GoodBadEvents): SLIMeasurement;
-    /**
-     * Calculate SLI from time series data
-     */
-    calculateFromTimeSeries(sli: SLI, data: TimeSeriesPoint[], windowMs: number): SLIMeasurement;
-    /**
-     * Calculate SLI from QA360 test results
-     */
-    calculateFromTestResults(sli: SLI, results: {
-        total: number;
-        passed: number;
-        failed: number;
-        skipped: number;
-    }): SLIMeasurement;
-    /**
-     * Calculate SLI from latency measurements
-     */
-    calculateLatency(sli: SLI, latencies: number[], percentile?: 'p50' | 'p95' | 'p99' | 'p99_9'): SLIMeasurement;
-    /**
-     * Calculate multiple SLIs from a single data source
-     */
-    calculateBatch(slis: SLI[], data: TimeSeriesPoint[] | GoodBadEvents | {
-        total: number;
-        passed: number;
-        failed: number;
-        skipped: number;
-    }): SLIMeasurement[];
-    /**
-     * Calculate percentile value
-     */
-    private percentile;
-    /**
-     * Parse percentile string to number
-     */
-    private parsePercentile;
-    /**
-     * Create empty measurement
-     */
-    private emptyMeasurement;
-    /**
-     * Aggregate measurements over time
-     */
-    aggregateMeasurements(measurements: SLIMeasurement[], aggregation: SLIAggregation): SLIMeasurement;
-    /**
-     * Check if measurement meets threshold
-     */
-    meetsThreshold(measurement: SLIMeasurement, threshold: {
-        operator: string;
-        value: number;
-    }): boolean;
-    /**
-     * Calculate burn rate for error budget
-     */
-    calculateBurnRate(measurements: SLIMeasurement[], target: number, windowMs: number): BurnRate;
-    /**
-     * Determine SLO status from current value and target
-     */
-    determineStatus(current: number, target: number, warningThreshold?: number): SLOStatus;
-}
-/**
- * Create an SLI calculator
- */
-export declare function createSLICalculator(): SLICalculator;

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

@@ -1,364 +0,0 @@
-/**
- * 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

@@ -1,148 +0,0 @@
-/**
- * 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;