@gguf/coder 0.3.1 → 0.3.2

package/source/utils/logging/health-monitor/middleware/http-middleware.ts

@@ -1,75 +0,0 @@
-/**
- * Health check middleware for HTTP servers
- */
-
-/**
- * Health check middleware for HTTP servers
- */
-export function healthCheckMiddleware(healthChecks: {
-	full: () => Promise<{
-		status: 'healthy' | 'degraded' | 'unhealthy';
-		timestamp: string;
-		score: number;
-		checks: Array<{
-			name: string;
-			status: 'pass' | 'fail' | 'warn';
-			score: number;
-		}>;
-	}>;
-	ready: () => Promise<boolean>;
-	alive: () => boolean;
-	metrics: () => unknown;
-}) {
-	return async (
-		req: {path: string},
-		res: {
-			status: (code: number) => {
-				json: (data: unknown) => void;
-			};
-			json: (data: unknown) => void;
-		},
-		next: () => void,
-	) => {
-		if (req.path === '/health') {
-			try {
-				const health = await healthChecks.full();
-				const statusCode =
-					health.status === 'healthy'
-						? 200
-						: health.status === 'degraded'
-							? 200
-							: 503;
-
-				res.status(statusCode).json({
-					status: health.status,
-					timestamp: health.timestamp,
-					score: health.score,
-					checks: health.checks.map(check => ({
-						name: check.name,
-						status: check.status,
-						score: check.score,
-					})),
-				});
-			} catch (error) {
-				res.status(503).json({
-					status: 'unhealthy',
-					timestamp: new Date().toISOString(),
-					error: error instanceof Error ? error.message : 'Unknown error',
-				});
-			}
-		} else if (req.path === '/health/ready') {
-			const ready = await healthChecks.ready();
-			const statusCode = ready ? 200 : 503;
-			res.status(statusCode).json({ready});
-		} else if (req.path === '/health/live') {
-			const alive = healthChecks.alive();
-			const statusCode = alive ? 200 : 503;
-			res.status(statusCode).json({alive});
-		} else if (req.path === '/metrics') {
-			const metrics = healthChecks.metrics();
-			res.json(metrics);
-		} else {
-			next();
-		}
-	};
-}

package/source/utils/logging/health-monitor/types.ts

@@ -1,126 +0,0 @@
-/**
- * Type definitions for health monitoring system
- */
-
-/**
- * Health check result interface
- */
-export interface HealthCheckResult {
-	status: 'healthy' | 'degraded' | 'unhealthy';
-	score: number; // 0-100
-	checks: HealthCheck[];
-	timestamp: string;
-	duration: number;
-	correlationId: string;
-	summary: {
-		total: number;
-		passed: number;
-		failed: number;
-		warnings: number;
-	};
-	recommendations: string[];
-}
-
-/**
- * Individual health check interface
- */
-export interface HealthCheck {
-	name: string;
-	status: 'pass' | 'fail' | 'warn';
-	score: number; // 0-100
-	duration: number;
-	message?: string;
-	details?: Record<string, unknown>;
-	error?: string;
-	threshold?: {
-		warning: number;
-		critical: number;
-	};
-}
-
-/**
- * System metrics interface
- */
-export interface SystemMetrics {
-	timestamp: string;
-	memory: {
-		heapUsed: number;
-		heapTotal: number;
-		external: number;
-		rss: number;
-		heapUsagePercent: number;
-	};
-	cpu: {
-		usage: number;
-		loadAverage: number[];
-	};
-	process: {
-		uptime: number;
-		pid: number;
-		nodeVersion: string;
-		platform: string;
-		arch: string;
-	};
-	logging: {
-		totalLogEntries: number;
-		logRate: number; // entries per second
-		errorRate: number; // errors per second
-		averageLogSize: number;
-		oldestLogEntry?: string;
-		newestLogEntry?: string;
-	};
-	requests: {
-		totalRequests: number;
-		activeRequests: number;
-		averageDuration: number;
-		errorRate: number;
-		requestsPerSecond: number;
-	};
-	performance: {
-		operationCount: number;
-		averageDuration: number;
-		slowOperations: number;
-		memoryIntensiveOps: number;
-	};
-}
-
-/**
- * Health check configuration
- */
-export interface HealthCheckConfig {
-	enabled: boolean;
-	interval: number; // ms between checks
-	timeout: number; // ms per check
-	thresholds: {
-		memory: {
-			heapUsageWarning: number; // percentage
-			heapUsageCritical: number;
-			externalWarning: number; // MB
-			externalCritical: number;
-		};
-		performance: {
-			averageDurationWarning: number; // ms
-			averageDurationCritical: number;
-			errorRateWarning: number; // percentage
-			errorRateCritical: number;
-		};
-		logging: {
-			logRateWarning: number; // logs per second
-			logRateCritical: number;
-			errorRateWarning: number; // percentage
-			errorRateCritical: number;
-		};
-		requests: {
-			durationWarning: number; // ms
-			durationCritical: number;
-			errorRateWarning: number; // percentage
-			errorRateCritical: number;
-		};
-	};
-	alerts: {
-		enabled: boolean;
-		channels: ('console' | 'file' | 'webhook')[];
-		webhookUrl?: string;
-		cooldown: number; // ms between alerts
-	};
-}

