Implementación y Configuración del Módulo logging en Python

El módulo logging de Python es una herramienta estándar diseñada para registrar eventos de una aplicación de manera flexible y segura para hilos (thread-safe). Permite categorizar mensajes por niveles de severidad y dirigirlos a múltiples destinos simultáneamente.

Configuración básica para archivos individuales

Para casos sencillos, el método basicConfig permite establecer una salida rápida hacia un archivo físico. Es ideal para scripts pequeños o prototipos.

import logging

# Configuración inicial del sistema de registros
logging.basicConfig(
    filename='registro_actividad.log',
    level=logging.DEBUG,
    format='%(asctime)s | %(levelname)s | %(module)s | %(message)s',
    datefmt='%d/%m/%Y %I:%M:%S %p'
)

logging.debug("Mensaje de depuración detallado")
logging.info("Evento informativo del sistema")
logging.warning("Advertencia detectada")
logging.error("Se ha producido un error")
logging.critical("Fallo crítico en la aplicación")

Encapsulamiento mediante una Clase de Registro

En aplicaciones más robustas, es preferible encapsular la lógica de registro. El siguiente ejemplo utiliza un RotatingFileHandler para gestionar el tamaño del archivo y evitar que el almacenamiento se agote.

import logging
from logging.handlers import RotatingFileHandler

class GestorLogs:
    def __init__(self, nombre_archivo, nivel=logging.INFO):
        self.logger = logging.getLogger(nombre_archivo)
        self.logger.setLevel(nivel)
        
        # Definición de rotación: 50MB por archivo, máximo 5 archivos de respaldo
        manejador = RotatingFileHandler(
            nombre_archivo, 
            maxBytes=50*1024*1024, 
            backupCount=5
        )
        
        # Estructura del mensaje
        esquema = logging.Formatter(
            '%(asctime)s - [%(levelname)s] - %(name)s - %(message)s'
        )
        manejador.setFormatter(esquema)
        
        if not self.logger.handlers:
            self.logger.addHandler(manejador)

    def registrar(self, texto):
        self.logger.info(texto)

# Ejemplo de uso
if __name__ == "__main__":
    servicio_log = GestorLogs("app_principal.log")
    try:
        servicio_log.registrar("Iniciando procesos de backend...")
    except Exception as e:
        servicio_log.logger.error(f"Error inesperado: {e}")

Niveles de registro

El sistema de prioridades permite filtrar qué mensajes se guardan según la importancia del evento. Un mensaje solo se procesará si su nivel es igual o superior al configurado en el logger.

CRITICAL (50): Errores graves que impiden la ejecución.
ERROR (40): Fallos que afectan una funcionalidad específica.
WARNING (30): Indicaciones de algo inesperado o problemas potenciales.
INFO (20): Confirmación de que las cosas funcionan como se espera.
DEBUG (10): Información detallada para diagnóstico técnico.

Gestión de múltiples destinos

Es común necesitar que los logs se guarden en archivos distintos depandiendo de su origen o propósito. Esto se logra creando instancias independientes de Logger.

# Configuración para logs de base de datos
manejador_db = logging.FileHandler('db_ops.log')
formato_db = logging.Formatter('%(name)s - %(message)s')
manejador_db.setFormatter(formato_db)

logger_db = logging.getLogger('BaseDatos')
logger_db.addHandler(manejador_db)
logger_db.setLevel(logging.WARNING)

# Configuración para logs de acceso web
manejador_web = logging.FileHandler('acceso_web.log')
logger_web = logging.getLogger('ServidorWeb')
logger_web.addHandler(manejador_web)
logger_web.setLevel(logging.INFO)

# Registro de eventos por separado
logger_db.error("Fallo de conexión en el pool")
logger_web.info("Usuario 'admin' ha iniciado sesión")

Rotación basada en tiempo

Cuando el volumen de datos es alto, es útil rotar los archivos cada cierto periodo (diariamente, por ejemplo) en lugar de por tamaño.

import logging
from logging.handlers import TimedRotatingFileHandler

def crear_logger_temporal(nombre_log):
    logger = logging.getLogger("MonitorTiempo")
    logger.setLevel(logging.DEBUG)
    
    # Rota cada medianoche y mantiene 30 días de historial
    manejador = TimedRotatingFileHandler(
        nombre_log, 
        when="midnight", 
        interval=1, 
        backupCount=30
    )
    
    formato = logging.Formatter('%(process)d - %(levelname)s - %(message)s')
    manejador.setFormatter(formato)
    logger.addHandler(manejador)
    return logger

monitor = crear_logger_temporal("analisis_diario.log")
monitor.debug("Verificación de latencia completada")

Alertas mediante Correo Electrónico

Para incidentes críticos, el manejador SMTPHandler permite enviar notificaciones automáticas por email cuando ocurre un error de nivel ERROR o superior.

from logging.handlers import SMTPHandler

logger_alerta = logging.getLogger("AlertaEmail")

config_email = SMTPHandler(
    mailhost=("smtp.servidor.com", 587),
    fromaddr="sistema@empresa.com",
    toaddrs=["admin@empresa.com"],
    subject="CRITICAL ERROR: Fallo en Producción",
    credentials=("usuario", "password"),
    secure=()
)

logger_alerta.addHandler(config_email)
logger_alerta.error("El servicio de pagos no responde. Revisar de inmediato.")

Etiquetas: Python logging error-handling file-rotation smtp-handler

Publicado el 8-6 01:57

Friki Work