@gguf/coder 0.2.9 → 0.3.1

package/source/utils/logging/health-monitor/checks/request-check.spec.ts

@@ -0,0 +1,56 @@
+/**
+ * Request check tests
+ */
+
+import test from 'ava';
+import type {HealthCheckConfig} from '../types.js';
+import {checkRequestTracking} from './request-check.js';
+
+const createMockConfig = (): HealthCheckConfig => ({
+	enabled: true,
+	interval: 5000,
+	timeout: 1000,
+	thresholds: {
+		memory: {
+			heapUsageWarning: 0.8,
+			heapUsageCritical: 0.9,
+			externalWarning: 256,
+			externalCritical: 512,
+		},
+		performance: {
+			averageDurationWarning: 1000,
+			averageDurationCritical: 5000,
+			errorRateWarning: 0.05,
+			errorRateCritical: 0.1,
+		},
+		logging: {
+			logRateWarning: 100,
+			logRateCritical: 500,
+			errorRateWarning: 0.02,
+			errorRateCritical: 0.05,
+		},
+		requests: {
+			durationWarning: 1000,
+			durationCritical: 5000,
+			errorRateWarning: 0.05,
+			errorRateCritical: 0.1,
+		},
+	},
+	alerts: {
+		enabled: true,
+		channels: ['console'],
+		cooldown: 60000,
+	},
+});
+
+test('checkRequestTracking returns health check result', t => {
+	const config = createMockConfig();
+	const result = checkRequestTracking(config);
+
+	t.is(result.name, 'request-tracking');
+	t.true(['pass', 'warn', 'fail'].includes(result.status));
+	t.true(result.score >= 0 && result.score <= 100);
+	t.true(result.duration >= 0);
+	t.truthy(result.message);
+	t.truthy(result.details);
+});

package/source/utils/logging/health-monitor/checks/request-check.ts

@@ -0,0 +1,76 @@
+/**
+ * Request tracking health check
+ */
+
+import {globalRequestTracker} from '../../request-tracker.js';
+import type {HealthCheck, HealthCheckConfig} from '../types.js';
+
+/**
+ * Calculate score based on status and value
+ */
+function calculateScore(
+	status: 'pass' | 'fail' | 'warn',
+	value: number,
+	warningThreshold: number,
+	criticalThreshold: number,
+): number {
+	if (status === 'fail') return 0;
+	if (status === 'pass') return 100;
+	if (status === 'warn') {
+		// Calculate score based on how far from critical threshold
+		const range = criticalThreshold - warningThreshold;
+		const distance = criticalThreshold - value;
+		return Math.max(50, Math.min(80, 50 + (distance / range) * 30));
+	}
+	return 50; // default for unknown status
+}
+
+/**
+ * Check request tracking health
+ */
+export function checkRequestTracking(config: HealthCheckConfig): HealthCheck {
+	const startTime = performance.now();
+	const stats = globalRequestTracker.getStats();
+	const thresholds = config.thresholds.requests;
+
+	let status: 'pass' | 'fail' | 'warn' = 'pass';
+	let message = 'Request tracking is healthy';
+	const details = {
+		totalRequests: stats.totalRequests,
+		averageDuration: Math.round(stats.averageDuration),
+		errorRate: Math.round(stats.errorRate * 10000) / 100, // percentage with 2 decimals
+		activeRequests: globalRequestTracker.getActiveRequests().length,
+	};
+
+	if (stats.errorRate > thresholds.errorRateCritical) {
+		status = 'fail';
+		message = 'Request error rate is critically high';
+	} else if (stats.averageDuration > thresholds.durationCritical) {
+		status = 'fail';
+		message = 'Request duration is critically high';
+	} else if (stats.errorRate > thresholds.errorRateWarning) {
+		status = 'warn';
+		message = 'Request error rate is elevated';
+	} else if (stats.averageDuration > thresholds.durationWarning) {
+		status = 'warn';
+		message = 'Request duration is elevated';
+	}
+
+	return {
+		name: 'request-tracking',
+		status,
+		score: calculateScore(
+			status,
+			stats.errorRate,
+			thresholds.errorRateWarning,
+			thresholds.errorRateCritical,
+		),
+		duration: performance.now() - startTime,
+		message,
+		details,
+		threshold: {
+			warning: thresholds.errorRateWarning,
+			critical: thresholds.errorRateCritical,
+		},
+	};
+}

