qa360 2.1.2 → 2.1.4

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

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

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

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