Logging framework

import java.time.Instant;
import java.util.*;
import java.util.concurrent.*;

/** Axis 1: WHAT gets through. Order IS the meaning — that is what makes a threshold possible. */
enum Level { TRACE, DEBUG, INFO, WARN, ERROR, FATAL }

/** The value object. Immutable, built ONCE per log call, shared by every appender. */
final class LogEvent {
    final Instant timestamp;
    final Level level;
    final String loggerName;
    final String message;
    final String threadName;
    final Throwable throwable;
    final Map<String, String> context;

    LogEvent(Level level, String loggerName, String message, Throwable throwable, Map<String, String> context) {
        this.timestamp = Instant.now();
        this.level = level;
        this.loggerName = loggerName;
        this.message = message;
        this.threadName = Thread.currentThread().getName();
        this.throwable = throwable;
        this.context = Map.copyOf(context);
    }
}

/** Axis 3: HOW it looks. One method, two implementations, zero knowledge of where it lands. */
interface Formatter { String format(LogEvent e); }

class PlainTextFormatter implements Formatter {
    public String format(LogEvent e) {
        StringBuilder sb = new StringBuilder()
            .append(e.timestamp).append(' ')
            .append(String.format("%-5s", e.level)).append(" [").append(e.threadName).append("] ")
            .append(e.loggerName).append(" - ").append(e.message);
        e.context.forEach((k, v) -> sb.append(' ').append(k).append('=').append(v));
        if (e.throwable != null) sb.append(" | ").append(e.throwable);
        return sb.toString();
    }
}

class JsonFormatter implements Formatter {
    public String format(LogEvent e) {
        StringBuilder sb = new StringBuilder("{");
        sb.append(q("ts")).append(':').append(q(e.timestamp.toString())).append(',');
        sb.append(q("level")).append(':').append(q(e.level.name())).append(',');
        sb.append(q("logger")).append(':').append(q(e.loggerName)).append(',');
        sb.append(q("thread")).append(':').append(q(e.threadName)).append(',');
        sb.append(q("msg")).append(':').append(q(e.message));
        e.context.forEach((k, v) -> sb.append(',').append(q(k)).append(':').append(q(v)));
        return sb.append('}').toString();
    }
    private static String q(String s) { return '"' + s.replace("\"", "\\\"") + '"'; }
}

/** Axis 2: WHERE it goes. Its own threshold, its own formatter, its OWN lock. */
interface Appender extends AutoCloseable {
    void append(LogEvent e);
    default void close() {}
}

abstract class AbstractAppender implements Appender {
    final String appenderName;
    private final Level threshold;
    private final Formatter formatter;
    private final Object writeLock = new Object();      // per appender — NOT global

    AbstractAppender(String appenderName, Level threshold, Formatter formatter) {
        this.appenderName = appenderName; this.threshold = threshold; this.formatter = formatter;
    }

    public final void append(LogEvent e) {
        if (e.level.ordinal() < threshold.ordinal()) return;   // second filter, composes with the logger's
        String line = formatter.format(e);                     // format OUTSIDE the lock
        synchronized (writeLock) { write(line); }              // only the write is serialised
    }

    protected abstract void write(String line);
}

class ConsoleAppender extends AbstractAppender {
    ConsoleAppender(Level threshold, Formatter formatter) { super("console", threshold, formatter); }
    protected void write(String line) { System.out.println("[console] " + line); }
}

/** Rotation lives HERE and nowhere else — nothing outside knows the file rolls. */
class FileAppender extends AbstractAppender {
    private final long maxBytes;
    private long written = 0;
    private int rollCount = 0;

    FileAppender(Level threshold, Formatter formatter, long maxBytes) {
        super("file", threshold, formatter);
        this.maxBytes = maxBytes;
    }

    protected void write(String line) {
        if (written + line.length() > maxBytes) {
            rollCount++;
            written = 0;
            System.out.println("[file] -- rolled to app.log." + rollCount + " --");
        }
        written += line.length();
        System.out.println("[file] " + line);
    }
}

class NetworkAppender extends AbstractAppender {
    NetworkAppender(Level threshold, Formatter formatter) { super("network", threshold, formatter); }
    protected void write(String line) {
        try { Thread.sleep(40); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
        System.out.println("[network] " + line);
    }
}

/** A decorator: the caller returns immediately, one writer thread drains the queue. */
class AsyncAppender implements Appender {
    private final Appender delegate;
    private final BlockingQueue<LogEvent> queue;
    private final Thread writer;
    private volatile boolean running = true;
    private int dropped = 0;

    AsyncAppender(Appender delegate, int capacity) {
        this.delegate = delegate;
        this.queue = new ArrayBlockingQueue<>(capacity);
        this.writer = new Thread(this::drain, "log-writer");
        this.writer.setDaemon(true);
        this.writer.start();
    }

    public void append(LogEvent e) {
        // FULL QUEUE POLICY: drop and count. A log line is worth less than the request it describes.
        if (!queue.offer(e)) dropped++;
    }

    private void drain() {
        while (running || !queue.isEmpty()) {
            try {
                LogEvent e = queue.poll(20, TimeUnit.MILLISECONDS);
                if (e != null) delegate.append(e);
            } catch (InterruptedException ie) { Thread.currentThread().interrupt(); return; }
        }
    }

