Saltearse al contenido

Logging

print escribe en la salida estándar y desaparece. Un registro es un evento con nivel, momento, origen y contexto, que se puede filtrar, agregar y consultar. La diferencia se nota el día que hay un incidente y no hay nada que leer.

Un log es una estructura de datos; print es una línea de texto que se pierde.

Un mensaje que no se emite (nivel WARNING, mensaje DEBUG)
Forma Coste
log.debug(f"valor {x}") 169 ns
log.debug("valor %s", x) 114 ns

python mediciones/07-01-05-produccion.py

La diferencia del 48 % viene de que la f-string se evalúa siempre, aunque el mensaje no se emita; el formato perezoso sólo se aplica si el registro pasa el filtro.

Con un entero la f-string es barata. Con f"{objeto!r}" sobre una estructura de mil filas, construir el mensaje puede costar milisegundos, y se paga en cada llamada descartada. En un bucle cerrado, eso es un programa lento sin síntoma aparente.

La regla: dentro de un log.debug, nunca f-strings.

import logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s %(levelname)s %(name)s %(message)s",
)
logger = logging.getLogger(__name__)

getLogger(__name__) da un logger por módulo, con nombre jerárquico: mi_paquete.servicios hereda la configuración de mi_paquete. Eso permite subir el nivel de un subsistema sin tocar el resto.

En una biblioteca, basicConfig no se llama: se añade un NullHandler y se deja la configuración a la aplicación. Una librería que configura el logging global secuestra el de quien la usa.

import json, logging
class JSONFormatter(logging.Formatter):
def format(self, record):
return json.dumps({
"ts": self.formatTime(record),
"nivel": record.levelname,
"mensaje": record.getMessage(),
"logger": record.name,
"peticion": getattr(record, "peticion", None),
"exc": self.formatException(record.exc_info) if record.exc_info else None,
}, ensure_ascii=False)
log = logging.getLogger("demo")
h = logging.StreamHandler(); h.setFormatter(JSONFormatter())
log.addHandler(h)
try:
1 / 0
except ZeroDivisionError:
log.exception("fallo", extra={"peticion": "abc"})

log.exception dentro del except rellena exc_info, y "exc" lleva la traza completa, con los saltos de línea escapados como \n dentro del JSON: sigue siendo una línea por evento. Salida real (3.13.7; la ruta del archivo se abrevia):

{"ts": "2026-11-17 14:36:30,162", "nivel": "ERROR", "mensaje": "fallo", "logger": "demo", "peticion": "abc", "exc": "Traceback (most recent call last):\n File \"demo.py\", line 18, in <module>\n 1 / 0\n ~~^~~\nZeroDivisionError: division by zero"}

Un log en texto se lee con grep; uno en JSON se consulta: «todas las peticiones con peticion=abc», «el percentil 99 de duración por endpoint». La diferencia entre depurar a mano y tener métricas.

El contexto —identificador de petición, usuario, traza— se pasa con extra o con un LoggerAdapter, no concatenando en el mensaje.

Nivel Cuándo
DEBUG Detalle de desarrollo, nunca en producción por defecto
INFO Eventos de negocio: pedido creado, tarea terminada
WARNING Algo raro que no impide seguir
ERROR Una operación falló y alguien debe mirar
CRITICAL El servicio no puede continuar

El error más común es usar INFO para todo y ERROR para nada. Una regla práctica: si un ERROR no despierta a nadie, no es un error; es un WARNING.

  • En bucles de millones de iteraciones. Ni en DEBUG: el filtro es barato, pero el formateo de argumentos no siempre.
  • Datos que ya son métricas. Contar peticiones se hace con un contador, no con una línea de log por petición.
  • En bibliotecas, salvo con NullHandler.

Un servicio registra log.info("procesado") por cada uno de los 50 000 elementos de un lote. El volumen de logs se dispara y el coste de almacenamiento también. Propón tres cambios y di cuál de ellos reduce más.

Solución
  1. Registrar por lote, no por elemento: un INFO al final con el recuento, el tiempo y los errores. Reduce el volumen de 50 000 líneas a una, y conserva la información que importa. Es el cambio que más reduce.
  2. Bajar a DEBUG el detalle por elemento, para que sólo aparezca cuando se investiga. Reduce el coste sin perder la posibilidad de depurar.
  3. Añadir muestreo en el detalle (1 de cada 100), si se necesita ver progreso.

El primero gana porque ataca la causa: el evento de negocio es «el lote se procesó», no «se procesó un elemento». Los otros dos mitigan el síntoma.

El detalle que suele faltar: si el lote falla a mitad, conviene un WARNING con el número de elemento donde falló. Ese sí es un evento único y accionable.

Las cuentas, para comprobarlas:

import logging
class Contador(logging.Handler):
def __init__(self):
super().__init__()
self.lineas = 0
def emit(self, record):
self.lineas += 1
def procesar(lote, por_elemento):
log = logging.getLogger("lote")
log.handlers = [c := Contador()]
log.setLevel(logging.INFO)
log.propagate = False
for _ in lote:
if por_elemento:
log.info("procesado")
if not por_elemento:
log.info("lote procesado: %d elementos", len(lote))
return c.lineas
lote = range(50_000)
print("por elemento:", procesar(lote, True), "lineas")
print("por lote: ", procesar(lote, False), "linea")
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 8.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 13.
  • Mediciones: mediciones/07-01-05-produccion.py.
  • 05 · Errores: qué se registra y con qué nivel.
  • 10 · Depuración: cuando el log no basta.
  • 02 · Configuración: el nivel como parámetro del entorno.