Added a Logging Library :>

Author: RealMangorage

src/main/java/module-info.java

@@ -3,15 +3,18 @@
     requires static com.google.gson;
     requires static java.sql;
 
-    exports org.mangorage.bootstrap.api.transformer;
-    exports org.mangorage.bootstrap.api.module;
+    exports org.mangorage.bootstrap.api.dependency;
     exports org.mangorage.bootstrap.api.launch;
+    exports org.mangorage.bootstrap.api.lifecycle;
     exports org.mangorage.bootstrap.api.loader;
-    exports org.mangorage.bootstrap.api.dependency;
+    exports org.mangorage.bootstrap.api.logging;
+    exports org.mangorage.bootstrap.api.module;
+    exports org.mangorage.bootstrap.api.transformer;
     exports org.mangorage.bootstrap.api.util;
 
     opens org.mangorage.bootstrap;
 
     uses org.mangorage.bootstrap.api.launch.ILaunchTarget;
     uses org.mangorage.bootstrap.api.lifecycle.IBootstrapLifecycle;
+    uses org.mangorage.bootstrap.api.logging.ILoggerProvider;
 }

src/main/java/org/mangorage/bootstrap/Bootstrap.java

@@ -1,6 +1,7 @@
 package org.mangorage.bootstrap;
 
 import org.mangorage.bootstrap.api.launch.ILaunchTarget;
+import org.mangorage.bootstrap.internal.logger.DefaultLoggerFactory;
 import org.mangorage.bootstrap.internal.util.Util;
 
 import java.lang.module.Configuration;
