qa360 2.1.7 → 2.2.0

package/core/src/serve/server.ts

@@ -0,0 +1,230 @@
+/**
+ * QA360 Core Observability Server
+ * Endpoints: /health, /diag, /metrics, /cancel
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { URL } from 'url';
+import { SecurityRedactor } from '../security/redactor.js';
+import { HealthChecker } from './health-checker.js';
+import { DiagnosticsCollector } from './diagnostics-collector.js';
+import { MetricsCollector } from './metrics-collector.js';
+import { ProcessManager } from './process-manager.js';
+
+export interface ServeConfig {
+  port: number;
+  host?: string;
+  metrics?: boolean;
+  readinessCheck?: boolean;
+  verbose?: boolean;
+}
+
+export interface ServeResponse {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+}
+
+export class QA360Server {
+  private server?: ReturnType<typeof createServer>;
+  private healthChecker: HealthChecker;
+  private diagnosticsCollector: DiagnosticsCollector;
+  private metricsCollector: MetricsCollector;
+  private processManager: ProcessManager;
+  private redactor: SecurityRedactor;
+  private startTime: number;
+
+  constructor(private config: ServeConfig) {
+    this.healthChecker = new HealthChecker();
+    this.diagnosticsCollector = new DiagnosticsCollector();
+    this.metricsCollector = new MetricsCollector();
+    this.processManager = new ProcessManager();
+    this.redactor = SecurityRedactor.forLogs();
+    this.startTime = Date.now();
+  }
+
+  async start(): Promise<void> {
+    if (this.server) return;
+
+    await new Promise<void>((resolve, reject) => {
+      const srv = createServer(this.handleRequest.bind(this));
+      srv.on('error', (err: any) => {
+        if (err?.code === 'EADDRINUSE') {
+          this.log('error', 'Port already in use', { port: this.config.port, code: 'HLT003' });
+          reject(Object.assign(new Error('Port already in use'), { code: 'HLT003' }));
+          return;
+        }
+        reject(err);
+      });
+      srv.listen(this.config.port, this.config.host ?? '127.0.0.1', () => {
+        this.server = srv;
+        this.log('info', 'QA360 Server started', {
+          port: this.config.port,
+          host: this.config.host || '127.0.0.1',
+          metrics: this.config.metrics ?? true
+        });
+        resolve();
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.log('info', 'QA360 Server stopped');
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const url = new URL(req.url || '/', `http://${req.headers.host}`);
+    const method = req.method?.toUpperCase() || 'GET';
+    
+    try {
+      const response = await this.routeRequest(method, url.pathname, req);
+      
+      // Set headers
+      Object.entries(response.headers).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
+      
+      res.statusCode = response.status;
+      res.end(response.body);
+      
+      this.log('info', 'Request handled', {
+        method,
+        path: url.pathname,
+        status: response.status
+      });
+      
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      this.log('error', 'Request failed', { method, path: url.pathname, error: errorMessage });
+      
+      res.statusCode = 500;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({
+        error: 'Internal Server Error',
+        code: 'SRV001',
+        message: errorMessage
+      }));
+    }
+  }
+
+  private async routeRequest(method: string, path: string, req: IncomingMessage): Promise<ServeResponse> {
+    // Health endpoint
+    if (method === 'GET' && path === '/health') {
+      return await this.handleHealth();
+    }
+    
+    // Diagnostics endpoint
+    if (method === 'GET' && path === '/diag') {
+      return await this.handleDiagnostics();
+    }
+    
+    // Metrics endpoint
+    if (method === 'GET' && path === '/metrics') {
+      return await this.handleMetrics();
+    }
+    
+    // Cancel endpoint
+    if (method === 'POST' && path.startsWith('/cancel/')) {
+      const runId = path.split('/')[2];
+      return await this.handleCancel(runId, req);
+    }
+    
+    // 404 Not Found
+    return {
+      status: 404,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        error: 'Not Found',
+        code: 'SRV404',
+        message: `Endpoint ${method} ${path} not found`
+      })
+    };
+  }
+
+  private async handleHealth(): Promise<ServeResponse> {
+    const health = await this.healthChecker.check();
+    const status = health.status === 'ok' ? 200 : health.status === 'degraded' ? 200 : 503;
+    
+    return {
+      status,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        ...health,
+        uptime_s: Math.floor((Date.now() - this.startTime) / 1000)
+      }, null, 2)
+    };
+  }
+
+  private async handleDiagnostics(): Promise<ServeResponse> {
+    const diagnostics = await this.diagnosticsCollector.collect();
+    
+    return {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(diagnostics, null, 2)
+    };
+  }
+
+  private async handleMetrics(): Promise<ServeResponse> {
+    if (!this.config.metrics) {
+      return {
+        status: 404,
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'Metrics disabled'
+      };
+    }
+    
+    const metrics = await this.metricsCollector.collect();
+    
+    return {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain; version=0.0.4' },
+      body: metrics
+    };
+  }
+
+  private async handleCancel(runId: string, req: IncomingMessage): Promise<ServeResponse> {
+    if (!runId) {
+      return {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          error: 'Bad Request',
+          code: 'SRV400',
+          message: 'runId is required'
+        })
+      };
+    }
+    
+    const result = await this.processManager.cancelRun(runId);
+    
+    return {
+      status: result.cancelled ? 200 : 404,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(result)
+    };
+  }
+
+  private log(level: 'info' | 'error', message: string, meta: Record<string, any> = {}): void {
+    if (!this.config.verbose && level === 'info') return;
+    
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      service: 'qa360-server',
+      ...(meta ? (this.redactor ? this.redactor.redactObject(meta) : meta) : {})
+    };
+    
+    console.log(JSON.stringify(logEntry));
+  }
+}

package/core/src/slo/config.ts

@@ -0,0 +1,408 @@
+/**
+ * SLO/SLI Default Configuration
+ *
+ * Predefined SLOs and SLIs for common quality metrics.
+ * Factory functions for creating standard configurations.
+ */
+
+import type { SLO, SLI, SLOConfig } from './types.js';
+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(): SLOConfig {
+  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(): SLOConfig {
+  const config = createDefaultSLOConfig();
+
+  config.slos = [
+    createStrictTestQualitySLO(),
+    createStrictAPISuccessSLO(),
+    createStrictPerformanceSLO()
+  ];
+
+  config.alertThresholds = {
+    warning: 20,
+    critical: 50
+  };
+
+  return config;
+}
+
+/**
+ * Create relaxed SLO configuration (development)
+ */
+export function createRelaxedSLOConfig(): SLOConfig {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLO {
+  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(): SLI {
+  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(): SLI {
+  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(): SLI {
+  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: {
+  name: string;
+  description?: string;
+  target: number;
+  windowMs?: number;
+  sliIds: string[];
+  tags?: string[];
+  owner?: string;
+}): SLO {
+  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: {
+  name: string;
+  description?: string;
+  type: SLI['type'];
+  source: SLI['source'];
+  queryString: string;
+  aggregation: SLI['aggregation'];
+  unit: SLI['unit'];
+  threshold: { operator: SLI['threshold']['operator']; value: number };
+  category?: SLI['category'];
+  tags?: string[];
+}): SLI {
+  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/core/src/slo/index.ts

@@ -0,0 +1,68 @@
+/**
+ * QA360 SLO/SLI Management Module
+ *
+ * Exports all SLO/SLI functionality.
+ */
+
+// Types
+export type {
+  SLO,
+  SLI,
+  SLIMeasurement,
+  SLOReport,
+  SLOStatus,
+  SLOResult,
+  ErrorBudget,
+  BurnRate,
+  SLOConfig,
+  SLOViolation,
+  SLIType,
+  SLISource,
+  SLIQuery,
+  SLIAggregation,
+  SLIUnit,
+  SLIThreshold,
+  SLICategory
+} from './types.js';
+
+// 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,
+  type SLOTrackerOptions,
+  type SLOAlert
+} from './slo-tracker.js';
+
+// Vault integration
+export { SLOVault } from './vault.js';
+
+// Re-exports for convenience
+export { createDefaultSLOConfig as createSLOConfig } from './config.js';