@gguf/coder 0.3.0 → 0.3.1

package/source/utils/logging/logger-provider.ts

@@ -0,0 +1,362 @@
+/**
+ * Logger Provider - Implements dependency injection pattern for logging
+ * This file provides centralized logger management without circular dependencies
+ */
+
+import {createLogMethods} from './log-method-factory.js';
+import type {LogLevel, Logger, LoggerConfig} from './types.js';
+
+export class LoggerProvider {
+	private static instance: LoggerProvider | null = null;
+	private _logger: Logger | null = null;
+	private _config: LoggerConfig | null = null;
+	private _dependenciesLoaded = false;
+
+	// Lazy-loaded dependencies
+	private _createPinoLogger:
+		| ((config?: Partial<LoggerConfig>) => Logger)
+		| null = null;
+	private _createConfig:
+		| ((config?: Partial<LoggerConfig>) => LoggerConfig)
+		| null = null;
+
+	private constructor() {
+		// Private constructor for singleton pattern
+	}
+
+	/**
+	 * Get the singleton logger provider instance
+	 */
+	public static getInstance(): LoggerProvider {
+		if (!LoggerProvider.instance) {
+			LoggerProvider.instance = new LoggerProvider();
+		}
+		return LoggerProvider.instance;
+	}
+
+	/**
+	 * Initialize lazy-loaded dependencies to avoid circular imports
+	 */
+	private ensureDependenciesLoaded() {
+		if (this._dependenciesLoaded) {
+			return;
+		}
+
+		// For now, use fallback logger synchronously to avoid circular dependencies
+		// The real Pino logger will be loaded asynchronously when needed
+		this._createPinoLogger = () => this.createFallbackLogger();
+		this._createConfig = (config?: Partial<LoggerConfig>) => ({
+			level: 'silent', // Default to silent for production CLI usage
+			pretty: false,
+			redact: [],
+			correlation: false,
+			serialize: false,
+			...config,
+		});
+		this._dependenciesLoaded = true;
+
+		// Asynchronously load the real dependencies and replace the fallback
+		this.loadRealDependencies().catch(error => {
+			try {
+				const fallbackLogger = this.createFallbackLogger();
+				fallbackLogger.error(
+					'[LOGGER_PROVIDER] Failed to load real dependencies',
+					{
+						error: this.formatErrorForLogging(error),
+						fallback: true,
+						source: 'logger-provider',
+						timestamp: new Date().toISOString(),
+					},
+				);
+			} catch (fallbackError) {
+				// Absolute fallback to console if everything else fails
+				console.error(
+					'[LOGGER_PROVIDER] Critical failure - fallback logger failed:',
+					fallbackError,
+					'Original error:',
+					error,
+				);
+			}
+		});
+	}
+
+	/**
+	 * Asynchronously load real Pino dependencies
+	 * Uses dynamic imports to avoid circular dependency issues
+	 */
+	private async loadRealDependencies() {
+		// Skip if already loaded to prevent duplicate loading
+		if (this._dependenciesLoaded) {
+			// Only log in development mode to avoid noise for end users
+			if (process.env.NODE_ENV === 'development') {
+				this.createFallbackLogger().debug('Real dependencies already loaded', {
+					source: 'logger-provider',
+					status: 'already-loaded',
+				});
+			}
+			return;
+		}
+
+		const startTime = Date.now();
+		// Only log in development mode to avoid noise for end users
+		if (process.env.NODE_ENV === 'development') {
+			this.createFallbackLogger().info('Loading real Pino dependencies', {
+				source: 'logger-provider',
+				method: 'dynamic-import',
+				status: 'starting',
+			});
+		}
+
+		try {
+			// Load dependencies dynamically to avoid circular imports
+			// Using Promise.all for parallel loading to improve performance
+			const [pinoLogger, configModule] = await Promise.all([
+				import('./pino-logger.js'),
+				import('./config.js'),
+			]);
+
+			// Verify imports were successful
+			if (!pinoLogger?.createPinoLogger || !configModule?.createConfig) {
+				throw new Error('Dynamic imports returned invalid modules');
+			}
+
+			this._createPinoLogger = pinoLogger.createPinoLogger;
+			this._createConfig = configModule.createConfig;
+			this._dependenciesLoaded = true;
+
+			// If we already have a logger with fallback config, reinitialize it with real config
+			if (this._logger && this._config) {
+				try {
+					this._logger = this._createPinoLogger(this._config);
+					// Only log in development mode
+					if (process.env.NODE_ENV === 'development') {
+						this.createFallbackLogger().info(
+							'Logger reinitialized with real Pino instance',
+							{
+								source: 'logger-provider',
+								status: 'reinitialized',
+								duration: Date.now() - startTime,
+							},
+						);
+					}
+				} catch (reinitError) {
+					this.createFallbackLogger().warn(
+						'Failed to reinitialize logger, keeping fallback',
+						{
+							error: this.formatErrorForLogging(reinitError),
+							source: 'logger-provider',
+							status: 'reinit-failed',
+						},
+					);
+				}
+			}
+
+			// Only log in development mode
+			if (process.env.NODE_ENV === 'development') {
+				this.createFallbackLogger().info(
+					'Real dependencies loaded successfully',
+					{
+						source: 'logger-provider',
+						status: 'success',
+						duration: Date.now() - startTime,
+						modules: ['pino-logger', 'config'],
+					},
+				);
+			}
+		} catch (error) {
+			try {
+				const fallbackLogger = this.createFallbackLogger();
+				fallbackLogger.error(
+					'[LOGGER_PROVIDER] Failed to load real dependencies',
+					{
+						error: this.formatErrorForLogging(error),
+						fallback: true,
+						source: 'logger-provider',
+						status: 'load-failed',
+						duration: Date.now() - startTime,
+					},
+				);
+			} catch (fallbackError) {
+				// Absolute fallback to console if everything else fails
+				console.error(
+					'[LOGGER_PROVIDER] Critical failure - fallback logger failed:',
+					fallbackError,
+					'Original error:',
+					error,
+				);
+			}
+			// Keep the fallback logger
+		}
+	}
+
+	/**
+	 * Create fallback logger when dependencies fail to load
+	 */
+	private createFallbackLogger(): Logger {
+		// Check current config level - default to silent for production
+		const configLevel = this._config?.level || 'silent';
+		const isSilent = configLevel === 'silent';
+
+		// If silent, return a no-op logger
+		if (isSilent) {
+			const noOp = () => {};
+			return {
+				fatal: noOp,
+				error: noOp,
+				warn: noOp,
+				info: noOp,
+				http: noOp,
+				debug: noOp,
+				trace: noOp,
+				child: (_bindings: Record<string, unknown>) =>
+					this.createFallbackLogger(),
+				isLevelEnabled: (_level: string) => false,
+				flush: async () => Promise.resolve(),
+				end: async () => Promise.resolve(),
+			};
+		}
+
+		const fallbackConsole = console; // Use console as the logger
+
+		// Create all log methods using the factory
+		const logMethods = createLogMethods(fallbackConsole, {
+			consolePrefix: '',
+			transformArgs: (args, _level, _msg) => {
+				// Note: Level prefix is handled by consolePrefix option in createLogMethod
+				return args;
+			},
+		});
+
+		return {
+			...logMethods,
+			child: (_bindings: Record<string, unknown>) =>
+				this.createFallbackLogger(),
+			isLevelEnabled: (_level: string) => true,
+			flush: async () => Promise.resolve(),
+			end: async () => Promise.resolve(),
+		};
+	}
+
+	/**
+	 * Create default configuration based on environment
+	 */
+	private createDefaultConfig(
+		override: Partial<LoggerConfig> = {},
+	): LoggerConfig {
+		const isDev = process.env.NODE_ENV === 'development';
+		const isTest = process.env.NODE_ENV === 'test';
+
+		const defaultConfig: LoggerConfig = {
+			level: isTest
+				? 'silent'
+				: isDev
+					? 'debug'
+					: (process.env.CODER_LOG_LEVEL as LogLevel) || 'silent', // Default to silent for production/CLI usage
+			pretty: isDev,
+			redact: ['apiKey', 'token', 'password', 'secret'],
+			correlation: true,
+			serialize: !isDev,
+		};
+
+		return {...defaultConfig, ...override};
+	}
+
+	/**
+	 * Initialize the logger with configuration
+	 */
+	public initializeLogger(config?: Partial<LoggerConfig>): Logger {
+		if (this._logger) {
+			return this._logger;
+		}
+
+		this.ensureDependenciesLoaded();
+		this._config = this.createDefaultConfig(config);
+		this._logger =
+			this._createPinoLogger?.(this._config) ?? this.createFallbackLogger();
+
+		return this._logger;
+	}
+
+	/**
+	 * Get the current logger instance
+	 */
+	public getLogger(): Logger {
+		if (!this._logger) {
+			// Auto-initialize with defaults if not already done
+			return this.initializeLogger();
+		}
+		return this._logger;
+	}
+
+	/**
+	 * Get the current configuration
+	 */
+	public getLoggerConfig(): LoggerConfig | null {
+		return this._config;
+	}
+
+	/**
+	 * Create a child logger with additional context
+	 */
+	public createChildLogger(bindings: Record<string, unknown>): Logger {
+		const parent = this.getLogger();
+		return parent.child(bindings);
+	}
+
+	/**
+	 * Format error for structured logging
+	 */
+	private formatErrorForLogging(error: unknown): object {
+		if (error instanceof Error) {
+			return {
+				message: error.message,
+				stack: error.stack,
+				name: error.name,
+				cause: error.cause,
+			};
+		}
+		return {value: error};
+	}
+
+	/**
+	 * Check if a log level is enabled
+	 */
+	public isLevelEnabled(level: LogLevel): boolean {
+		const logger = this.getLogger();
+		return logger.isLevelEnabled(level);
+	}
+
+	/**
+	 * Reset the logger instance (useful for testing)
+	 */
+	public reset(): void {
+		this._logger = null;
+		this._config = null;
+		this._dependenciesLoaded = false;
+		this._createPinoLogger = null;
+		this._createConfig = null;
+	}
+
+	/**
+	 * Flush any pending logs
+	 */
+	public async flush(): Promise<void> {
+		if (this._logger) {
+			await this._logger.flush();
+		}
+	}
+
+	/**
+	 * End the logger and close all streams
+	 */
+	public async end(): Promise<void> {
+		if (this._logger) {
+			await this._logger.end();
+			this._logger = null;
+			this._config = null;
+		}
+	}
+}
+
+// Export the singleton instance for easy access
+export const loggerProvider = LoggerProvider.getInstance();

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

