Java Academy · Lesson

Why Structured Logging

Beyond System.out.println.

Why Structured Logging is a free Java Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Java Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

The Problem With println

System.out.println is fine for a quick experiment, but it is a poor logging tool for real applications.

No timestamps, levels, or thread names.
No way to turn it off in production.
Writes to stdout only, with no routing.

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

What Logging Frameworks Add

A logging framework gives you:

Levels (TRACE, DEBUG, INFO, WARN, ERROR) to filter noise.
Timestamps, thread, and logger names automatically.
Routing to files, console, or remote systems.
Runtime configuration without recompiling.

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);
    }
}

Log Levels Explained

Levels rank messages by importance:

TRACE: very fine detail.
DEBUG: development diagnostics.
INFO: normal milestones.
WARN: something unexpected but recoverable.
ERROR: a failure needing attention.

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);
        }
    }
}

Filtering by Threshold

A logger has a threshold. Messages below the threshold are dropped cheaply.

In production you might set INFO so DEBUG and TRACE vanish, cutting noise and cost without code changes.

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");
    }
}

Structured vs Unstructured

Unstructured logs are plain sentences. Structured logs attach key-value context (user id, request id) that machines can parse.

Structured logs are searchable and aggregatable in tools like Elasticsearch or 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);
    }
}

The Facade Idea

You should not bind your code to a specific logging library. A facade like SLF4J lets you code against one API and swap the backend (Logback, Log4j2) later.

This decouples your application from logging implementation choices.

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");
    }
}

Why Not Just Use a Boolean Flag?

Some code uses if (DEBUG) System.out.println(...). This litters the codebase and offers no per-package control.

A logging framework centralizes configuration: enable DEBUG for one package, ERROR for everything else.

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");
    }
}

Performance Concerns

Logging should be cheap when disabled. Frameworks skip work for filtered levels, and parameterized messages avoid building strings you will throw away.

println always evaluates its argument, even if no one reads the output.

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");
    }
}

Centralized Output Routing

Frameworks send logs to one or more appenders: console, rolling files, syslog, or a network collector.

You configure routing once; the application code stays the same.

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);
    }
}

Correlation and Context

Real systems add a request id to every log line in a request, so you can trace one user's journey across threads and services.

SLF4J supports this through the 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);
    }
}

The Plan

Over this course you will:

Use the SLF4J facade and get loggers.
Log at the right level.
Use parameterized messages for efficiency.
Configure Logback with appenders and patterns.

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

Quick Check

Test your understanding of structured logging.

Recap

You learned why structured logging matters:

println lacks levels, metadata, and routing.
Frameworks add levels, filtering, and appenders.
A facade decouples code from the backend.
Structured context and MDC enable correlation.

Next, the SLF4J facade and creating loggers.

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

Frequently asked questions

Is the “Why Structured Logging” lesson free?

Yes — the full text of “Why Structured Logging” is free to read here on the web, and the Java Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Java Academy course, upgrade to CoddyKit PRO.

What will I learn in “Why Structured Logging”?

Beyond System.out.println. You practise Java Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Java Academy?

No prior experience is required. Java Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Why Structured Logging” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Java Academy lesson?

Yes. Every Java Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Java Academy