@@ -58,6 +59,9 @@ public static void main(String[] args) throws Throwable {
         Path launchPath = Path.of(DEFAULT_LAUNCH_PATH);
 
         final ModuleLayer moduleLayer = createLaunchModuleLayer(parent, launchPath);
+
+        DefaultLoggerFactory.load(moduleLayer); // Load the providers this layer has!
+
         final Map<String, ILaunchTarget> launchTargetMap = discoverLaunchTargets(moduleLayer);
 
         if (!launchTargetMap.containsKey(launchTarget)) {
@@ -67,6 +71,7 @@ public static void main(String[] args) throws Throwable {
         }
 
         LOGGER.info("Loading BootstrapLifecycle hooks");
+
         final var lifecycleHooks = ServiceLoader.load(moduleLayer, org.mangorage.bootstrap.api.lifecycle.IBootstrapLifecycle.class)
                 .stream()
                 .map(ServiceLoader.Provider::get)
@@ -75,7 +80,10 @@ public static void main(String[] args) throws Throwable {
         LOGGER.info("Launching target: " + launchTarget);
 
         try {
-            launchTargetMap.get(launchTarget).launch(moduleLayer, parent, args);
+            final var launchLayer = launchTargetMap.get(launchTarget).launch(moduleLayer, parent, args);
+            if (launchLayer != null) {
+                DefaultLoggerFactory.load(launchLayer); // Load the providers this layer has!
+            }
         } catch (Throwable t) {
             LOGGER.log(Level.SEVERE, "Error during launch target execution: " + launchTarget, t);
             lifecycleHooks.forEach(hook -> hook.onError(t, moduleLayer));

src/main/java/org/mangorage/bootstrap/api/launch/ILaunchTarget.java

@@ -3,5 +3,8 @@
 public interface ILaunchTarget {
     String getId();
 
-    void launch(ModuleLayer bootstrapLayer, ModuleLayer parent, String[] args) throws Throwable;
+    /**
+     * @return The ModuleLayer that was created!
+     */
+    ModuleLayer launch(ModuleLayer bootstrapLayer, ModuleLayer parent, String[] args) throws Throwable;
 }

src/main/java/org/mangorage/bootstrap/api/logging/AbstractLoggerProvider.java

@@ -0,0 +1,25 @@
+package org.mangorage.bootstrap.api.logging;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public abstract class AbstractLoggerProvider implements ILoggerProvider {
+    private final String name;
+    private final Map<String, IMangoLogger> loggerCache = new ConcurrentHashMap<>();
+
+    public AbstractLoggerProvider(String name) {
+        this.name = name;
+    }
+
+    protected abstract IMangoLogger createLogger(String name);
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public IMangoLogger getLogger(String name) {
+        return loggerCache.computeIfAbsent(name, this::createLogger);
+    }
+}

src/main/java/org/mangorage/bootstrap/api/logging/ILoggerFactory.java

@@ -0,0 +1,38 @@
+package org.mangorage.bootstrap.api.logging;
+
+import org.mangorage.bootstrap.internal.logger.DefaultLoggerFactory;
+
+public interface ILoggerFactory {
+    static ILoggerFactory getDefault() {
+        return DefaultLoggerFactory.INSTANCE;
+    }
+
+    /**
+     * Gets the logger provider by its name. The name is defined by the provider itself
+     * and can be used to differentiate between multiple providers.
+     */
+    ILoggerProvider getProvider(String providerName);
+
+    /**
+     * Gets the wrapped logger provider by its name. This is used to get the underlying logger provider
+     * Sometimes providers come in later then originally requested, so this method can be used to use the provider after it has been loaded.
+     */
+    default ILoggerProvider getWrappedProvider(String providerName) {
+        return new ILoggerProvider() {
+            private volatile ILoggerProvider delegate;
+
+            @Override
+            public String getName() {
+                return delegate == null ? providerName : delegate.getName();
+            }
+
+            @Override
+            public IMangoLogger getLogger(String name) {
+                if (delegate == null) {
+                    delegate = getProvider(providerName);
+                }
+                return delegate.getLogger(name);
+            }
+        };
+    }
+}

src/main/java/org/mangorage/bootstrap/api/logging/ILoggerProvider.java

@@ -0,0 +1,12 @@
+package org.mangorage.bootstrap.api.logging;
+
+public interface ILoggerProvider {
+
+    String getName();
+
+    default IMangoLogger getLogger(Class<?> clazz) {
+        return getLogger(clazz.getName());
+    }
+
+    IMangoLogger getLogger(String name);
+}

src/main/java/org/mangorage/bootstrap/api/logging/IMangoLogger.java

@@ -0,0 +1,50 @@
+package org.mangorage.bootstrap.api.logging;
+
+/**
+ * Enhanced logging wrapper that can delegate to different logging implementations.
+ * Provides additional "fun" features while maintaining standard logging compatibility.
+ */
+public interface IMangoLogger {
+
+    <T> T unwrap(Class<T> loggerClass) throws UnsupportedOperationException;
+
+    // Standard logging methods
+    void trace(String message);
+    void trace(String message, Object... args);
+    void trace(String message, Throwable throwable);
+
+    void debug(String message);
+    void debug(String message, Object... args);
+    void debug(String message, Throwable throwable);
+
+    void info(String message);
+    void info(String message, Object... args);
+    void info(String message, Throwable throwable);
+
+    void warn(String message);
+    void warn(String message, Object... args);
+    void warn(String message, Throwable throwable);
+
+    void error(String message);
+    void error(String message, Object... args);
+    void error(String message, Throwable throwable);
+
+    // Fun/Enhanced methods
+    void rainbow(String message);
+    void celebration(String message);
+    void dramatic(String message);
+    void whisper(String message);
+    void shout(String message);
+    void withEmoji(String emoji, String message);
+    void withBorder(String message);
+    void withContext(String context, String message);
+
+    // Utility methods
+    boolean isTraceEnabled();
+    boolean isDebugEnabled();
+    boolean isInfoEnabled();
+    boolean isWarnEnabled();
+    boolean isErrorEnabled();
+
+    String getName();
+}

src/main/java/org/mangorage/bootstrap/internal/logger/DefaultLoggerFactory.java

@@ -0,0 +1,31 @@
+package org.mangorage.bootstrap.internal.logger;
+
+import org.mangorage.bootstrap.api.logging.ILoggerFactory;
+import org.mangorage.bootstrap.api.logging.ILoggerProvider;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DefaultLoggerFactory implements ILoggerFactory {
+    public static final DefaultLoggerFactory INSTANCE = new DefaultLoggerFactory();
+    private static final Map<String, ILoggerProvider> providers = new ConcurrentHashMap<>(); // Placeholder for actual provider storage
+
+    static {
+        providers.put("default", DefaultLoggerProvider.INSTANCE);
+    }
+
+    public static void load(ModuleLayer moduleLayer) {
+        ServiceLoader.load(moduleLayer, ILoggerProvider.class).forEach(provider -> {
+            // Register the provider in some way, e.g., add it to a map
+            providers.put(provider.getName(), provider);
+        });
+    }
+
+    DefaultLoggerFactory() {
+    }
+
+    @Override
+    public ILoggerProvider getProvider(String providerName) {
+        return providers.getOrDefault(providerName, DefaultLoggerProvider.INSTANCE);
+    }
+}

src/main/java/org/mangorage/bootstrap/internal/logger/DefaultLoggerProvider.java

@@ -0,0 +1,18 @@
+package org.mangorage.bootstrap.internal.logger;
+
+import org.mangorage.bootstrap.api.logging.AbstractLoggerProvider;
+import org.mangorage.bootstrap.api.logging.ILoggerProvider;
+import org.mangorage.bootstrap.api.logging.IMangoLogger;
+
+public final class DefaultLoggerProvider extends AbstractLoggerProvider {
+    public static final ILoggerProvider INSTANCE = new DefaultLoggerProvider("default");
+
+    DefaultLoggerProvider(String name) {
+        super(name);
+    }
+
+    @Override
+    protected IMangoLogger createLogger(String name) {
+        return new JulMangoLogger(name);
+    }
+}