Java Academy · Lección

Por qué usar logging estructurado

Más allá de System.out.println

Por qué usar logging estructurado es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

El problema de println

System.out.println está bien para un experimento rápido, pero es una herramienta de registro deficiente para aplicaciones reales.

No incluye marcas de tiempo, niveles ni nombres de hilos.
No hay forma de desactivarlo en producción.
Solo escribe en stdout, sin posibilidad de redirigir la salida.

public class Main {
    public static void main(String[] args) {
        // Crude: no level, no timestamp, always on
        System.out.println("User logged in");
    }
}

Qué aportan los frameworks de logging

Un framework de logging proporciona:

Niveles (TRACE, DEBUG, INFO, WARN, ERROR) para filtrar el ruido.
Marcas de tiempo, nombres de hilos y nombres de loggers automáticamente.
Redirección a archivos, la consola o sistemas remotos.
Configuración en tiempo de ejecución sin recompilar.

public class Main {
    public static void main(String[] args) {
        // A framework would render: time, level, logger, thread, message
        String simulated = "2026-01-01 10:00:00 INFO  c.e.App [main] - User logged in";
        System.out.println(simulated);
    }
}

Niveles de logging explicados

Los niveles clasifican los mensajes según su importancia:

TRACE: detalles muy minuciosos.
DEBUG: información de diagnóstico para el desarrollo.
INFO: hitos normales.
WARN: algo inesperado, pero recuperable.
ERROR: un fallo que requiere atención.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    public static void main(String[] args) {
        Level threshold = Level.INFO;
        for (Level l : Level.values()) {
            boolean shown = l.ordinal() >= threshold.ordinal();
            System.out.println(l + " visible? " + shown);
        }
    }
}

Filtrar por umbral

Un logger tiene un umbral. Los mensajes por debajo del umbral se descartan con un coste mínimo.

En producción, podría establecer INFO para que DEBUG y TRACE desaparezcan, reduciendo el ruido y el coste sin modificar el código.

public class Main {
    enum Level { TRACE, DEBUG, INFO, WARN, ERROR }
    static void log(Level threshold, Level level, String msg) {
        if (level.ordinal() >= threshold.ordinal()) {
            System.out.println(level + " - " + msg);
        }
    }
    public static void main(String[] args) {
        Level t = Level.WARN;
        log(t, Level.DEBUG, "hidden detail");
        log(t, Level.ERROR, "shown error");
    }
}

Estructurado frente a no estructurado

Los logs no estructurados son frases normales. Los logs estructurados incorporan contexto de clave y valor (id de usuario, id de solicitud) que las máquinas pueden analizar.

Los logs estructurados se pueden buscar y agregar en herramientas como Elasticsearch o Loki.

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Structured context as key-value pairs
        Map<String, Object> fields = Map.of("event", "login", "userId", 42, "ok", true);
        System.out.println(fields);
    }
}

La idea de una fachada

No debería vincular su código a una biblioteca de logging específica. Una fachada como SLF4J le permite programar contra una única API y cambiar posteriormente el backend (Logback, Log4j2).

Esto desacopla la aplicación de las decisiones sobre la implementación del logging.

public class Main {
    public static void main(String[] args) {
        // Concept: your code calls a facade interface, not a concrete logger
        System.out.println("App -> SLF4J facade -> Logback backend");
    }
}

¿Por qué no usar simplemente una bandera booleana?

Algunos programas usan if (DEBUG) System.out.println(...). Esto dispersa condicionales por todo el código y no ofrece control por paquete.

Un framework de logging centraliza la configuración: habilite DEBUG para un paquete y ERROR para todo lo demás.

public class Main {
    static final boolean DEBUG = false;
    public static void main(String[] args) {
        // Inflexible: one global switch, scattered checks
        if (DEBUG) System.out.println("diagnostic");
        System.out.println("A framework controls this per logger instead");
    }
}

Consideraciones de rendimiento

El logging debería tener un coste bajo cuando está desactivado. Los frameworks omiten el trabajo correspondiente a los niveles filtrados, y los mensajes parametrizados evitan construir cadenas que se van a descartar.

println siempre evalúa su argumento, aunque nadie lea la salida.

public class Main {
    static String expensive() {
        System.out.println("(building expensive string)");
        return "big report";
    }
    public static void main(String[] args) {
        boolean debugEnabled = false;
        // Only build the message if it will actually be logged
        if (debugEnabled) System.out.println(expensive());
        System.out.println("skipped expensive work");
    }
}

Redirección centralizada de la salida

Los frameworks envían los logs a uno o varios appenders: la consola, archivos rotativos, syslog o un recopilador de red.

La redirección se configura una sola vez; el código de la aplicación permanece igual.

public class Main {
    public static void main(String[] args) {
        String[] appenders = {"CONSOLE", "ROLLING_FILE", "JSON_HTTP"};
        for (String a : appenders) System.out.println("route logs to: " + a);
    }
}

Correlación y contexto

Los sistemas reales añaden un id de solicitud a cada línea de log perteneciente a una solicitud, para que pueda seguir el recorrido de un usuario entre hilos y servicios.

SLF4J admite esto mediante MDC (Mapped Diagnostic Context).

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, String> mdc = new HashMap<>();
        mdc.put("requestId", "req-1234");
        System.out.println("All logs in this request tagged with " + mdc);
    }
}

El plan

A lo largo de este curso:

Usará la fachada SLF4J y obtendrá loggers.
Registrará mensajes con el nivel adecuado.
Usará mensajes parametrizados para mejorar la eficiencia.
Configurará Logback con appenders y patrones.

public class Main {
    public static void main(String[] args) {
        System.out.println("Next: SLF4J facade and loggers");
    }
}

Comprobación rápida

Compruebe su comprensión del registro estructurado.

Repaso

Ha aprendido por qué es importante el registro estructurado:

println carece de niveles, metadatos y enrutamiento.
Los frameworks añaden niveles, filtrado y appenders.
Una fachada desacopla el código del backend.
El contexto estructurado y MDC permiten la correlación.

A continuación, la fachada SLF4J y la creación de loggers.

public class Main {
    public static void main(String[] args) {
        System.out.println("Structured logging recap complete");
    }
}

Preguntas frecuentes

¿La lección «Por qué usar logging estructurado» es gratis?

Sí — el texto completo de «Por qué usar logging estructurado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Por qué usar logging estructurado»?

Más allá de System.out.println Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Por qué usar logging estructurado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy