feat(console monitor): Log level can be set via program arg

core/common/boot/src/main/java/org/eclipse/edc/boot/system/ExtensionLoader.java

@@ -23,8 +23,10 @@
 import org.eclipse.edc.boot.system.injection.ProviderMethod;
 import org.eclipse.edc.boot.system.injection.ProviderMethodScanner;
 import org.eclipse.edc.boot.system.injection.lifecycle.ExtensionLifecycleManager;
+import org.eclipse.edc.spi.EdcException;
 import org.eclipse.edc.spi.monitor.ConsoleMonitor;
 import org.eclipse.edc.spi.monitor.Monitor;
+import org.eclipse.edc.spi.result.Result;
 import org.eclipse.edc.spi.system.MonitorExtension;
 import org.eclipse.edc.spi.system.ServiceExtension;
 import org.eclipse.edc.spi.system.ServiceExtensionContext;
@@ -37,6 +39,7 @@
 import java.util.Set;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class ExtensionLoader {
 
@@ -89,7 +92,11 @@ private static Supplier<Object> getDefaultProviderInvoker(ServiceExtensionContex
 
     static @NotNull Monitor loadMonitor(List<MonitorExtension> availableMonitors, String... programArgs) {
         if (availableMonitors.isEmpty()) {
-            return new ConsoleMonitor(!Set.of(programArgs).contains("--no-color"));
+            var parseResult = parseLogLevel(programArgs);
+            if (parseResult.failed()) {
+                throw new EdcException(parseResult.getFailureDetail());
+            }
+            return new ConsoleMonitor((ConsoleMonitor.Level) parseResult.getContent(), !Set.of(programArgs).contains(ConsoleMonitor.COLOR_PROG_ARG));
         }
 
         if (availableMonitors.size() > 1) {
@@ -127,4 +134,27 @@ public <T> List<T> loadExtensions(Class<T> type, boolean required) {
         return serviceLocator.loadImplementors(type, required);
     }
 
+    /**
+     * Parses the ConsoleMonitor log level from the program args. If no log level is provided, defaults to Level default.
+     */
+    private static Result<?> parseLogLevel(String[] programArgs) {
+        return Stream.of(programArgs)
+                .filter(arg -> arg.startsWith(ConsoleMonitor.LEVEL_PROG_ARG + "="))
+                .map(arg -> arg.split("="))
+                .map(arg -> {
+                    var validValueMessage = String.format("Valid values for the console level are %s", Stream.of(ConsoleMonitor.Level.values()).toList());
+
+                    if (arg.length != 2) {
+                        return Result.failure(String.format("Value missing for the --log-level argument. %s", validValueMessage));
+                    }
+                    try {
+                        return Result.success(ConsoleMonitor.Level.valueOf(arg[1]));
+                    } catch (IllegalArgumentException e) {
+                        return Result.failure(String.format("Invalid value %s for the --log-level argument. %s", arg[1], validValueMessage));
+                    }
+                })
+                .findFirst()
+                .orElse(Result.success(ConsoleMonitor.Level.getDefaultLevel()));
+    }
+
 }

core/common/boot/src/test/java/org/eclipse/edc/boot/system/ExtensionLoaderTest.java

@@ -37,6 +37,8 @@
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
 import org.mockito.Mockito;
 
 import java.util.ArrayList;
@@ -98,6 +100,33 @@ void loadMonitor_whenNoMonitorExtension() {
         assertTrue(monitor instanceof ConsoleMonitor);
     }
 
+    @ParameterizedTest
+    @EnumSource
+    void loadMonitor_programArgsSetConsoleMonitorLogLevel(ConsoleMonitor.Level level) {
+
+        var monitor = ExtensionLoader.loadMonitor(new ArrayList<>(), ConsoleMonitor.LEVEL_PROG_ARG + "=" + level.toString());
+
+        assertThat(monitor).extracting("level").isEqualTo(level);
+    }
+
+    @Test
+    void loadMonitor_consoleMonitorDefaultLogLevelWhenNoArgs() {
+
+        var monitor = ExtensionLoader.loadMonitor(new ArrayList<>());
+
+        assertThat(monitor).extracting("level").isEqualTo(ConsoleMonitor.Level.getDefaultLevel());
+    }
+
+    @Test
+    void loadMonitor_consoleMonitorDefaultLogLevelWhenWrongArgs() {
+        assertThatThrownBy(() -> ExtensionLoader.loadMonitor(new ArrayList<>(), ConsoleMonitor.LEVEL_PROG_ARG + "=INF"))
+                .isInstanceOf(EdcException.class)
+                .hasMessageContaining("Invalid value INF for the --log-level argument.");
+        assertThatThrownBy(() -> ExtensionLoader.loadMonitor(new ArrayList<>(), ConsoleMonitor.LEVEL_PROG_ARG + "="))
+                .isInstanceOf(EdcException.class)
+                .hasMessageContaining("Value missing for the --log-level argument.");
+    }
+
     @Test
     void selectOpenTelemetryImpl_whenNoOpenTelemetry() {
         var openTelemetry = ExtensionLoader.selectOpenTelemetryImpl(emptyList());

spi/common/boot-spi/src/main/java/org/eclipse/edc/spi/monitor/ConsoleMonitor.java

@@ -30,21 +30,21 @@ public class ConsoleMonitor implements Monitor {
     private static final String INFO = "INFO";
     private static final String DEBUG = "DEBUG";
 
+    public static final String LEVEL_PROG_ARG = "--log-level";
+    public static final String COLOR_PROG_ARG = "--no-color";
+
+
     private final boolean useColor;
 
-    private final Level level;
+    private Level level;
     private final String prefix;
 
     public ConsoleMonitor() {
-        this(true);
-    }
-
-    public ConsoleMonitor(boolean useColor) {
-        this(null, Level.DEBUG, useColor);
+        this(Level.getDefaultLevel(), true);
     }
 
-    public ConsoleMonitor(@Nullable String runtimeName, Level level) {
-        this(runtimeName, level, true);
+    public ConsoleMonitor(Level level, boolean useColor) {
+        this(null, level, useColor);
     }
 
     public ConsoleMonitor(@Nullable String runtimeName, Level level, boolean useColor) {
@@ -117,5 +117,10 @@ public enum Level {
         Level(int value) {
             this.value = value;
         }
+
+        public static Level getDefaultLevel() {
+            return Level.DEBUG;
+        }
+
     }
 }