package/source/utils/logging/index.spec.ts

@@ -1,284 +0,0 @@
-import {existsSync, mkdirSync, rmSync, writeFileSync} from 'fs';
-import {tmpdir} from 'os';
-import {join} from 'path';
-import test from 'ava';
-
-console.log(`\nlogging/index.spec.ts`);
-
-// Import the logging functions we want to test
-import {
-	createChildLogger,
-	end,
-	flush,
-	getLogger,
-	getLoggerConfig,
-	initializeLogger,
-	isLevelEnabled,
-	log,
-	console as structuredConsole,
-} from './index.js';
-
-// Import logger provider for reset functionality
-import {LoggerProvider} from './logger-provider.js';
-
-// Import types for testing
-import type {LogLevel, LoggerConfig} from './types.js';
-
-// Create a temporary test directory
-const testDir = join(tmpdir(), `coder-logging-test-${Date.now()}`);
-
-test.before(() => {
-	// Create test directory
-	mkdirSync(testDir, {recursive: true});
-
-	// Set test environment variables
-	process.env.NODE_ENV = 'test';
-	process.env.LOG_LEVEL = 'debug';
-});
-
-test.after.always(async () => {
-	// Clean up test directory
-	if (existsSync(testDir)) {
-		rmSync(testDir, {recursive: true, force: true});
-	}
-
-	// Reset logger state
-	await end();
-});
-
-test('initializeLogger creates a logger instance', t => {
-	const logger = initializeLogger({
-		level: 'debug',
-		pretty: true,
-	});
-
-	t.truthy(logger, 'Logger should be created');
-	t.is(typeof logger.info, 'function', 'Logger should have info method');
-	t.is(typeof logger.error, 'function', 'Logger should have error method');
-	t.is(typeof logger.warn, 'function', 'Logger should have warn method');
-	t.is(typeof logger.debug, 'function', 'Logger should have debug method');
-});
-
-test('getLogger returns the same logger instance', t => {
-	// Reset logger state first
-	const logger1 = initializeLogger({level: 'info'});
-	const logger2 = getLogger();
-	const logger3 = getLogger();
-
-	t.is(logger1, logger2, 'Should return same instance');
-	t.is(logger2, logger3, 'Should return same instance');
-});
-
-test('getLogger auto-initializes with defaults', async t => {
-	// Reset logger state
-	await end();
-
-	const logger = getLogger();
-
-	t.truthy(logger, 'Should auto-initialize logger');
-	t.is(typeof logger.info, 'function', 'Should have info method');
-});
-
-test('getLoggerConfig returns current configuration', t => {
-	const config: LoggerConfig = {
-		level: 'warn',
-		pretty: false,
-		redact: ['apiKey'],
-		correlation: true,
-		serialize: true,
-	};
-
-	initializeLogger(config);
-	const retrievedConfig = getLoggerConfig();
-
-	t.truthy(retrievedConfig, 'Should return configuration');
-	// Note: The logger provider may apply default configuration overrides
-	// so we check that the level is set appropriately rather than exact match
-	t.truthy(retrievedConfig!.level, 'Should have level');
-	t.is(retrievedConfig!.pretty, config.pretty, 'Should match pretty setting');
-	// Check that the redaction rules include our custom rule
-	t.true(
-		retrievedConfig!.redact.includes('apiKey'),
-		'Should include custom redaction rule',
-	);
-});
-
-test('createChildLogger creates child with bindings', t => {
-	const parentLogger = initializeLogger({level: 'debug'});
-	const childBindings = {module: 'test', userId: '123'};
-	const childLogger = createChildLogger(childBindings);
-
-	t.truthy(childLogger, 'Should create child logger');
-	t.is(typeof childLogger.info, 'function', 'Child should have info method');
-	t.not(parentLogger, childLogger, 'Should be different instance');
-});
-
-test('isLevelEnabled checks log level correctly', t => {
-	// Reset logger to ensure clean state
-	const provider = LoggerProvider.getInstance();
-	provider.reset();
-
-	// Initialize with debug level to ensure logging is enabled in tests
-	initializeLogger({level: 'debug'});
-
-	// With debug level, these should all be enabled
-	t.true(
-		isLevelEnabled('debug'),
-		'Debug should be enabled',
-	);
-	t.true(
-		isLevelEnabled('trace'),
-		'Trace should be enabled',
-	);
-	t.true(isLevelEnabled('warn'), 'Warn should be enabled');
-	t.true(isLevelEnabled('error'), 'Error should be enabled');
-	t.true(isLevelEnabled('fatal'), 'Fatal should be enabled');
-});
-
-test('log convenience methods work correctly', t => {
-	const logger = initializeLogger({level: 'debug'});
-
-	t.notThrows(() => {
-		log.debug('Debug message');
-		log.info('Info message');
-		log.warn('Warning message');
-		log.error('Error message');
-		log.fatal('Fatal message');
-		log.http('HTTP message');
-		log.trace('Trace message');
-	}, 'Log methods should not throw');
-});
-
-test('structured console facade provides backward compatibility', t => {
-	t.notThrows(() => {
-		structuredConsole.log('Test log message');
-		structuredConsole.info('Test info message');
-		structuredConsole.warn('Test warning message');
-		structuredConsole.error('Test error message');
-		structuredConsole.debug('Test debug message');
-	}, 'Console facade methods should not throw');
-});
-
-test('flush and end methods work correctly', async t => {
-	const logger = initializeLogger({level: 'info'});
-
-	logger.info('Test message for flushing');
-
-	await t.notThrowsAsync(async () => {
-		await flush();
-		await end();
-	}, 'Flush and end should not throw');
-});
-
-test('logger handles different log levels correctly', t => {
-	const logger = initializeLogger({level: 'warn'});
-
-	// These should be filtered out
-	t.notThrows(() => {
-		logger.trace('trace message');
-		logger.debug('debug message');
-		logger.info('info message');
-		logger.http('http message');
-	}, 'Filtered levels should not throw');
-
-	// These should be logged
-	t.notThrows(() => {
-		logger.warn('warn message');
-		logger.error('error message');
-		logger.fatal('fatal message');
-	}, 'Active levels should not throw');
-});
-
-test('logger handles structured data correctly', t => {
-	const logger = initializeLogger({level: 'debug'});
-
-	const testData = {
-		userId: '123',
-		action: 'login',
-		metadata: {ip: '127.0.0.1', userAgent: 'test-agent'},
-	};
-
-	t.notThrows(() => {
-		logger.info('User action', testData);
-		logger.warn('Warning with data', {type: 'validation', details: testData});
-		logger.error('Error with context', {
-			error: new Error('test'),
-			context: testData,
-		});
-	}, 'Structured data should be handled correctly');
-});
-
-test('logger handles edge cases gracefully', t => {
-	const logger = initializeLogger({level: 'debug'});
-
-	// Empty message
-	t.notThrows(() => {
-		logger.info('');
-		logger.info(null as any);
-		logger.info(undefined as any);
-	}, 'Edge cases should not throw');
-
-	// Large objects
-	const largeObject = {data: 'x'.repeat(10000)};
-	t.notThrows(() => {
-		logger.info('Large object', largeObject);
-	}, 'Large objects should be handled');
-
-	// Circular references
-	const circular: any = {a: 1};
-	circular.self = circular;
-	t.notThrows(() => {
-		logger.info('Circular reference', circular);
-	}, 'Circular references should be handled');
-});
-
-test('logger maintains correlation context', t => {
-	const logger = initializeLogger({
-		level: 'debug',
-		correlation: true,
-	});
-
-	t.notThrows(() => {
-		logger.info('Message with correlation');
-		logger.child({requestId: 'req-123'}).info('Child message');
-	}, 'Correlation context should be maintained');
-});
-
-test('logger respects redaction rules', t => {
-	const logger = initializeLogger({
-		level: 'debug',
-		redact: ['apiKey', 'token', 'password', 'secret'],
-	});
-
-	const sensitiveData = {
-		username: 'user123',
-		apiKey: 'sk-1234567890',
-		password: 'secret123',
-		token: 'abc123xyz',
-		safeField: 'public-data',
-	};
-
-	t.notThrows(() => {
-		logger.info('Login attempt', sensitiveData);
-	}, 'Redaction should not throw errors');
-
-	// The actual redaction would be verified by checking log output,
-	// but that requires more complex test setup with output capture
-});
-
-test('multiple logger instances do not interfere', t => {
-	const logger1 = initializeLogger({
-		level: 'debug',
-		pretty: true,
-	});
-
-	// This should return the existing instance
-	const logger2 = getLogger();
-
-	t.is(logger1, logger2, 'Should return same instance');
-
-	t.notThrows(() => {
-		logger1.info('Message from logger1');
-		logger2.debug('Message from logger2');
-	}, 'Multiple references should work');
-});