Logging in Java Applications

Every serious Java application needs a way to record what it is doing — not for the developer sitting at a terminal, but for diagnosing problems in production, days or weeks after an incident, when no debugger is attached. System.out.println feels convenient during learning, but it is unsuitable for real applications: it cannot be turned off selectively, it always writes to standard output with no timestamps or severity information, it cannot be routed to a file or a log-aggregation system, and it has no concept of which part of the application produced the message.

A proper logging framework solves all of this: it lets you tag each message with a severity level, filter what gets recorded without changing code, attach context like timestamps and thread names, and send output to multiple destinations (console, rotating files, remote log collectors) at once.

Why it matters

When a production system misbehaves at three in the morning, the logs are the only account of what happened. System.out.println cannot be filtered by severity, switched off or routed to a file without changing code. A logging framework does all of this by configuration, and every professional Java application uses one.

Log Levels

Logging frameworks categorize messages by severity, and each logger has a configured threshold — only messages at or above that threshold are actually recorded, everything below is silently dropped.

• TRACE — extremely fine-grained detail, rarely enabled outside of deep debugging sessions.
• DEBUG — diagnostic information useful during development, such as variable values and control-flow decisions.
• INFO — high-level events confirming the application is working as expected (a service started, a job completed).
• WARN — something unexpected happened, but the application can continue running.
• ERROR — a serious problem occurred, typically an operation failed and needs attention.

java.util.logging (JUL)

Java ships with a built-in logging API, java.util.logging, available in every JDK with no extra dependency. You obtain a Logger via Logger.getLogger(ClassName.class.getName()) and call methods like .info(), .warning(), and .severe(). It works, but its configuration API is verbose, its default output format is unpopular with many teams, and its feature set (log rotation, structured output, integrations) lags behind third-party alternatives.

SLF4J and Logback: The Practical Standard

In real-world Java projects, the de facto standard is to code against SLF4J (Simple Logging Facade for Java) — a thin, framework-agnostic logging API — and plug in Logback as the actual implementation that writes the logs. This separation matters: your code and any libraries you use only depend on the SLF4J interface, so you can swap the underlying logging implementation (Logback, Log4j2, or others) without touching application code. SLF4J also supports parameterized messages (logger.info("User {} logged in", userId)), which avoid the cost of string concatenation when a log level is disabled.

Example

import java.util.logging.Logger;

public class BuiltInLoggingDemo {
    private static final Logger logger = Logger.getLogger(BuiltInLoggingDemo.class.getName());

    public static void main(String[] args) {
        logger.info("Application starting");
        logger.warning("Cache miss for key: user_42");
    }
}

// --- With SLF4J + Logback (typical dependency: org.slf4j:slf4j-api, ch.qos.logback:logback-classic) ---

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);

    void processOrder(String orderId) {
        logger.info("Processing order {}", orderId);
        try {
            // ... order logic ...
        } catch (Exception e) {
            logger.error("Failed to process order {}", orderId, e);
        }
    }
}

Sep 21, 2026 10:02:11 AM BuiltInLoggingDemo main
INFO: Application starting
Sep 21, 2026 10:02:11 AM BuiltInLoggingDemo main
WARNING: Cache miss for key: user_42

10:02:11.412 [main] INFO  OrderService - Processing order ORD-1001

Exercise

Using java.util.logging, create a logger whose level is INFO and whose handler writes to standard output in the form LEVEL: message. Log one message at each of the levels FINE, INFO and WARNING. The FINE message must not appear.

Expected output: INFO: started then WARNING: disk almost full

import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.StreamHandler;

public class LogLevels {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("app");
        logger.setUseParentHandlers(false); // do not also print through the default handler

        StreamHandler handler = new StreamHandler(System.out, new Formatter() {
            @Override
            public String format(LogRecord record) {
                // TODO: return "LEVEL: message" followed by a line separator
                return "";
            }
        });
        logger.addHandler(handler);

        // TODO: set the logger's level to INFO

        logger.fine("details for developers");
        logger.info("started");
        logger.warning("disk almost full");

        handler.flush();
    }
}

import java.util.logging.Formatter;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.StreamHandler;

public class LogLevels {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger("app");
        logger.setUseParentHandlers(false); // do not also print through the default handler

        StreamHandler handler = new StreamHandler(System.out, new Formatter() {
            @Override
            public String format(LogRecord record) {
                return record.getLevel() + ": " + record.getMessage() + System.lineSeparator();
            }
        });
        logger.addHandler(handler);

        logger.setLevel(Level.INFO);

        logger.fine("details for developers");
        logger.info("started");
        logger.warning("disk almost full");

        handler.flush();
    }
}

Quick quiz

Interview questions