[slf4j] Support delegating slf4j to commons.log, switch commons.log to default to fancy stdout logger

commons-slf4j/src/main/java/io/gitlab/jfronny/commons/log/CommonsLogger.java

@@ -0,0 +1,315 @@
+package io.gitlab.jfronny.commons.log;
+
+import org.slf4j.Logger;
+import org.slf4j.Marker;
+
+public record CommonsLogger(io.gitlab.jfronny.commons.log.Logger delegate) implements Logger {
+    public CommonsLogger(String name) {
+        this(io.gitlab.jfronny.commons.log.Logger.forName(name));
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+        return false;
+    }
+
+    @Override
+    public void trace(String msg) {
+        delegate.trace(msg);
+    }
+
+    @Override
+    public void trace(String format, Object arg) {
+        delegate.trace(format, arg);
+    }
+
+    @Override
+    public void trace(String format, Object arg1, Object arg2) {
+        delegate.trace(format, arg1, arg2);
+    }
+
+    @Override
+    public void trace(String format, Object... arguments) {
+        delegate.trace(format, arguments);
+    }
+
+    @Override
+    public void trace(String msg, Throwable t) {
+        delegate.trace(msg, t);
+    }
+
+    @Override
+    public boolean isTraceEnabled(Marker marker) {
+        return false;
+    }
+
+    @Override
+    public void trace(Marker marker, String msg) {
+        delegate.trace(msg);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg) {
+        delegate.trace(format, arg);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object arg1, Object arg2) {
+        delegate.trace(format, arg1, arg2);
+    }
+
+    @Override
+    public void trace(Marker marker, String format, Object... argArray) {
+        delegate.trace(format, argArray);
+    }
+
+    @Override
+    public void trace(Marker marker, String msg, Throwable t) {
+        delegate.trace(msg, t);
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+        return false;
+    }
+
+    @Override
+    public void debug(String msg) {
+        delegate.debug(msg);
+    }
+
+    @Override
+    public void debug(String format, Object arg) {
+        delegate.debug(format, arg);
+    }
+
+    @Override
+    public void debug(String format, Object arg1, Object arg2) {
+        delegate.debug(format, arg1, arg2);
+    }
+
+    @Override
+    public void debug(String format, Object... arguments) {
+        delegate.debug(format, arguments);
+    }
+
+    @Override
+    public void debug(String msg, Throwable t) {
+        delegate.debug(msg, t);
+    }
+
+    @Override
+    public boolean isDebugEnabled(Marker marker) {
+        return false;
+    }
+
+    @Override
+    public void debug(Marker marker, String msg) {
+        delegate.debug(msg);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg) {
+        delegate.debug(format, arg);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object arg1, Object arg2) {
+        delegate.debug(format, arg1, arg2);
+    }
+
+    @Override
+    public void debug(Marker marker, String format, Object... arguments) {
+        delegate.debug(format, arguments);
+    }
+
+    @Override
+    public void debug(Marker marker, String msg, Throwable t) {
+        delegate.debug(msg, t);
+    }
+
+    @Override
+    public boolean isInfoEnabled() {
+        return true;
+    }
+
+    @Override
+    public void info(String msg) {
+        delegate.info(msg);
+    }
+
+    @Override
+    public void info(String format, Object arg) {
+        delegate.info(format, arg);
+    }
+
+    @Override
+    public void info(String format, Object arg1, Object arg2) {
+        delegate.info(format, arg1, arg2);
+    }
+
+    @Override
+    public void info(String format, Object... arguments) {
+        delegate.info(format, arguments);
+    }
+
+    @Override
+    public void info(String msg, Throwable t) {
+        delegate.info(msg, t);
+    }
+
+    @Override
+    public boolean isInfoEnabled(Marker marker) {
+        return true;
+    }
+
+    @Override
+    public void info(Marker marker, String msg) {
+        delegate.info(msg);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg) {
+        delegate.info(format, arg);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object arg1, Object arg2) {
+        delegate.info(format, arg1, arg2);
+    }
+
+    @Override
+    public void info(Marker marker, String format, Object... arguments) {
+        delegate.info(format, arguments);
+    }
+
+    @Override
+    public void info(Marker marker, String msg, Throwable t) {
+        delegate.info(msg, t);
+    }
+
+    @Override
+    public boolean isWarnEnabled() {
+        return true;
+    }
+
+    @Override
+    public void warn(String msg) {
+        delegate.warn(msg);
+    }
+
+    @Override
+    public void warn(String format, Object arg) {
+        delegate.warn(format, arg);
+    }
+
+    @Override
+    public void warn(String format, Object... arguments) {
+        delegate.warn(format, arguments);
+    }
+
+    @Override
+    public void warn(String format, Object arg1, Object arg2) {
+        delegate.warn(format, arg1, arg2);
+    }
+
+    @Override
+    public void warn(String msg, Throwable t) {
+        delegate.warn(msg, t);
+    }
+
+    @Override
+    public boolean isWarnEnabled(Marker marker) {
+        return true;
+    }
+
+    @Override
+    public void warn(Marker marker, String msg) {
+        delegate.warn(msg);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg) {
+        delegate.warn(format, arg);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object arg1, Object arg2) {
+        delegate.warn(format, arg1, arg2);
+    }
+
+    @Override
+    public void warn(Marker marker, String format, Object... arguments) {
+        delegate.warn(format, arguments);
+    }
+
+    @Override
+    public void warn(Marker marker, String msg, Throwable t) {
+        delegate.warn(msg, t);
+    }
+
+    @Override
+    public boolean isErrorEnabled() {
+        return true;
+    }
+
+    @Override
+    public void error(String msg) {
+        delegate.error(msg);
+    }
+
+    @Override
+    public void error(String format, Object arg) {
+        delegate.error(format, arg);
+    }
+
+    @Override
+    public void error(String format, Object arg1, Object arg2) {
+        delegate.error(format, arg1, arg2);
+    }
+
+    @Override
+    public void error(String format, Object... arguments) {
+        delegate.error(format, arguments);
+    }
+
+    @Override
+    public void error(String msg, Throwable t) {
+        delegate.error(msg, t);
+    }
+
+    @Override
+    public boolean isErrorEnabled(Marker marker) {
+        return true;
+    }
+
+    @Override
+    public void error(Marker marker, String msg) {
+        delegate.error(msg);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg) {
+        delegate.error(format, arg);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object arg1, Object arg2) {
+        delegate.error(format, arg1, arg2);
+    }
+
+    @Override
+    public void error(Marker marker, String format, Object... arguments) {
+        delegate.error(format, arguments);
+    }
+
+    @Override
+    public void error(Marker marker, String msg, Throwable t) {
+        delegate.error(msg, t);
+    }
+}

