Logging framework design - Low-Level Design Guide

Overview

Designing a logging framework (like a mini Log4j or SLF4J) is a popular LLD question. Core concepts: a Logger per name, log levels (DEBUG < INFO < WARN < ERROR) with filtering, log records with timestamp, level, message, and context, formatters that turn records into text or JSON, and appenders (sinks) that write to console, files, or remote systems.

The design showcases many patterns: Singleton or factory for logger lookup, Strategy for formatters, Observer or Composite for multiple appenders, Chain of Responsibility for level filtering and hierarchical loggers, and asynchronous appenders with a queue for performance. Thread safety and not blocking the caller are key concerns.

A newsroom

Reporters (loggers) file stories with an urgency level. Editors (filters) drop minor stories when busy. Layout (formatters) shapes each story, and distribution (appenders) sends it to print, web, and radio at the same time.

When to use it

Interview prompt: 'Design a logger / logging library'.
Understanding how SLF4J, Log4j, and Winston work.
Building structured logging for a platform.

Where it shows up in interviews

Framework design

Recognize it when: levels, multiple sinks, formats.

Design a logging framework
Design an audit trail library

Where it is used in real software

Log4j2 / Logback

Loggers, levels, appenders, layouts, and async appenders with LMAX Disruptor.

SLF4J

A facade decoupling application code from logging implementations.

Pino and Winston

Node.js loggers with transports and JSON output.

Key terms

Logger: Named entry point (com.shop.orders).
Level: Severity threshold for filtering.
Appender / sink: Destination for records.
Formatter / layout: Converts records to output text.
Async appender: Queues records and writes on a background thread.

How it works, step by step

1
Define LogRecord
time, level, logger name, message, fields, error.
2
Logger checks level
Cheap early return when disabled.
3
Dispatch to appenders
Each with its own formatter and minimum level.
4
Make appenders pluggable
Console, file, rolling file, HTTP.
5
Add async and thread safety
Bounded queue and a writer thread.

Routing records

Logger level INFO; console appender INFO+, file appender WARN+, JSON formatter

Call	Logger passes?	Console	File
debug('cache miss')	No	-	-
info('order placed')	Yes	Written	-
warn('slow payment')	Yes	Written	Written
error('db down', err)	Yes	Written	Written with stack trace

NOWCall: debug('cache miss') | Logger passes?: No | Console: - | File: -

Filtering at the logger and at each appender keeps output targeted and cheap.

Implementation

1import java.time.Instant;2import java.util.*;3import java.util.concurrent.*;4 5public enum Level { DEBUG, INFO, WARN, ERROR }6 7public record LogRecord(Instant time, Level level, String logger, String message, Map<String, Object> fields, Throwable error) {}8 9public interface Formatter { String format(LogRecord r); }10 11public interface Appender { void append(LogRecord r); }12 13public final class JsonFormatter implements Formatter {14    public String format(LogRecord r) {15        StringBuilder sb = new StringBuilder("{\"ts\":\"").append(r.time()).append("\",\"level\":\"").append(r.level())16            .append("\",\"logger\":\"").append(r.logger()).append("\",\"msg\":\"").append(r.message()).append('"');17        r.fields().forEach((k, v) -> sb.append(",\"").append(k).append("\":\"").append(v).append('"'));18        return sb.append('}').toString();19    }20}21 22public final class ConsoleAppender implements Appender {23    private final Level min;24    private final Formatter formatter;25    public ConsoleAppender(Level min, Formatter formatter) { this.min = min; this.formatter = formatter; }26    public void append(LogRecord r) { if (r.level().compareTo(min) >= 0) System.out.println(formatter.format(r)); }27}28 29public final class AsyncAppender implements Appender, AutoCloseable {30    private final BlockingQueue<LogRecord> queue = new ArrayBlockingQueue<>(10_000);31    private final Thread writer;32    public AsyncAppender(Appender delegate) {33        writer = new Thread(() -> {34            try { while (true) delegate.append(queue.take()); } catch (InterruptedException ignored) {}35        }, "log-writer");36        writer.setDaemon(true);37        writer.start();38    }39    public void append(LogRecord r) { queue.offer(r); }  // drop when full rather than block callers40    public void close() { writer.interrupt(); }41}42 43public final class Logger {44    private final String name;45    private volatile Level level;46    private final List<Appender> appenders;47 48    Logger(String name, Level level, List<Appender> appenders) { this.name = name; this.level = level; this.appenders = appenders; }49 50    public void info(String msg, Map<String, Object> fields) { log(Level.INFO, msg, fields, null); }51    public void error(String msg, Throwable e) { log(Level.ERROR, msg, Map.of(), e); }52 53    private void log(Level l, String msg, Map<String, Object> fields, Throwable e) {54        if (l.compareTo(level) < 0) return;                  // cheap filter55        LogRecord r = new LogRecord(Instant.now(), l, name, msg, fields, e);56        for (Appender a : appenders) a.append(r);57    }58}59 60public final class LoggerFactory {61    private static final ConcurrentHashMap<String, Logger> LOGGERS = new ConcurrentHashMap<>();62    private static final List<Appender> APPENDERS = List.of(new AsyncAppender(new ConsoleAppender(Level.INFO, new JsonFormatter())));63    public static Logger get(String name) { return LOGGERS.computeIfAbsent(name, n -> new Logger(n, Level.INFO, APPENDERS)); }64}

Complexity and performance

Disabled level checkO(1)

Must be near-free.

Enabled logO(appenders + format)

Async moves I/O off the caller.

Trade-offs

Sync vs async appenders

Sync guarantees delivery order and durability; async protects latency but can drop records under pressure.

Drop vs block when full

Dropping protects the application; blocking guarantees logs but can stall requests.

Variants and related techniques

Hierarchical loggers

Child loggers inherit levels and appenders from parents (com.shop inherits from com).

Rolling file appender

Rotate by size or date and retain N files.

Common mistakes

Building strings before checking the level.
Fix: Check level first or use lazy/parameterized messages.
Appenders that throw into the caller.
Fix: Catch and report appender errors internally.
Non-thread-safe file writes.
Fix: Single writer thread or synchronized appender.

Interview questions

Which design patterns appear in a logging framework?

Factory/Singleton for logger lookup, Strategy for formatters, Observer-like fan-out to multiple appenders, Chain of Responsibility or hierarchy for level filtering, Decorator for async or buffered appenders, and Facade (SLF4J) over implementations.

How do you keep logging from slowing the application?

Cheap level checks, lazy message construction, asynchronous appenders with bounded queues, batching writes, and dropping low-priority logs when overloaded.

Practice problems

Problem	Difficulty	What it trains
Logger with levels and two appenders	Easy	Filtering.
Async rolling file appender	Hard	Concurrency and rotation.