    /** Without this, the last events — the interesting ones — never reach the sink. */
    public void close() {
        running = false;
        try { writer.join(2000); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); }
        delegate.close();
        System.out.println("[async] flushed; dropped=" + dropped);
    }
}

/** The logger: a threshold, a parent, and a list of appenders. It knows nothing about formats. */
class Logger {
    private final String loggerName;
    private final Logger parent;                    // null for root
    private volatile Level configured;              // null = inherit
    private final List<Appender> appenders = new CopyOnWriteArrayList<>();

    Logger(String loggerName, Logger parent) { this.loggerName = loggerName; this.parent = parent; }

    void setLevel(Level level) { this.configured = level; }
    void addAppender(Appender a) { appenders.add(a); }

    /** Chain of Responsibility: walk up until somebody is configured. */
    Level effectiveLevel() {
        for (Logger node = this; node != null; node = node.parent)
            if (node.configured != null) return node.configured;
        return Level.INFO;
    }

    boolean isEnabled(Level level) { return level.ordinal() >= effectiveLevel().ordinal(); }

    void log(Level level, String message, Throwable t, Map<String, String> context) {
        if (level.ordinal() < effectiveLevel().ordinal()) return;      // FIRST statement. nothing built yet.
        LogEvent e = new LogEvent(level, loggerName, message, t, context);   // built ONCE
        for (Logger node = this; node != null; node = node.parent)
            for (Appender a : node.appenders) a.append(e);             // the SAME object to everyone
    }

    /** Parameterised message: the substitution happens only after the gate. */
    void log(Level level, String pattern, Object... args) {
        if (level.ordinal() < effectiveLevel().ordinal()) return;
        String message = pattern;
        for (Object arg : args) message = message.replaceFirst("\\{\\}", String.valueOf(arg));
        log(level, message, null, Map.of());
    }

    void trace(String p, Object... a) { log(Level.TRACE, p, a); }
    void debug(String p, Object... a) { log(Level.DEBUG, p, a); }
    void info(String p, Object... a)  { log(Level.INFO, p, a); }
    void warn(String p, Object... a)  { log(Level.WARN, p, a); }
    void error(String p, Object... a) { log(Level.ERROR, p, a); }
}

/** A REGISTRY, not a singleton per logger: one manager, many loggers, cached by name. */
class LogManager {
    private static final Map<String, Logger> CACHE = new ConcurrentHashMap<>();
    private static final Logger ROOT = new Logger("root", null);
    static { ROOT.setLevel(Level.INFO); CACHE.put("root", ROOT); }

    static Logger root() { return ROOT; }

    static Logger getLogger(String loggerName) {
        return CACHE.computeIfAbsent(loggerName, n -> {
            int dot = n.lastIndexOf('.');
            Logger parent = dot < 0 ? ROOT : getLogger(n.substring(0, dot));
            return new Logger(n, parent);
        });
    }

    static void shutdown() { /* a real one walks every logger; here the demo closes explicitly */ }
}

public class Main {
    public static void main(String[] args) throws Exception {
        // ---- configuration: three sinks, three thresholds, two formats ----
        Logger root = LogManager.root();
        root.setLevel(Level.INFO);
        root.addAppender(new ConsoleAppender(Level.DEBUG, new PlainTextFormatter()));
        root.addAppender(new FileAppender(Level.WARN, new JsonFormatter(), 200));
        AsyncAppender net = new AsyncAppender(new NetworkAppender(Level.ERROR, new JsonFormatter()), 8);
        root.addAppender(net);

        // ---- turn on DEBUG for ONE package only ----
        LogManager.getLogger("com.app.db").setLevel(Level.DEBUG);

        Logger web  = LogManager.getLogger("com.app.web.Handler");
        Logger pool = LogManager.getLogger("com.app.db.PoolManager");

        System.out.println("web effective  = " + web.effectiveLevel());    // inherits root
        System.out.println("pool effective = " + pool.effectiveLevel());   // inherits com.app.db

        web.debug("this never appears — web inherits INFO");
        pool.debug("pool size={} idle={}", 8, 3);                          // DEBUG is on here
        web.info("user {} signed in", 42);
        pool.warn("disk {}% full", 91);
        web.error("connection refused");

        // ---- the lazy-message guard ----
        if (pool.isEnabled(Level.TRACE)) pool.trace("expensive: " + expensiveDump());

        Thread.sleep(300);
        net.close();
    }

    static String expensiveDump() { return "…a very costly string…"; }
}

/* expected output (ordering of the async lines may vary):
web effective  = INFO
pool effective = DEBUG
[console] …Z DEBUG [main] com.app.db.PoolManager - pool size=8 idle=3
[console] …Z INFO  [main] com.app.web.Handler - user 42 signed in
[console] …Z WARN  [main] com.app.db.PoolManager - disk 91% full
[file] {"ts":"…","level":"WARN","logger":"com.app.db.PoolManager","thread":"main","msg":"disk 91% full"}
[console] …Z ERROR [main] com.app.web.Handler - connection refused
[file] {"ts":"…","level":"ERROR","logger":"com.app.web.Handler","thread":"main","msg":"connection refused"}
[network] {"ts":"…","level":"ERROR","logger":"com.app.web.Handler","thread":"main","msg":"connection refused"}
[async] flushed; dropped=0
*/