Optimizacion de logger

db.ts

export async function connectDB() {
    try {
        Logger.info("Intentando autenticar con la base de datos...");
        await sequelize.authenticate({
            logging: (sql, timing) => {
                Logger.debug(`SQL: ${sql}`);
                if (timing) {
                    Logger.debug(`Tiempo de ejecución: ${timing}ms`);
                }
            },
        });
        Logger.info("Conexión a la base de datos establecida correctamente");
        if (enviroments.NODE_ENV === "production") return;
    } catch (error) {
        Logger.error("Error al conectar con la base de datos:", {
            error: error instanceof Error ? error.message : "Unknown error",
            stack: error instanceof Error ? error.stack : undefined,
        });
        throw error;
    }
}

logger.ts

import winston from "winston";
import DailyRotateFile from "winston-daily-rotate-file";
import enviroments from "~/config/server/environments.config";

// Define log levels
const levels = {
    error: 0,
    warn: 1,
    info: 2,
    http: 3,
    debug: 4,
};

// Determine log level based on environment
const level = () => (enviroments.NODE_ENV === "development" ? "debug" : "warn");

// Define log colors
const colors = {
    error: "red",
    warn: "yellow",
    info: "green",
    http: "magenta",
    debug: "white",
};

winston.addColors(colors);

// Custom log format
const format = winston.format.combine(
    winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" }),
    winston.format.colorize({ all: true }),
    winston.format.printf(
        (info) => `${info.timestamp} ${info.level}: ${info.message}`
    )
);

// Base transports (siempre activos)
const transports: winston.transport[] = [
    // Console transport
    new winston.transports.Console({
        format: winston.format.combine(winston.format.colorize(), format),
    }),
];

// Development-specific transports
if (enviroments.NODE_ENV === "development") {
    transports.push(
        new winston.transports.File({
            filename: "logs/dev-all.log",
            level: "debug",
            format: format,
            maxsize: 10 * 1024 * 1024, // 10MB
            maxFiles: 3,
        }),
        new DailyRotateFile({
            filename: "logs/dev-rotate-%DATE%.log",
            datePattern: "YYYY-MM-DD",
            zippedArchive: true,
            maxSize: "10m",
            maxFiles: "3d", // Solo 3 días en desarrollo
            level: "debug",
            format: format,
        })
    );
} else {
    transports.push(
        new winston.transports.File({
            filename: "logs/prod-errors.log",
            level: "warn", // Solo warnings y errores
            format: format,
            maxsize: 20 * 1024 * 1024, // 20MB
            maxFiles: 5,
        }),
        new DailyRotateFile({
            filename: "logs/prod-rotate-%DATE%.log",
            datePattern: "YYYY-MM-DD",
            zippedArchive: true,
            maxSize: "20m",
            maxFiles: "7d", // 7 días en producción
            level: "info", // Info y superior
            format: format,
        })
    );
}

// Create the logger
const Logger = winston.createLogger({
    level: level(),
    levels,
    format,
    transports,
    // Evita que el proceso termine por errores de log
    exceptionHandlers: [
        new winston.transports.File({
            filename: "logs/exceptions.log",
            maxFiles: 1,
            maxsize: 5 * 1024 * 1024, // 5MB
        }),
    ],
    rejectionHandlers: [
        new winston.transports.File({
            filename: "logs/rejections.log",
            maxFiles: 1,
            maxsize: 5 * 1024 * 1024, // 5MB
        }),
    ],
});

// Función para monitorear el tamaño de logs
function monitorLogSize() {
    const fs = require("fs");
    const path = require("path");

    const logsDir = path.join(__dirname, "../logs");
    if (!fs.existsSync(logsDir)) return;

    const files = fs.readdirSync(logsDir);
    let totalSize = 0;

    files.forEach((file: string) => {
        totalSize += fs.statSync(path.join(logsDir, file)).size;
    });

    const sizeMB = (totalSize / (1024 * 1024)).toFixed(2);

    if (totalSize > 100 * 1024 * 1024) {
        // >100MB
        Logger.warn(`Logs directory size: ${sizeMB} MB (consider cleaning up)`);
    } else {
        Logger.debug(`Current logs size: ${sizeMB} MB`);
    }
}

// Ejecutar monitoreo cada 24 horas
if (enviroments.NODE_ENV === "production") {
    setInterval(monitorLogSize, 24 * 60 * 60 * 1000);
}

export default Logger;

otros.ts

(
            morgan(
                enviroments.NODE_ENV === "development" ? "dev" : "combined",
                {
                    stream: {
                        write: (message) => {
                            Logger.http(message.trim());
                        },
                    },
                }
            )
        );

export async function middlewareRoute(err: Error, req: Request, res: Response) {
    Logger.error("Error en la aplicación:", {
        error: err.message,
        stack: err.stack,
        path: req.path,
        method: req.method,
    });

 res.redirect("/404");
}