package/source/utils/logging/health-monitor/core/health-check-runner.spec.ts

@@ -0,0 +1,70 @@
+/**
+ * Health check runner tests
+ */
+
+import test from 'ava';
+import type {HealthCheckConfig} from '../types.js';
+import {runHealthCheck} from './health-check-runner.js';
+
+const createMockConfig = (): HealthCheckConfig => ({
+	enabled: true,
+	interval: 5000,
+	timeout: 1000,
+	thresholds: {
+		memory: {
+			heapUsageWarning: 0.8,
+			heapUsageCritical: 0.9,
+			externalWarning: 256,
+			externalCritical: 512,
+		},
+		performance: {
+			averageDurationWarning: 1000,
+			averageDurationCritical: 5000,
+			errorRateWarning: 0.05,
+			errorRateCritical: 0.1,
+		},
+		logging: {
+			logRateWarning: 100,
+			logRateCritical: 500,
+			errorRateWarning: 0.02,
+			errorRateCritical: 0.05,
+		},
+		requests: {
+			durationWarning: 1000,
+			durationCritical: 5000,
+			errorRateWarning: 0.05,
+			errorRateCritical: 0.1,
+		},
+	},
+	alerts: {
+		enabled: true,
+		channels: ['console'],
+		cooldown: 60000,
+	},
+});
+
+test('runHealthCheck returns health check result', async t => {
+	const config = createMockConfig();
+	const result = await runHealthCheck(config, 'test-correlation-id');
+
+	t.true(['healthy', 'degraded', 'unhealthy'].includes(result.status));
+	t.true(result.score >= 0 && result.score <= 100);
+	t.true(Array.isArray(result.checks));
+	t.true(result.checks.length > 0);
+	t.truthy(result.timestamp);
+	t.is(result.correlationId, 'test-correlation-id');
+	t.truthy(result.summary);
+	t.true(Array.isArray(result.recommendations));
+});
+
+test('runHealthCheck includes all expected checks', async t => {
+	const config = createMockConfig();
+	const result = await runHealthCheck(config, 'test-correlation-id');
+
+	const checkNames = result.checks.map(c => c.name);
+	t.true(checkNames.includes('memory-usage'));
+	t.true(checkNames.includes('logging-system'));
+	t.true(checkNames.includes('request-tracking'));
+	t.true(checkNames.includes('performance-monitoring'));
+	t.true(checkNames.includes('configuration-system'));
+});

package/source/utils/logging/health-monitor/core/health-check-runner.ts

