@gguf/coder 0.3.1 → 0.3.2

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

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

@@ -1,209 +0,0 @@
-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');
-});