Design a Logger

import java.time.Instant;

public enum LogLevel {
    DEBUG(0), INFO(1), WARN(2), ERROR(3);

    private final int priority;

    // Assigns numeric priority for level comparison
    LogLevel(int priority) {
        this.priority = priority;
    }

    // True if this level is at least as severe as other
    public boolean isAtLeast(LogLevel other) {
        return this.priority >= other.priority;
    }
}

public record LogRecord(
        LogLevel level,
        String message,
        Instant timestamp,
        Throwable cause) {

    // Factory for simple message without exception
    public static LogRecord of(LogLevel level, String message) {
        return new LogRecord(level, message, Instant.now(), null);
    }

    // Factory attaching stack trace source for errors
    public static LogRecord of(LogLevel level, String message, Throwable cause) {
        return new LogRecord(level, message, Instant.now(), cause);
    }
}

public interface Formatter {
    // Converts a log record to output string (no trailing newline required)
    String format(LogRecord record);
}

public class PlainTextFormatter implements Formatter {
    // Human-readable line: timestamp LEVEL message
    @Override
    public String format(LogRecord record) {
        String base = record.timestamp() + " [" + record.level() + "] " + record.message();
        if (record.cause() == null) return base;
        return base + " | " + record.cause().toString();
    }
}

public class JsonFormatter implements Formatter {
    // Structured single-line JSON for log aggregators
    @Override
    public String format(LogRecord record) {
        return "{\"ts\":\"" + record.timestamp() + "\",\"level\":\"" + record.level()
            + "\",\"msg\":\"" + escape(record.message()) + "\"}";
    }

    // Escapes quotes in message for valid JSON
    private String escape(String s) {
        return s.replace("\\", "\\\\").replace("\"", "\\\"");
    }
}

import java.io.*;
import java.nio.file.*;

public abstract class LogHandler {
    private LogHandler next;
    protected final LogLevel minLevel;
    protected final Formatter formatter;

    // Base handler with level filter and formatter
    protected LogHandler(LogLevel minLevel, Formatter formatter) {
        this.minLevel = minLevel;
        this.formatter = formatter;
    }

    // Links the next handler in the chain
    public LogHandler setNext(LogHandler next) {
        this.next = next;
        return next;
    }

    // Entry point: handle locally then forward to next
    public void handle(LogRecord record) {
        if (minLevel.isAtLeast(record.level()))
            write(formatter.format(record));
        if (next != null)
            next.handle(record);
    }

    // Subclass writes formatted line to its sink
    protected abstract void write(String formattedLine);

    // Flushes/closes resources; override in file appender
    public void close() {}
}

public class ConsoleAppender extends LogHandler {
    // Logs to standard output at or above minLevel
    public ConsoleAppender(LogLevel minLevel, Formatter formatter) {
        super(minLevel, formatter);
    }

    // Prints one formatted log line to console
    @Override
    protected void write(String formattedLine) {
        System.out.println(formattedLine);
    }
}

public class FileAppender extends LogHandler {
    private final BufferedWriter writer;

    // Opens file for append; creates parent dirs if needed
    public FileAppender(LogLevel minLevel, Formatter formatter, Path path) throws IOException {
        super(minLevel, formatter);
        Files.createDirectories(path.getParent());
        this.writer = Files.newBufferedWriter(path, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
    }

    // Writes formatted line to file with flush for durability
    @Override
    protected synchronized void write(String formattedLine) {
        try {
            writer.write(formattedLine);
            writer.newLine();
            writer.flush();
        } catch (IOException e) {
            System.err.println("FileAppender failed: " + e.getMessage());
        }
    }

    // Closes underlying file writer
    @Override
    public void close() {
        try { writer.close(); } catch (IOException ignored) {}
    }
}

public class Logger {
    private final String name;
    private final LogHandler chainHead;
    private LogLevel level = LogLevel.DEBUG;

    // Binds logger name to the first handler in the chain
    public Logger(String name, LogHandler chainHead) {
        this.name = name;
        this.chainHead = chainHead;
    }

    // Drops messages below configured logger level
    public void setLevel(LogLevel level) {
        this.level = level;
    }

    // Emits DEBUG record if enabled
    public void debug(String message) {
        log(LogLevel.DEBUG, message, null);
    }

    // Emits INFO record if enabled
    public void info(String message) {
        log(LogLevel.INFO, message, null);
    }

    // Emits WARN record if enabled
    public void warn(String message) {
        log(LogLevel.WARN, message, null);
    }

    // Emits ERROR record with optional throwable
    public void error(String message, Throwable cause) {
        log(LogLevel.ERROR, message, cause);
    }

    // Builds LogRecord and dispatches into handler chain
    private void log(LogLevel msgLevel, String message, Throwable cause) {
        if (!msgLevel.isAtLeast(level)) return;
        LogRecord record = cause == null
            ? LogRecord.of(msgLevel, "[" + name + "] " + message)
            : LogRecord.of(msgLevel, "[" + name + "] " + message, cause);
        chainHead.handle(record);
    }
}

public class LoggerDemo {
    // Chains console (INFO+) and file (ERROR+) appenders
    public static void main(String[] args) throws Exception {
        Formatter fmt = new PlainTextFormatter();
        LogHandler console = new ConsoleAppender(LogLevel.INFO, fmt);
        LogHandler file = new FileAppender(LogLevel.ERROR, fmt, Path.of("logs/app.log"));
        console.setNext(file);

        Logger log = new Logger("OrderService", console);
        log.debug("won't print"); // below logger level default passes but console filters DEBUG if min INFO
        log.info("order created");
        log.error("payment failed", new RuntimeException("timeout"));
        file.close();
    }
}