DeepSource MCP Server

/** * @fileoverview Simple logging service for the application. * This provides a centralized place for all logging functionality. * * Configuration: * - LOG_LEVEL: Sets the minimum log level (DEBUG, INFO, WARN, ERROR). Defaults to DEBUG. * - LOG_FILE: Path to the log file. If not set, no logs will be written. * * Note: Since MCP servers use stdout for protocol communication, logs are written * to a file instead of stdout/stderr to avoid interference. */ import { writeFileSync, appendFileSync, existsSync, mkdirSync } from 'fs'; import { dirname } from 'path'; /** * Log levels for the application * @enum {string} */ // This enum is part of the public API and is used by consumers, even if not all values are used in this file export enum LogLevel { DEBUG = 'DEBUG', INFO = 'INFO', WARN = 'WARN', ERROR = 'ERROR', } /** * Environment-aware logging configuration */ const LOG_LEVELS_PRIORITY: Record<LogLevel, number> = { [LogLevel.DEBUG]: 0, [LogLevel.INFO]: 1, [LogLevel.WARN]: 2, [LogLevel.ERROR]: 3, }; /** * Get the log file path from environment * @returns {string | null} The log file path or null if not configured * @private */ function getLogFilePath(): string | null { return process.env.LOG_FILE || null; } let logFileInitialized = false; /** * Initialize the log file if needed by creating the directory and file * Only initializes once per process to avoid redundant file operations * @private * @returns {void} */ function initializeLogFile(): void { const logFile = getLogFilePath(); if (logFile && !logFileInitialized) { try { // Create directory if it doesn't exist const dir = dirname(logFile); if (!existsSync(dir)) { mkdirSync(dir, { recursive: true }); } // Create or truncate the log file writeFileSync(logFile, ''); logFileInitialized = true; } catch { // Fail silently if we can't create the log file logFileInitialized = true; // Don't retry } } } /** * Write a log message to file * @param message The formatted log message to write * @private */ function writeToLogFile(message: string): void { const logFile = getLogFilePath(); if (logFile) { try { if (!logFileInitialized) { initializeLogFile(); } appendFileSync(logFile, `${message}\n`); } catch { // Fail silently if we can't write to the log file } } } /** * Check if a log level should be displayed based on the environment configuration * @param level The log level to check * @returns {boolean} True if the log level should be displayed * @private */ function shouldLog(level: LogLevel): boolean { const configuredLevel = (process.env.LOG_LEVEL || 'DEBUG') as LogLevel; return LOG_LEVELS_PRIORITY[level] >= LOG_LEVELS_PRIORITY[configuredLevel]; } /** * Format a log message with timestamp, level, and context information * @param level The log level of the message * @param message The log message content * @param context Optional context identifier * @returns {string} Formatted log message * @private */ function formatLogMessage(level: LogLevel, message: string, context?: string): string { const timestamp = new Date().toISOString(); const contextStr = context ? `[${context}] ` : ''; return `${timestamp} ${level} ${contextStr}${message}`; } /** * Logger service for consistent logging throughout the application */ export class Logger { private context?: string; /** * Create a new logger instance, optionally with a context * @param context Optional context name to identify the log source */ constructor(context?: string) { if (context !== undefined) { this.context = context; } } /** * Log a debug message * @param message The message to log * @param data Optional data to include in the log */ debug(message: string, data?: unknown): void { if (shouldLog(LogLevel.DEBUG) && getLogFilePath()) { const formattedMessage = formatLogMessage(LogLevel.DEBUG, message, this.context); const fullMessage = data !== undefined ? `${formattedMessage} ${JSON.stringify(data, null, 2)}` : formattedMessage; writeToLogFile(fullMessage); } } /** * Log an info message * @param message The message to log * @param data Optional data to include in the log */ info(message: string, data?: unknown): void { if (shouldLog(LogLevel.INFO) && getLogFilePath()) { const formattedMessage = formatLogMessage(LogLevel.INFO, message, this.context); const fullMessage = data !== undefined ? `${formattedMessage} ${JSON.stringify(data, null, 2)}` : formattedMessage; writeToLogFile(fullMessage); } } /** * Log a warning message * @param message The message to log * @param data Optional data to include in the log */ warn(message: string, data?: unknown): void { if (shouldLog(LogLevel.WARN) && getLogFilePath()) { const formattedMessage = formatLogMessage(LogLevel.WARN, message, this.context); const fullMessage = data !== undefined ? `${formattedMessage} ${JSON.stringify(data, null, 2)}` : formattedMessage; writeToLogFile(fullMessage); } } /** * Log an error message with improved error formatting * @param message The message to log * @param error Optional error to include in the log. The error will be formatted for better readability: * - Error objects will include name, message and stack trace * - Objects will be stringified with proper indentation * - Other values will be converted to strings */ error(message: string, error?: unknown): void { if (shouldLog(LogLevel.ERROR) && getLogFilePath()) { const formattedMessage = formatLogMessage(LogLevel.ERROR, message, this.context); // Format the error for better debugging let errorOutput = ''; if (error !== undefined) { if (error instanceof Error) { errorOutput = `${error.name}: ${error.message}${error.stack ? `\n${error.stack}` : ''}`; } else { try { errorOutput = JSON.stringify(error, null, 2); } catch { // Fallback to string representation if JSON.stringify fails errorOutput = String(error); } } } const fullMessage = errorOutput ? `${formattedMessage} ${errorOutput}` : formattedMessage; writeToLogFile(fullMessage); } } } /** * Default logger instance for the application * Pre-configured with the 'DeepSourceMCP' context for quick imports * @const {Logger} */ export const defaultLogger = new Logger('DeepSourceMCP'); /** * Helper function to create a logger with a specific context * @param context The context to use for the logger * @returns A new logger instance with the specified context */ export function createLogger(context: string): Logger { return new Logger(context); } /** * Default export for simpler imports */ export default defaultLogger; // These log levels define the hierarchy for logging operations: // - DEBUG: Detailed information for debugging // - INFO: General information about application operation // - WARN: Warning events that might lead to issues // - ERROR: Error events that might still allow the application to continue // This helps maintain consistent logging patterns throughout the application