@@ -0,0 +1,138 @@
+/**
+ * Health check orchestration
+ */
+
+import {withNewCorrelationContext} from '../../correlation.js';
+import {loggerProvider} from '../../logger-provider.js';
+import type {CorrelationContext} from '../../types.js';
+
+const getLogger = () => loggerProvider.getLogger();
+import {checkConfigurationSystem} from '../checks/configuration-check.js';
+import {checkLoggingSystem} from '../checks/logging-check.js';
+import {checkMemory} from '../checks/memory-check.js';
+import {checkPerformanceMonitoring} from '../checks/performance-check.js';
+import {checkRequestTracking} from '../checks/request-check.js';
+import type {
+	HealthCheck,
+	HealthCheckConfig,
+	HealthCheckResult,
+} from '../types.js';
+import {generateRecommendations} from './scoring.js';
+
+// Get logger instance directly to avoid circular dependencies
+const logger = getLogger();
+
+/**
+ * Run a comprehensive health check
+ */
+export async function runHealthCheck(
+	config: HealthCheckConfig,
+	correlationId: string,
+): Promise<HealthCheckResult> {
+	return withNewCorrelationContext(async (_context: CorrelationContext) => {
+		const startTime = performance.now();
+
+		try {
+			logger.debug('Starting health check', {
+				correlationId,
+				source: 'health-monitor',
+			});
+
+			const checks: HealthCheck[] = [];
+
+			// Run all health checks
+			checks.push(checkMemory(config));
+			checks.push(checkLoggingSystem(config));
+			checks.push(checkRequestTracking(config));
+			checks.push(checkPerformanceMonitoring(config));
+			checks.push(checkConfigurationSystem(config));
+
+			// Calculate overall health
+			const totalChecks = checks.length;
+			const passedChecks = checks.filter(c => c.status === 'pass').length;
+			const failedChecks = checks.filter(c => c.status === 'fail').length;
+			const warningChecks = checks.filter(c => c.status === 'warn').length;
+			const averageScore =
+				checks.reduce((sum, c) => sum + c.score, 0) / totalChecks;
+
+			// Determine overall status
+			let status: 'healthy' | 'degraded' | 'unhealthy';
+			if (failedChecks > 0) {
+				status = 'unhealthy';
+			} else if (warningChecks > 0 || averageScore < 80) {
+				status = 'degraded';
+			} else {
+				status = 'healthy';
+			}
+
+			const duration = performance.now() - startTime;
+
+			const result: HealthCheckResult = {
+				status,
+				score: Math.round(averageScore),
+				checks,
+				timestamp: new Date().toISOString(),
+				duration: Math.round(duration),
+				correlationId,
+				summary: {
+					total: totalChecks,
+					passed: passedChecks,
+					failed: failedChecks,
+					warnings: warningChecks,
+				},
+				recommendations: generateRecommendations(checks, status),
+			};
+
+			// Log health check result
+			logger.info('Health check completed', {
+				status,
+				score: result.score,
+				duration: `${duration.toFixed(2)}ms`,
+				summary: result.summary,
+				correlationId,
+				source: 'health-monitor',
+			});
+
+			return result;
+		} catch (error) {
+			const duration = performance.now() - startTime;
+
+			logger.error('Health check failed', {
+				error: error instanceof Error ? error.message : error,
+				duration: `${duration.toFixed(2)}ms`,
+				correlationId,
+				source: 'health-monitor',
+			});
+
+			const result: HealthCheckResult = {
+				status: 'unhealthy',
+				score: 0,
+				checks: [
+					{
+						name: 'health-check-system',
+						status: 'fail',
+						score: 0,
+						duration,
+						error: error instanceof Error ? error.message : String(error),
+					},
+				],
+				timestamp: new Date().toISOString(),
+				duration: Math.round(duration),
+				correlationId,
+				summary: {
+					total: 1,
+					passed: 0,
+					failed: 1,
+					warnings: 0,
+				},
+				recommendations: [
+					'Fix health check system errors',
+					'Check system resources',
+					'Review configuration',
+				],
+			};
+
+			return result;
+		}
+	});
+}

package/source/utils/logging/health-monitor/core/health-monitor.spec.ts

@@ -0,0 +1,58 @@
+/**
+ * HealthMonitor class tests
+ */
+
+import test from 'ava';
+import {HealthMonitor} from './health-monitor.js';
+
+test('HealthMonitor can be instantiated', t => {
+	const monitor = new HealthMonitor();
+	t.truthy(monitor);
+});
+
+test('HealthMonitor is not active by default', t => {
+	const monitor = new HealthMonitor();
+	t.false(monitor.isActive());
+});
+
+test('HealthMonitor can get system metrics', t => {
+	const monitor = new HealthMonitor();
+	const metrics = monitor.getSystemMetrics();
+
+	t.truthy(metrics);
+	t.truthy(metrics.timestamp);
+	t.truthy(metrics.memory);
+	t.truthy(metrics.cpu);
+	t.truthy(metrics.process);
+	t.truthy(metrics.logging);
+	t.truthy(metrics.requests);
+	t.truthy(metrics.performance);
+});
+
+test('HealthMonitor can run a health check', async t => {
+	const monitor = new HealthMonitor();
+	const result = await monitor.runHealthCheck();
+
+	t.true(['healthy', 'degraded', 'unhealthy'].includes(result.status));
+	t.true(result.score >= 0 && result.score <= 100);
+	t.true(Array.isArray(result.checks));
+});
+
+test('HealthMonitor can update config', t => {
+	const monitor = new HealthMonitor();
+	monitor.updateConfig({
+		interval: 10000,
+	});
+
+	// The test passes if no error is thrown
+	t.pass();
+});
+
+test('HealthMonitor can get last health check', async t => {
+	const monitor = new HealthMonitor();
+	t.is(monitor.getLastHealthCheck(), undefined);
+
+	await monitor.runHealthCheck();
+	const lastCheck = monitor.getLastHealthCheck();
+	t.truthy(lastCheck);
+});