commons-slf4j/src/main/java/io/gitlab/jfronny/commons/log/CommonsLoggerFactory.java

@@ -0,0 +1,16 @@
+package io.gitlab.jfronny.commons.log;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.Logger;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CommonsLoggerFactory implements ILoggerFactory {
+    private final Map<String, Logger> loggerMap = new HashMap<>();
+
+    @Override
+    public synchronized Logger getLogger(String name) {
+        return loggerMap.computeIfAbsent(name, CommonsLogger::new);
+    }
+}

commons-slf4j/src/main/java/io/gitlab/jfronny/commons/log/CommonsServiceProvider.java

@@ -0,0 +1,41 @@
+package io.gitlab.jfronny.commons.log;
+
+import org.slf4j.ILoggerFactory;
+import org.slf4j.IMarkerFactory;
+import org.slf4j.helpers.BasicMarkerFactory;
+import org.slf4j.helpers.NOPMDCAdapter;
+import org.slf4j.spi.MDCAdapter;
+import org.slf4j.spi.SLF4JServiceProvider;
+
+public class CommonsServiceProvider implements SLF4JServiceProvider {
+    private ILoggerFactory loggerFactory;
+    private IMarkerFactory markerFactory;
+    private MDCAdapter mdcAdapter;
+
+    @Override
+    public ILoggerFactory getLoggerFactory() {
+        return loggerFactory;
+    }
+
+    @Override
+    public IMarkerFactory getMarkerFactory() {
+        return markerFactory;
+    }
+
+    @Override
+    public MDCAdapter getMDCAdapter() {
+        return mdcAdapter;
+    }
+
+    @Override
+    public String getRequestedApiVersion() {
+        return "2.0.0";
+    }
+
+    @Override
+    public void initialize() {
+        loggerFactory = new CommonsLoggerFactory();
+        markerFactory = new BasicMarkerFactory();
+        mdcAdapter = new NOPMDCAdapter();
+    }
+}

commons-slf4j/src/test/java/io/gitlab/jfronny/commons/test/SLFLogStrategyTest.java

@@ -9,7 +9,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 public class SLFLogStrategyTest {
     @BeforeEach
     void prepare() {
-        HotSwappingDelegateLogger.resetStrategy();
+        HotSwappingDelegateLogger.updateStrategy(SLF4JLogger::new);
     }
 
     @Test

src/main/java/io/gitlab/jfronny/commons/log/HotSwappingDelegateLogger.java

@@ -16,13 +16,7 @@ public class HotSwappingDelegateLogger extends DelegateLogger {
     }
 
     public static void resetStrategy() {
-        try {
-            LOGGER_BUILDER = Reflect.<String, Logger>getConstructor("io.gitlab.jfronny.commons.log.SLF4JLogger", String.class)
-                    .orThrow();
-        } catch (ClassNotFoundException | NoSuchMethodException e) {
-            // SLF4J logger is unavailable, use java.util.logging
-            LOGGER_BUILDER = JavaUtilLogger::new;
-        }
+        LOGGER_BUILDER = StdoutLogger::fancy;
     }
 
     public static void updateStrategy(@NotNull Function<String, Logger> factory) {

src/main/java/io/gitlab/jfronny/commons/log/StdoutLogger.java

@@ -24,6 +24,10 @@ public class StdoutLogger implements Logger {
         this.timestamp = timestamp;
     }
 
+    public static StdoutLogger fancy(String name) {
+        return new StdoutLogger(name, true, true, true);
+    }
+
     @Override
     public String getName() {
         return name;

src/test/java/io/gitlab/jfronny/commons/test/LoggerTest.java

@@ -13,13 +13,13 @@ public class LoggerTest {
 
     @Test
     void testFactory() {
-        assertEquals(JavaUtilLogger.class, assertInstanceOf(HotSwappingDelegateLogger.class, Logger.forName("Joe")).getDelegate().getClass());
+        assertEquals(StdoutLogger.class, assertInstanceOf(HotSwappingDelegateLogger.class, Logger.forName("Joe")).getDelegate().getClass());
     }
 
     @Test
     void testRegisterFactory() {
         HotSwappingDelegateLogger logger = assertInstanceOf(HotSwappingDelegateLogger.class, Logger.forName("Joe"));
-        assertEquals(JavaUtilLogger.class, logger.getDelegate().getClass());
+        assertEquals(StdoutLogger.class, logger.getDelegate().getClass());
         Logger.registerFactory(s -> new NopLogger());
         assertEquals(NopLogger.class, logger.getDelegate().getClass());
     }