Introducción

En entornos donde múltiples hilos o procesos operan simultáneamente, las operaciones de escritura no atómicas pueden provocar salidas desordenadas en la consola, como mensajes superpuestos o interleaved. La incorporación de un sistema de registro (logging) ofrece una solución estructurada, permitiendo escrituras atómicas tanto en consola como en archivos, y un seguimiento clasificado del comportamiento de la aplicación.

Funcionalidades principales del sistema de registro

Un sistema de registro estructurado y rastreable es un pilar esencial para la estabilidad, observabilidad y mantenimiento del software. Sus funciones clave incluyen:

1. Diagnóstico de fallos: Registrar el flujo de ejecución, variables críticas y trazas de excepciones para localizar rápidamente el origen y contexto de los errores.
2. Monitoreo de estado: Capturar eventos de inicio del servicio, llamadas a endpoints, latencias y consumo de recursos para alimentar sistemas de alerta y estadísticas de rendimiento.
3. Auditoría y trazabilidad: Documentar acciones de usuario, flujo de negocio y decisiones clave para cumplimiento normativo y análisis forense.
4. Optimización del rendimiento: Analizar métricas como tiempos de respuesta, concurrencia y frecuencia de llamadas para identificar cuellos de botella.
5. Seguridad: Registrar intentos de acceso, operaciones privilegiadas y anomalías para detectar intrusiones y actividades sospechosas.
6. Soporte al desarrollo: Proporcionar información de depuración estructurada y persistente durante las fases de desarrollo y pruebas.

Diseño e interfaces del módulo

Librerías estándar utilizadas

• <filesystem>: Proporciona herramientas para manipulación de rutas, verificación de existencia (std::filesystem::exists) y creación recursiva de directorios (std::filesystem::create_directories).
• <memory>: Incluye punteros inteligentes como std::unique_ptr para gestión automática de recursos, con std::make_unique para su creación segura.
• <sstream>: Ofrece std::stringstream para concatenación flexible de datos en cadenas.
• <fstream>: Provee std::ofstream para escritura en archivos.

Principios de diseño aplicados

La arquitectura del sistema se fundamenta en los siguientes patrones y mecanismos:

• Patrón Estrategia: Permite intercambiar dinámicamente la salida entre consola y archivos, facilitando la extensión a nuevos destinos (red, bases de datos).
• RAII (Resource Acquisition Is Initialization): Garantiza la liberación automática de recursos mediante destructores, por ejemplo, al finalizar el flujo de una entrada de registro.
• Concatenación mediante flujo (streaming): Sobrecarga del operador << para construir mensajes de registro de forma similar a std::cout.
• Seguridad en concurrencia: Uso de mutex para sincronizar el acceso a los recursos compartidos entre hilos.
• Gestión automatizada de recursos: Empleo de std::unique_ptr para objetos estratégicos y std::ofstream para descriptores de archivo, previniendo fugas de memoria o archivos.

Implementación completa del sistema

Estrategias de salida

// Clase base abstracta para estrategias de registro
class EstrategiaRegistro {
public:
    virtual ~EstrategiaRegistro() = default;
    virtual void emitir_registro(const std::string& mensaje) = 0;
};

// Estrategia para salida a consola
class EstrategiaConsola : public EstrategiaRegistro {
public:
    void emitir_registro(const std::string& mensaje) override {
        std::lock_guard<std::mutex> bloqueo(cerrojo_);
        std::cout << mensaje << "\n";
    }
private:
    std::mutex cerrojo_;
};

// Estrategia para salida a archivo
class EstrategiaArchivo : public EstrategiaRegistro {
public:
    EstrategiaArchivo(const std::string& ruta_dir = "./registro",
                      const std::string& nombre_archivo = "app.log")
        : ruta_directorio_(ruta_dir),
          nombre_archivo_(nombre_archivo) {
        if (!std::filesystem::exists(ruta_directorio_)) {
            std::filesystem::create_directories(ruta_directorio_);
        }
    }

    void emitir_registro(const std::string& mensaje) override {
        std::lock_guard<std::mutex> bloqueo(cerrojo_);
        std::string ruta_completa = ruta_directorio_ + "/" + nombre_archivo_;
        std::ofstream archivo_salida(ruta_completa, std::ios::app);
        if (archivo_salida.is_open()) {
            archivo_salida << mensaje << "\n";
        }
    }

private:
    std::string ruta_directorio_;
    std::string nombre_archivo_;
    std::mutex cerrojo_;
};

Gestor principle y RAII

