Design a Logging Framework

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

    private final int level;

    LogLevel(int level) {
        this.level = level;
    }

    public boolean isGreaterOrEqual(LogLevel other) {
        return this.level >= other.level;
    }
}

import java.time.LocalDateTime;

public class LogMessage {
    private final LogLevel logLevel;
    private final String message;
    private final LocalDateTime timestamp;
    private final String loggerName;

    private LogMessage(Builder builder) {
        this.logLevel   = builder.logLevel;
        this.message    = builder.message;
        this.loggerName = builder.loggerName;
        this.timestamp  = builder.timestamp;
    }

    public LogLevel getLogLevel()       { return logLevel; }
    public String getMessage()          { return message; }
    public LocalDateTime getTimestamp() { return timestamp; }
    public String getLoggerName()       { return loggerName; }

    public static class Builder {
        private LocalDateTime timestamp = LocalDateTime.now();
        private LogLevel logLevel;
        private String message;
        private String loggerName;

        public Builder logLevel(LogLevel level)      { this.logLevel   = level;      return this; }
        public Builder message(String message)        { this.message    = message;    return this; }
        public Builder timestamp(LocalDateTime ts)    { this.timestamp  = ts;         return this; }
        public Builder logger(String loggerName)      { this.loggerName = loggerName; return this; }

        public LogMessage build() {
            if (logLevel == null)
                throw new IllegalStateException("LogLevel is required");
            if (message == null || message.trim().isEmpty())
                throw new IllegalStateException("Message is required");
            return new LogMessage(this);
        }
    }
}

public interface LogFormatter {
    String format(LogMessage message);
}

import java.time.format.DateTimeFormatter;

public class TextFormatter implements LogFormatter {
    private static final DateTimeFormatter DTF =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");

    @Override
    public String format(LogMessage message) {
        return String.format("%s %s - %s: %s%n",
                message.getTimestamp().format(DTF),
                message.getLogLevel(),
                message.getLoggerName(),
                message.getMessage());
    }
}

public interface LogAppender {
    void append(LogMessage message);
    void close();
}

public class ConsoleAppender implements LogAppender {
    private LogFormatter logFormatter;

    public ConsoleAppender(LogFormatter formatter) {
        this.logFormatter = formatter;
    }

    @Override
    public void append(LogMessage logMessage) {
        System.out.print(logFormatter.format(logMessage));
    }

    @Override
    public void close() { /* stdout needs no cleanup */ }
}

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileAppender implements LogAppender {
    private LogFormatter logFormatter;
    private final FileWriter fileWriter;

    public FileAppender(LogFormatter formatter, String filePath) {
        this.logFormatter = formatter;
        try {
            File file = new File(filePath);
            if (file.getParentFile() != null) file.getParentFile().mkdirs();
            this.fileWriter = new FileWriter(file, true /* append */);
        } catch (IOException e) {
            throw new RuntimeException("Failed to open log file: " + filePath, e);
        }
    }

    @Override
    public synchronized void append(LogMessage logMessage) {
        try {
            fileWriter.write(logFormatter.format(logMessage));
            fileWriter.flush();
        } catch (IOException e) {
            System.err.println("FileAppender write failed: " + e.getMessage());
        }
    }

    @Override
    public void close() {
        try { fileWriter.close(); }
        catch (IOException e) { System.err.println("FileAppender close failed: " + e.getMessage()); }
    }
}

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class AsyncLogProcessor {
    private final ExecutorService executor;

    public AsyncLogProcessor() {
        this.executor = Executors.newSingleThreadExecutor(r -> {
            Thread t = new Thread(r, "AsyncLogProcessor");
            t.setDaemon(true);
            return t;
        });
    }

    public void process(LogMessage logMessage, List<LogAppender> appenders) {
        if (executor.isShutdown()) {
            System.err.println("Logger is shut down — cannot process logs");
            return;
        }
        executor.submit(() -> {
            for (LogAppender appender : appenders) {
                appender.append(logMessage);
            }
        });
    }

    public void stop() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(2, TimeUnit.SECONDS)) {
                System.err.println("Async processor did not finish in time");
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Logger {
    private final String name;
    private LogLevel logLevel;           // null = inherit from parent
    private final Logger parent;
    private final List<LogAppender> appenderList;

    Logger(String name, Logger parent) {
        this.name         = name;
        this.parent       = parent;
        this.appenderList = new CopyOnWriteArrayList<>();
    }

    public void setLogLevel(LogLevel level) { this.logLevel = level; }
    public List<LogAppender> getAppenderList() { return appenderList; }

    public void addAppender(LogAppender appender) {
        appenderList.add(appender);
    }

    /** Walk up to the first ancestor with a configured level; default DEBUG. */
    public LogLevel getEffectiveLevel() {
        for (Logger l = this; l != null; l = l.parent) {
            if (l.logLevel != null) return l.logLevel;
        }
        return LogLevel.DEBUG;
    }

    public void log(LogLevel level, String message) {
        if (!level.isGreaterOrEqual(getEffectiveLevel())) return;

        LogMessage logMessage = new LogMessage.Builder()
                .logLevel(level)
                .message(message)
                .logger(this.name)
                .build();

        callAppender(logMessage);
    }

    /** Propagate up the logger chain, dispatching to each ancestor's appenders. */
    private void callAppender(LogMessage message) {
        for (Logger current = this; current != null; current = current.parent) {
            if (!current.appenderList.isEmpty()) {
                LoggingManager.getInstance()
                              .getProcessor()
                              .process(message, current.appenderList);
            }
        }
    }

    public void debug(String message) { log(LogLevel.DEBUG, message); }
    public void info(String message)  { log(LogLevel.INFO,  message); }
    public void warn(String message)  { log(LogLevel.WARN,  message); }
    public void error(String message) { log(LogLevel.ERROR, message); }
}