[Log Utils] Make Non-Static/Modify backend.

[LexManos]

Currently I am using a custom Logger that allows for using the Log4J backend.
Specifically its the use of the StringFormatterMessageFactory which allows for String.format style log commands:
info("[%3d/%3d] Running test", current, max)
[INFO] [ 1/100] Running Test
As well as exception as last argument support:
info("Failed to download %s", fileName, ex)

[INFO] Failed to download version.json
java.io.IOException: File Not Found
  at whatever

I also made it implement Closeable so I can do things like:

try (var l = log.push()) {
  log.info("This is indented");
}
log.info("This is not");

At the end of the day it just drills down to log(Level, String) and log(Level, String, Object[]) so it doesn't need to use L4J levels, but allowing things to be instance based would allow the consumer to choose. I specifically care because I like L4J's logging to a file. Tho that can be easily duplicated without L4J.

package net.minecraftforge.ir.util;

import java.io.Closeable;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.message.StringFormatterMessageFactory;

public class Log implements Closeable {
    private static Class<?> getCallerClass() {
        StackTraceElement ste = Thread.currentThread().getStackTrace()[3];
        try {
            return Class.forName(ste.getClassName());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    private final Logger logger;
    private int tabLevel = 0;

    public Log() {
        this(LogManager.getLogger(getCallerClass(), StringFormatterMessageFactory.INSTANCE));
    }

    public Log(Logger logger) {
        this.logger = logger;
    }

    @Override
    public void close() {
        tabLevel--;
    }

    public Log push() {
        tabLevel++;
        return this;
    }

    public Log pop() {
        tabLevel--;
        return this;
    }

    private String getIndent() {
        return "  ".repeat(tabLevel);
    }

    private void log(Level level, String message) {
        logger.log(level, getIndent() + message);
    }

    private void log(Level level, String message, Object[] args) {
        logger.log(level, getIndent() + message, args);
    }

    public void info(String message) {
        log(Level.INFO, message);
    }

    public void info(String message, Object... args) {
        log(Level.INFO, message, args);
    }

    public void warn(String message) {
        log(Level.WARN, message);
    }

    public void warn(String message, Object... args) {
        log(Level.WARN, message, args);
    }

    public void error(String message) {
        log(Level.ERROR, message);
    }

    public void error(String message, Object... args) {
        log(Level.ERROR, message, args);
    }

    public void debug(String message) {
        log(Level.DEBUG, message);
    }

    public void debug(String message, Object... args) {
        log(Level.DEBUG, message, args);
    }
}

[Jonathing]

It was actually my original plan to make this non-static. The thing is, I'm aware that doing so could hinder performance, so I was trying to be careful.

The way I can do this is make an interface that either consumers would implement or would try to use reflection on an input object to look for methods such as info(level, message, object).

[LexManos]

Oh no dont do reflection for anyting, especially if you're worried about performance.
I think having a simple

public interface Logger {
    default void log(Level level, String message) {
        log(level, message, new Object[0]);
    }

    void log(Level level, String message, Object[] args);
}

Having the non-arg version is important for implementations that do message formatting to use a fast path when formatting is not needed.

I dont think making things non-static hinders performance enough for it to matter. Java is all about objects as it is.