tryaii-mcp-server/dist/middleware/utils/logger.js

TryAII MCP Server - 15+ AI models with comparison, cost tracking, and collective intelligence

import winston from 'winston';
import { dirname } from 'path';
import { existsSync, mkdirSync } from 'fs';
import { config } from './config.js';
// Ensure log directory exists
const logDir = dirname(config.logging.file);
if (!existsSync(logDir)) {
    mkdirSync(logDir, { recursive: true });
}
// Define log format
const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json());
// Console format for development
const consoleFormat = winston.format.combine(winston.format.colorize(), winston.format.timestamp({ format: 'HH:mm:ss' }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
    let log = `${timestamp} [${level}] ${message}`;
    if (Object.keys(meta).length > 0) {
        log += ` ${JSON.stringify(meta)}`;
    }
    return log;
}));
// Create logger instance
export const logger = winston.createLogger({
    level: config.logging.level,
    format: logFormat,
    transports: [
        // File transport
        new winston.transports.File({
            filename: config.logging.file,
            maxsize: 10 * 1024 * 1024, // 10MB
            maxFiles: 5,
            tailable: true
        }),
        // Console transport (only in development or test)
        ...(config.server.nodeEnv === 'development' || config.server.nodeEnv === 'test' ? [
            new winston.transports.Console({
                format: consoleFormat
            })
        ] : [])
    ],
    // Handle uncaught exceptions
    exceptionHandlers: [
        new winston.transports.File({
            filename: config.logging.file.replace('.log', '-exceptions.log')
        })
    ],
    // Handle unhandled promise rejections
    rejectionHandlers: [
        new winston.transports.File({
            filename: config.logging.file.replace('.log', '-rejections.log')
        })
    ]
});
// Structured logging helpers
export const loggers = {
    // Request logging
    request: (requestId, method, url, metadata = {}) => {
        logger.info('HTTP Request', {
            requestId,
            method,
            url,
            ...metadata
        });
    },
    response: (requestId, statusCode, responseTime, metadata = {}) => {
        logger.info('HTTP Response', {
            requestId,
            statusCode,
            responseTime,
            ...metadata
        });
    },
    // Authentication logging
    authSuccess: (userId, keyId, metadata = {}) => {
        logger.info('Authentication successful', {
            userId,
            keyId,
            ...metadata
        });
    },
    authFailure: (reason, metadata = {}) => {
        logger.warn('Authentication failed', {
            reason,
            ...metadata
        });
    },
    // Session logging
    sessionCreated: (sessionId, userId, keyId) => {
        logger.info('Session created', {
            sessionId,
            userId,
            keyId
        });
    },
    sessionExpired: (sessionId, userId, reason) => {
        logger.info('Session expired', {
            sessionId,
            userId,
            reason
        });
    },
    // MCP logging
    mcpRequest: (requestId, method, params) => {
        logger.debug('MCP Request', {
            requestId,
            method,
            params
        });
    },
    mcpResponse: (requestId, success, responseTime, metadata = {}) => {
        logger.debug('MCP Response', {
            requestId,
            success,
            responseTime,
            ...metadata
        });
    },
    mcpError: (requestId, error, metadata = {}) => {
        logger.error('MCP Error', {
            requestId,
            error: error.message,
            stack: error.stack,
            ...metadata
        });
    },
    // Process logging
    processStart: (processType, pid, metadata = {}) => {
        logger.info('Process started', {
            processType,
            pid,
            ...metadata
        });
    },
    processExit: (processType, pid, code, signal) => {
        logger.warn('Process exited', {
            processType,
            pid,
            exitCode: code,
            signal
        });
    },
    processRestart: (processType, attempt, maxAttempts) => {
        logger.warn('Process restart attempt', {
            processType,
            attempt,
            maxAttempts
        });
    },
    // Error logging
    error: (message, error, metadata = {}) => {
        logger.error(message, {
            error: error.message,
            stack: error.stack,
            ...metadata
        });
    },
    // Performance logging
    performance: (operation, duration, metadata = {}) => {
        logger.info('Performance metric', {
            operation,
            duration,
            ...metadata
        });
    },
    // Business logic logging
    apiUsage: (userId, keyId, endpoint, cost) => {
        logger.info('API usage recorded', {
            userId,
            keyId,
            endpoint,
            cost
        });
    }
};
// Export configuration for health checks
export const loggerConfig = {
    level: config.logging.level,
    logFile: config.logging.file,
    transports: logger.transports.length
};
//# sourceMappingURL=logger.js.map