Logging framework

enum Level { DEBUG = 10, INFO = 20, WARN = 30, ERROR = 40 }

interface LogRecord { level: Level; logger: string; message: string; }

interface Formatter { format(r: LogRecord): string; }

class TextFormatter implements Formatter {
  format(r: LogRecord): string { return `[${Level[r.level]}] ${r.logger}: ${r.message}`; }
}

class JsonFormatter implements Formatter {
  format(r: LogRecord): string {
    return JSON.stringify({ level: Level[r.level], logger: r.logger, message: r.message });
  }
}

/** A destination. Each has its own threshold and formatter, so one record can go to many places differently. */
abstract class Appender {
  constructor(protected formatter: Formatter, protected threshold: Level = Level.DEBUG) {}
  append(r: LogRecord): void {
    if (r.level >= this.threshold) this.write(this.formatter.format(r));
  }
  protected abstract write(line: string): void;
}

class ConsoleAppender extends Appender {
  protected write(line: string): void { console.log(line); }
}

/** Stands in for a file or a network sink; also handy in tests. */
class MemoryAppender extends Appender {
  readonly lines: string[] = [];
  protected write(line: string): void { this.lines.push(line); }
}

class Logger {
  constructor(private name: string, private level: Level, private appenders: Appender[]) {}
  log(level: Level, message: string): void {
    if (level < this.level) return; // cheap check first: most debug calls stop here
    const record: LogRecord = { level, logger: this.name, message };
    for (const a of this.appenders) a.append(record);
  }
  debug(m: string): void { this.log(Level.DEBUG, m); }
  info(m: string): void { this.log(Level.INFO, m); }
  warn(m: string): void { this.log(Level.WARN, m); }
  error(m: string): void { this.log(Level.ERROR, m); }
}

const alerts = new MemoryAppender(new JsonFormatter(), Level.ERROR);
const log = new Logger("payments", Level.INFO, [new ConsoleAppender(new TextFormatter()), alerts]);
log.debug("cache warm-up details");
log.info("charge started");
log.warn("retrying card network");
log.error('card declined: "insufficient funds"');
console.log("alerts sink:");
for (const line of alerts.lines) console.log(line);

import java.util.ArrayList;
import java.util.List;

enum Level { DEBUG, INFO, WARN, ERROR }

record LogRecord(Level level, String logger, String message) {}

interface Formatter {
    String format(LogRecord r);
}

class TextFormatter implements Formatter {
    public String format(LogRecord r) {
        return "[" + r.level() + "] " + r.logger() + ": " + r.message();
    }
}

class JsonFormatter implements Formatter {
    public String format(LogRecord r) {
        String msg = r.message().replace("\\", "\\\\").replace("\"", "\\\"");
        return "{\"level\":\"" + r.level() + "\",\"logger\":\"" + r.logger() + "\",\"message\":\"" + msg + "\"}";
    }
}

/** A destination. Each has its own threshold and formatter, so one record can go to many places differently. */
abstract class Appender {
    private final Formatter formatter;
    private final Level threshold;

    Appender(Formatter formatter, Level threshold) {
        this.formatter = formatter;
        this.threshold = threshold;
    }

    void append(LogRecord r) {
        if (r.level().compareTo(threshold) >= 0) write(formatter.format(r));
    }

    protected abstract void write(String line);
}

class ConsoleAppender extends Appender {
    ConsoleAppender(Formatter f) {
        super(f, Level.DEBUG);
    }

    protected void write(String line) {
        System.out.println(line);
    }
}

/** Stands in for a file or a network sink; also handy in tests. */
class MemoryAppender extends Appender {
    final List<String> lines = new ArrayList<>();

    MemoryAppender(Formatter f, Level threshold) {
        super(f, threshold);
    }

    protected synchronized void write(String line) {
        lines.add(line);
    }
}

class Logger {
    private final String name;
    private final Level level;
    private final List<Appender> appenders;

    Logger(String name, Level level, List<Appender> appenders) {
        this.name = name;
        this.level = level;
        this.appenders = appenders;
    }

    void log(Level l, String message) {
        if (l.compareTo(level) < 0) return; // cheap check first: most debug calls stop here
        LogRecord r = new LogRecord(l, name, message);
        for (Appender a : appenders) a.append(r);
    }

    void debug(String m) { log(Level.DEBUG, m); }
    void info(String m) { log(Level.INFO, m); }
    void warn(String m) { log(Level.WARN, m); }
    void error(String m) { log(Level.ERROR, m); }
}

public class Main {
    public static void main(String[] args) {
        MemoryAppender alerts = new MemoryAppender(new JsonFormatter(), Level.ERROR);
        Logger log = new Logger("payments", Level.INFO, List.of(new ConsoleAppender(new TextFormatter()), alerts));
        log.debug("cache warm-up details");
        log.info("charge started");
        log.warn("retrying card network");
        log.error("card declined: \"insufficient funds\"");
        System.out.println("alerts sink:");
        alerts.lines.forEach(System.out::println);
    }
}