qa360 1.4.5 → 2.0.1

package/dist/core/slo/config.js

@@ -0,0 +1,360 @@
+/**
+ * SLO/SLI Default Configuration
+ *
+ * Predefined SLOs and SLIs for common quality metrics.
+ * Factory functions for creating standard configurations.
+ */
+import { randomUUID } from 'crypto';
+/**
+ * Default time windows in milliseconds
+ */
+export const TimeWindows = {
+    HOUR: 60 * 60 * 1000,
+    DAY: 24 * 60 * 60 * 1000,
+    WEEK: 7 * 24 * 60 * 60 * 1000,
+    MONTH: 30 * 24 * 60 * 60 * 1000,
+    QUARTER: 90 * 24 * 60 * 60 * 1000
+};
+/**
+ * Create default SLO configuration
+ */
+export function createDefaultSLOConfig() {
+    return {
+        enabled: true,
+        defaultWindowMs: TimeWindows.MONTH,
+        defaultOnExhaustion: 'alert_only',
+        alertThresholds: {
+            warning: 50, // Alert at 50% budget used
+            critical: 80 // Critical alert at 80% budget used
+        },
+        retention: {
+            measurements: 90, // Keep raw measurements for 90 days
+            aggregated: 365 // Keep aggregated data for 1 year
+        },
+        slos: [
+            createDefaultTestQualitySLO(),
+            createDefaultAPISuccessSLO(),
+            createDefaultPerformanceSLO()
+        ],
+        slis: [
+            createTestPassRateSLI(),
+            createAPISuccessRateSLI(),
+            createLatencySLI()
+        ]
+    };
+}
+/**
+ * Create strict SLO configuration (enterprise/production)
+ */
+export function createStrictSLOConfig() {
+    const config = createDefaultSLOConfig();
+    config.slos = [
+        createStrictTestQualitySLO(),
+        createStrictAPISuccessSLO(),
+        createStrictPerformanceSLO()
+    ];
+    config.alertThresholds = {
+        warning: 20,
+        critical: 50
+    };
+    return config;
+}
+/**
+ * Create relaxed SLO configuration (development)
+ */
+export function createRelaxedSLOConfig() {
+    const config = createDefaultSLOConfig();
+    config.slos = [
+        createRelaxedTestQualitySLO(),
+        createRelaxedAPISuccessSLO(),
+        createRelaxedPerformanceSLO()
+    ];
+    config.alertThresholds = {
+        warning: 70,
+        critical: 90
+    };
+    return config;
+}
+/**
+ * Default: Test Quality SLO (95% pass rate over 30 days)
+ */
+export function createDefaultTestQualitySLO() {
+    const sliId = `sli_test_pass_rate_${randomUUID().slice(0, 8)}`;
+    return {
+        id: `slo_test_quality_${randomUUID().slice(0, 8)}`,
+        name: 'Test Quality',
+        description: 'Percentage of tests passing across all gates',
+        sliIds: [sliId],
+        target: 95,
+        windowMs: TimeWindows.WEEK,
+        errorBudget: {
+            initialBudget: 5,
+            remainingBudget: 5,
+            alertThresholds: {
+                warning: 2,
+                critical: 5
+            },
+            onExhaustion: 'alert_only'
+        },
+        status: 'unknown',
+        tags: ['quality', 'testing'],
+        owner: 'qa',
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * Default: API Success Rate SLO (99.9% over 30 days)
+ */
+export function createDefaultAPISuccessSLO() {
+    const sliId = `sli_api_success_${randomUUID().slice(0, 8)}`;
+    return {
+        id: `slo_api_success_${randomUUID().slice(0, 8)}`,
+        name: 'API Success Rate',
+        description: 'Percentage of successful API requests',
+        sliIds: [sliId],
+        target: 99.9,
+        windowMs: TimeWindows.MONTH,
+        errorBudget: {
+            initialBudget: 0.1,
+            remainingBudget: 0.1,
+            alertThresholds: {
+                warning: 2,
+                critical: 5
+            },
+            onExhaustion: 'alert_only'
+        },
+        status: 'unknown',
+        tags: ['api', 'reliability'],
+        owner: 'backend',
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * Default: Performance SLO (p95 latency < 500ms)
+ */
+export function createDefaultPerformanceSLO() {
+    const sliId = `sli_latency_p95_${randomUUID().slice(0, 8)}`;
+    return {
+        id: `slo_performance_${randomUUID().slice(0, 8)}`,
+        name: 'API Latency (p95)',
+        description: '95th percentile response time for API requests',
+        sliIds: [sliId],
+        target: 95, // Interpreted as "95% of requests under threshold"
+        windowMs: TimeWindows.WEEK,
+        errorBudget: {
+            initialBudget: 5,
+            remainingBudget: 5,
+            alertThresholds: {
+                warning: 2,
+                critical: 5
+            },
+            onExhaustion: 'alert_only'
+        },
+        status: 'unknown',
+        tags: ['performance', 'latency'],
+        owner: 'backend',
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * Strict: Test Quality SLO (98% pass rate)
+ */
+export function createStrictTestQualitySLO() {
+    const slo = createDefaultTestQualitySLO();
+    slo.id = `slo_test_quality_strict_${randomUUID().slice(0, 8)}`;
+    slo.target = 98;
+    slo.errorBudget.initialBudget = 2;
+    slo.errorBudget.remainingBudget = 2;
+    slo.tags = [...(slo.tags || []), 'strict'];
+    return slo;
+}
+/**
+ * Strict: API Success Rate SLO (99.95%)
+ */
+export function createStrictAPISuccessSLO() {
+    const slo = createDefaultAPISuccessSLO();
+    slo.id = `slo_api_success_strict_${randomUUID().slice(0, 8)}`;
+    slo.target = 99.95;
+    slo.errorBudget.initialBudget = 0.05;
+    slo.errorBudget.remainingBudget = 0.05;
+    slo.tags = [...(slo.tags || []), 'strict'];
+    return slo;
+}
+/**
+ * Strict: Performance SLO (p95 latency < 200ms)
+ */
+export function createStrictPerformanceSLO() {
+    const slo = createDefaultPerformanceSLO();
+    slo.id = `slo_performance_strict_${randomUUID().slice(0, 8)}`;
+    slo.target = 98;
+    slo.errorBudget.initialBudget = 2;
+    slo.errorBudget.remainingBudget = 2;
+    slo.tags = [...(slo.tags || []), 'strict'];
+    return slo;
+}
+/**
+ * Relaxed: Test Quality SLO (90% pass rate)
+ */
+export function createRelaxedTestQualitySLO() {
+    const slo = createDefaultTestQualitySLO();
+    slo.id = `slo_test_quality_relaxed_${randomUUID().slice(0, 8)}`;
+    slo.target = 90;
+    slo.errorBudget.initialBudget = 10;
+    slo.errorBudget.remainingBudget = 10;
+    slo.tags = [...(slo.tags || []), 'relaxed'];
+    return slo;
+}
+/**
+ * Relaxed: API Success Rate SLO (99%)
+ */
+export function createRelaxedAPISuccessSLO() {
+    const slo = createDefaultAPISuccessSLO();
+    slo.id = `slo_api_success_relaxed_${randomUUID().slice(0, 8)}`;
+    slo.target = 99;
+    slo.errorBudget.initialBudget = 1;
+    slo.errorBudget.remainingBudget = 1;
+    slo.tags = [...(slo.tags || []), 'relaxed'];
+    return slo;
+}
+/**
+ * Relaxed: Performance SLO (p95 latency < 1000ms)
+ */
+export function createRelaxedPerformanceSLO() {
+    const slo = createDefaultPerformanceSLO();
+    slo.id = `slo_performance_relaxed_${randomUUID().slice(0, 8)}`;
+    slo.target = 90;
+    slo.errorBudget.initialBudget = 10;
+    slo.errorBudget.remainingBudget = 10;
+    slo.tags = [...(slo.tags || []), 'relaxed'];
+    return slo;
+}
+/**
+ * SLI: Test Pass Rate
+ */
+export function createTestPassRateSLI() {
+    return {
+        id: `sli_test_pass_rate_${randomUUID().slice(0, 8)}`,
+        name: 'Test Pass Rate',
+        description: 'Percentage of tests that pass',
+        type: 'quality',
+        source: 'qa360_tests',
+        query: {
+            queryString: 'test_results',
+            timeWindow: { value: 1, unit: 'd' }
+        },
+        aggregation: 'ratio',
+        unit: 'percentage',
+        threshold: {
+            operator: 'gte',
+            value: 95
+        },
+        category: 'quality',
+        tags: ['quality', 'testing'],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * SLI: API Success Rate
+ */
+export function createAPISuccessRateSLI() {
+    return {
+        id: `sli_api_success_${randomUUID().slice(0, 8)}`,
+        name: 'API Success Rate',
+        description: 'Percentage of successful API requests',
+        type: 'availability',
+        source: 'qa360_tests',
+        query: {
+            queryString: 'api_smoke_results',
+            timeWindow: { value: 1, unit: 'd' }
+        },
+        aggregation: 'ratio',
+        unit: 'percentage',
+        threshold: {
+            operator: 'gte',
+            value: 99.9
+        },
+        category: 'reliability',
+        tags: ['api', 'reliability'],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * SLI: Latency (p95)
+ */
+export function createLatencySLI() {
+    return {
+        id: `sli_latency_p95_${randomUUID().slice(0, 8)}`,
+        name: 'API Latency p95',
+        description: '95th percentile API response time',
+        type: 'latency',
+        source: 'qa360_tests',
+        query: {
+            queryString: 'api_latency',
+            timeWindow: { value: 1, unit: 'd' }
+        },
+        aggregation: 'p95',
+        unit: 'milliseconds',
+        threshold: {
+            operator: 'lte',
+            value: 500
+        },
+        category: 'performance',
+        tags: ['performance', 'latency'],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * Create custom SLO from parameters
+ */
+export function createCustomSLO(params) {
+    return {
+        id: `slo_custom_${randomUUID().slice(0, 8)}`,
+        name: params.name,
+        description: params.description,
+        sliIds: params.sliIds,
+        target: params.target,
+        windowMs: params.windowMs || TimeWindows.MONTH,
+        errorBudget: {
+            initialBudget: 100 - params.target,
+            remainingBudget: 100 - params.target,
+            alertThresholds: {
+                warning: 2,
+                critical: 5
+            },
+            onExhaustion: 'alert_only'
+        },
+        status: 'unknown',
+        tags: params.tags || ['custom'],
+        owner: params.owner,
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}
+/**
+ * Create custom SLI from parameters
+ */
+export function createCustomSLI(params) {
+    return {
+        id: `sli_custom_${randomUUID().slice(0, 8)}`,
+        name: params.name,
+        description: params.description,
+        type: params.type,
+        source: params.source,
+        query: {
+            queryString: params.queryString
+        },
+        aggregation: params.aggregation,
+        unit: params.unit,
+        threshold: params.threshold,
+        category: params.category || 'custom',
+        tags: params.tags || ['custom'],
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+    };
+}

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

@@ -0,0 +1,11 @@
+/**
+ * QA360 SLO/SLI Management Module
+ *
+ * Exports all SLO/SLI functionality.
+ */
+export type { SLO, SLI, SLIMeasurement, SLOReport, SLOStatus, SLOResult, ErrorBudget, BurnRate, SLOConfig, SLOViolation, SLIType, SLISource, SLIQuery, SLIAggregation, SLIUnit, SLIThreshold, SLICategory } from './types.js';
+export { TimeWindows, createDefaultSLOConfig, createStrictSLOConfig, createRelaxedSLOConfig, createDefaultTestQualitySLO, createDefaultAPISuccessSLO, createDefaultPerformanceSLO, createStrictTestQualitySLO, createStrictAPISuccessSLO, createStrictPerformanceSLO, createRelaxedTestQualitySLO, createRelaxedAPISuccessSLO, createRelaxedPerformanceSLO, createTestPassRateSLI, createAPISuccessRateSLI, createLatencySLI, createCustomSLO, createCustomSLI } from './config.js';
+export { SLICalculator, createSLICalculator } from './sli-calculator.js';
+export { SLOTracker, createSLOTracker, type SLOTrackerOptions, type SLOAlert } from './slo-tracker.js';
+export { SLOVault } from './vault.js';
+export { createDefaultSLOConfig as createSLOConfig } from './config.js';

package/dist/core/slo/index.js

@@ -0,0 +1,15 @@
+/**
+ * QA360 SLO/SLI Management Module
+ *
+ * Exports all SLO/SLI functionality.
+ */
+// Config
+export { TimeWindows, createDefaultSLOConfig, createStrictSLOConfig, createRelaxedSLOConfig, createDefaultTestQualitySLO, createDefaultAPISuccessSLO, createDefaultPerformanceSLO, createStrictTestQualitySLO, createStrictAPISuccessSLO, createStrictPerformanceSLO, createRelaxedTestQualitySLO, createRelaxedAPISuccessSLO, createRelaxedPerformanceSLO, createTestPassRateSLI, createAPISuccessRateSLI, createLatencySLI, createCustomSLO, createCustomSLI } from './config.js';
+// Calculator
+export { SLICalculator, createSLICalculator } from './sli-calculator.js';
+// Tracker
+export { SLOTracker, createSLOTracker } from './slo-tracker.js';
+// Vault integration
+export { SLOVault } from './vault.js';
+// Re-exports for convenience
+export { createDefaultSLOConfig as createSLOConfig } from './config.js';

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

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