class GestorRegistros;

// Objeto temporal que construye el mensaje y lo emite al destruirse
class EntradaRegistro {
public:
    EntradaRegistro(NivelRegistro nivel, const std::string& archivo,
                    int linea, GestorRegistros& gestor)
        : nivel_(nivel), archivo_(archivo), linea_(linea), gestor_(gestor) {
        std::stringstream cabecera;
        cabecera << "[" << obtener_timestamp() << "] "
                 << "[" << nivel_a_cadena(nivel_) << "] "
                 << "[" << archivo_ << ":" << linea_ << "] - ";
        mensaje_ = cabecera.str();
    }

    template <typename T>
    EntradaRegistro& operator<<(const T& dato) {
        std::stringstream ss;
        ss << dato;
        mensaje_ += ss.str();
        return *this;
    }

    ~EntradaRegistro() {
        gestor_.flush_estrategia()->emitir_registro(mensaje_);
    }

private:
    NivelRegistro nivel_;
    std::string archivo_;
    int linea_;
    GestorRegistros& gestor_;
    std::string mensaje_;

    static std::string nivel_a_cadena(NivelRegistro nivel);
    static std::string obtener_timestamp();
};

class GestorRegistros {
public:
    GestorRegistros() : estrategia_actual_(std::make_unique<EstrategiaConsola>()) {}

    void usar_estrategia_consola() {
        estrategia_actual_ = std::make_unique<EstrategiaConsola>();
    }

    void usar_estrategia_archivo() {
        estrategia_actual_ = std::make_unique<EstrategiaArchivo>();
    }

    EntradaRegistro operator()(NivelRegistro nivel, const std::string& archivo, int linea) {
        return EntradaRegistro(nivel, archivo, linea, *this);
    }

    EstrategiaRegistro* flush_estrategia() const {
        return estrategia_actual_.get();
    }

private:
    std::unique_ptr<EstrategiaRegistro> estrategia_actual_;
};

// Instancia global y macros de conveniencia
GestorRegistros gestor_registro_global;

#define REGISTRAR(nivel) gestor_registro_global(nivel, __FILE__, __LINE__)
#define REGISTRO_A_CONSOLA gestor_registro_global.usar_estrategia_consola()
#define REGISTRO_A_ARCHIVO gestor_registro_global.usar_estrategia_archivo()

Enumeración de niveles y utilidades

enum class NivelRegistro {
    DEPURACION,
    INFORMACION,
    ADVERTENCIA,
    ERROR,
    FATAL
};

std::string EntradaRegistro::nivel_a_cadena(NivelRegistro nivel) {
    static const std::map<NivelRegistro, std::string> mapa_niveles = {
        {NivelRegistro::DEPURACION, "DEPURACION"},
        {NivelRegistro::INFORMACION, "INFO"},
        {NivelRegistro::ADVERTENCIA, "WARN"},
        {NivelRegistro::ERROR, "ERROR"},
        {NivelRegistro::FATAL, "FATAL"}
    };
    auto it = mapa_niveles.find(nivel);
    return it != mapa_niveles.end() ? it->second : "DESCONOCIDO";
}

std::string EntradaRegistro::obtener_timestamp() {
    auto ahora = std::chrono::system_clock::now();
    auto tiempo = std::chrono::system_clock::to_time_t(ahora);
    std::stringstream ss;
    ss << std::put_time(std::localtime(&tiempo), "%Y-%m-%d %H:%M:%S");
    return ss.str();
}

Compilación: El código requiere soporte para C++17. Ejemplo de comando: g++ -std=c++17 -pthread main.cpp -o aplicacion.

Implementación alternativa del mutex con RAII

// Wrapper para pthread_mutex_t con RAII
class CerrojoMutex {
public:
    CerrojoMutex() {
        pthread_mutex_init(&mutex_interno_, nullptr);
    }
    ~CerrojoMutex() {
        pthread_mutex_destroy(&mutex_interno_);
    }
    void bloquear() {
        pthread_mutex_lock(&mutex_interno_);
    }
    void desbloquear() {
        pthread_mutex_unlock(&mutex_interno_);
    }
private:
    pthread_mutex_t mutex_interno_;
};

class GuardaCerrojo {
public:
    explicit GuardaCerrojo(CerrojoMutex& cerrojo) : cerrojo_(cerrojo) {
        cerrojo_.bloquear();
    }
    ~GuardaCerrojo() {
        cerrojo_.desbloquear();
    }
private:
    CerrojoMutex& cerrojo_;
};