@@ -0,0 +1,209 @@
+import test from 'ava';
+import {
+	correlationStorage,
+	getCurrentCorrelationContext,
+} from './correlation.js';
+import {
+	checkMemoryThresholds,
+	measureTime,
+	takePerformanceSnapshot,
+	trackPerformance,
+} from './performance.js';
+
+// Test the trackPerformance decorator with async context handling
+test('trackPerformance decorator maintains correlation context throughout async operation', async t => {
+	const testFn = async (value: unknown) => {
+		// Simulate async operation
+		await new Promise(resolve => setTimeout(resolve, 10));
+		return `processed-${String(value)}`;
+	};
+
+	const decoratedFn = trackPerformance(testFn, 'test-async-operation', {
+		logLevel: 'debug',
+		trackMemory: false,
+		trackCpu: false,
+	});
+
+	const result = await decoratedFn('test-input');
+
+	t.is(result, 'processed-test-input', 'Function should return correct result');
+});
+
+test('trackPerformance decorator handles errors correctly', async t => {
+	const testFn = async () => {
+		throw new Error('Test error');
+	};
+
+	const decoratedFn = trackPerformance(testFn, 'test-error-handling', {
+		logLevel: 'debug',
+		trackMemory: false,
+		trackCpu: false,
+	});
+
+	const error = await t.throwsAsync(async () => {
+		await decoratedFn();
+	});
+
+	t.is(error.message, 'Test error', 'Error should be propagated correctly');
+});
+
+test('measureTime function maintains correlation context', async t => {
+	const result = await measureTime(
+		async () => {
+			await new Promise(resolve => setTimeout(resolve, 5));
+			return 'test-result';
+		},
+		'test-measurement',
+		{
+			logPerformance: false,
+			trackMemory: false,
+			trackCpu: false,
+		},
+	);
+
+	t.is(result.result, 'test-result', 'Should return correct result');
+	t.truthy(result.duration >= 0, 'Should have valid duration');
+});
+
+test('checkMemoryThresholds function works correctly', t => {
+	const memory = {
+		heapUsed: 100 * 1024 * 1024, // 100MB
+		heapTotal: 200 * 1024 * 1024, // 200MB
+		external: 50 * 1024 * 1024, // 50MB
+		rss: 150 * 1024 * 1024, // 150MB
+		arrayBuffers: 10 * 1024 * 1024, // 10MB
+	};
+
+	const result = checkMemoryThresholds(memory, {
+		heapUsagePercentThreshold: 0.9,
+		heapUsageAbsoluteThreshold: 512,
+	});
+
+	t.true(result.isHealthy, 'Should be healthy with these thresholds');
+	t.is(result.warnings.length, 0, 'Should have no warnings');
+});
+
+test('takePerformanceSnapshot function works correctly', t => {
+	const snapshot = takePerformanceSnapshot();
+
+	t.truthy(snapshot.timestamp, 'Should have timestamp');
+	t.truthy(snapshot.memory, 'Should have memory data');
+	t.truthy(snapshot.uptime >= 0, 'Should have uptime');
+	t.truthy(snapshot.correlationId, 'Should have correlation ID');
+});
+
+test('trackPerformance with complex async chains maintains context', async t => {
+	const testFn = async () => {
+		// Complex async chain
+		const step1 = await new Promise(resolve =>
+			setTimeout(() => resolve('step1'), 10),
+		);
+		const step2 = await new Promise(resolve =>
+			setTimeout(() => resolve('step2'), 10),
+		);
+		const step3 = await new Promise(resolve =>
+			setTimeout(() => resolve('step3'), 10),
+		);
+
+		return {step1, step2, step3};
+	};
+
+	const decoratedFn = trackPerformance(testFn, 'complex-async-chain', {
+		logLevel: 'debug',
+		trackMemory: false,
+		trackCpu: false,
+	});
+
+	const result = await decoratedFn();
+
+	t.deepEqual(
+		result,
+		{step1: 'step1', step2: 'step2', step3: 'step3'},
+		'Should handle complex async chains',
+	);
+});
+
+test('trackPerformance with nested async operations', async t => {
+	const outerFn = async () => {
+		const innerResult = await trackPerformance(
+			async () => {
+				await new Promise(resolve => setTimeout(resolve, 5));
+				return 'inner-result';
+			},
+			'nested-operation',
+			{logLevel: 'debug', trackMemory: false, trackCpu: false},
+		)();
+
+		return `outer-${innerResult}`;
+	};
+
+	const decoratedFn = trackPerformance(outerFn, 'outer-operation', {
+		logLevel: 'debug',
+		trackMemory: false,
+		trackCpu: false,
+	});
+
+	const result = await decoratedFn();
+
+	t.is(result, 'outer-inner-result', 'Should handle nested async operations');
+});
+
+test('measureTime with thresholds', async t => {
+	const result = await measureTime(
+		async () => {
+			// Use a longer delay to ensure we exceed the threshold
+			await new Promise(resolve => setTimeout(resolve, 50));
+			return 'slow-result';
+		},
+		'slow-operation',
+		{
+			logPerformance: false,
+			trackMemory: false,
+			trackCpu: false,
+			thresholds: {
+				duration: 10, // Set threshold below actual duration
+			},
+		},
+	);
+
+	t.is(
+		result.result,
+		'slow-result',
+		'Should return correct result even with threshold exceeded',
+	);
+	t.true(result.duration >= 10, 'Should have duration >= 10ms');
+});
+
+test('trackPerformance maintains context across Promise boundaries', async t => {
+	let contextId: string | null = null;
+
+	const testFn = async () => {
+		// Get context at start
+		const startContext = correlationStorage.getStore();
+
+		// Simulate async boundary
+		await new Promise(resolve => setTimeout(resolve, 10));
+
+		// Get context after async boundary
+		const endContext = correlationStorage.getStore();
+
+		// Both should be the same context
+		if (startContext && endContext) {
+			contextId = startContext.id;
+			return startContext.id === endContext.id;
+		}
+
+		return false;
+	};
+
+	const decoratedFn = trackPerformance(testFn, 'context-persistence-test', {
+		logLevel: 'debug',
+		trackMemory: false,
+		trackCpu: false,
+	});
+
+	const result = await decoratedFn();
+
+	t.true(result, 'Context should persist across async boundaries');
+	t.truthy(contextId, 'Should have a valid context ID');
+});