Implement JSON Logger configuration (#74)

Author: JavaSaBr

gradle/libs.versions.toml

@@ -21,6 +21,8 @@ mockito = "5.20.0"
 assertj-core = "4.0.0-M1"
 # https://mvnrepository.com/artifact/org.awaitility/awaitility
 awaitility = "4.3.0"
+# https://mvnrepository.com/artifact/tools.jackson.core/jackson-core/3.2.0
+jackson = "3.2.0"
 
 [libraries]
 project-reactor-core = { module = "io.projectreactor:reactor-core", version.ref = "project-reactor" }
@@ -40,6 +42,8 @@ mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version.ref = "mockito" }
 assertj-core = { module = "org.assertj:assertj-core", version.ref = "assertj-core" }
 awaitility = { module = "org.awaitility:awaitility", version.ref = "awaitility" }
+jackson-core = { module = "tools.jackson.core:jackson-core", version.ref = "jackson" }
+jackson-databind = { module = "tools.jackson.core:jackson-databind", version.ref = "jackson" }
 
 [bundles]
 mail = ["jakarta-mail-api", "angus-mail"]

rlib-common/src/testFixtures/java/javasabr/rlib/common/util/ResourceClassLoader.java

@@ -0,0 +1,39 @@
+package javasabr.rlib.common.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ResourceClassLoader extends ClassLoader {
+
+  private final Map<String, byte[]> resources;
+  private final Set<String> hiddenResources;
+
+  public ResourceClassLoader(Map<String, String> resources, Set<String> hiddenResources) {
+    super(Thread
+        .currentThread()
+        .getContextClassLoader());
+    this.resources = resources
+        .entrySet()
+        .stream()
+        .collect(Collectors.toUnmodifiableMap(
+            Map.Entry::getKey,
+            entry -> entry.getValue().getBytes(StandardCharsets.UTF_8)));
+    this.hiddenResources = Set.copyOf(hiddenResources);
+  }
+
+  @Override
+  public InputStream getResourceAsStream(String name) {
+    byte[] loaded = resources.get(name);
+    if (loaded != null) {
+      return new ByteArrayInputStream(loaded);
+    }
+    if (hiddenResources.contains(name)) {
+      return null;
+    }
+    return super.getResourceAsStream(name);
+  }
+}

rlib-logger-api/src/main/java/javasabr/rlib/logger/api/LoggerFactory.java

@@ -7,6 +7,8 @@
  */
 public interface LoggerFactory {
 
+  String ROOT_LOGGER_NAME = "ROOT";
+  
   /**
    * Creates or gets a logger with the specified name.
    *
@@ -26,12 +28,12 @@ public interface LoggerFactory {
   Logger getLogger(Class<?> type);
 
   /**
-   * Returns the default logger.
+   * Returns the root logger.
    *
-   * @return the default logger
+   * @return the root logger
    * @since 10.0.0
    */
-  Logger getDefault();
+  Logger getRootLogger();
 
   /**
    * Returns the logger service.

rlib-logger-api/src/main/java/javasabr/rlib/logger/api/LoggerManager.java

@@ -59,7 +59,7 @@ public class LoggerManager {
    * @since 10.0.0
    */
   public static Logger getDefaultLogger() {
-    return LOGGER_FACTORY.getDefault();
+    return LOGGER_FACTORY.getRootLogger();
   }
 
   /**

rlib-logger-api/src/main/java/javasabr/rlib/logger/api/impl/NoOpsLoggerFactory.java

@@ -20,7 +20,7 @@ public Logger getLogger(Class<?> type) {
   }
 
   @Override
-  public Logger getDefault() {
+  public Logger getRootLogger() {
     return NO_OPS_LOGGER;
   }
 

rlib-logger-impl-json/build.gradle

@@ -0,0 +1,11 @@
+plugins {
+  id("configure-java")
+  id("configure-publishing")
+}
+
+dependencies {
+  api projects.rlibLoggerImpl
+  api libs.jackson.core
+  api libs.jackson.databind
+  testImplementation testFixtures(projects.rlibCommon)
+}

rlib-logger-impl-json/src/main/java/javasabr/rlib/logger/impl/config/loader/json/JsonLoggerConfigLoader.java

@@ -0,0 +1,177 @@
+package javasabr.rlib.logger.impl.config.loader.json;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javasabr.rlib.common.util.StringUtils;
+import javasabr.rlib.logger.api.LoggerLevel;
+import javasabr.rlib.logger.impl.config.LoggerConfig;
+import javasabr.rlib.logger.impl.config.consumer.LogMessageConsumer;
+import javasabr.rlib.logger.impl.config.consumer.impl.ConsoleMessageConsumer;
+import javasabr.rlib.logger.impl.config.consumer.impl.CustomLogMessageConsumer;
+import javasabr.rlib.logger.impl.config.impl.LoggerConfigBuilder;
+import javasabr.rlib.logger.impl.config.loader.LoggerConfigLoader;
+import javasabr.rlib.logger.impl.config.loader.json.dto.JsonLoggerConfigDto;
+import javasabr.rlib.logger.impl.config.loader.json.dto.JsonLoggerConfigDto.ConsumerDto;
+import javasabr.rlib.logger.impl.config.loader.json.dto.JsonLoggerConfigDto.LoggerDto;
+import javasabr.rlib.logger.impl.config.loader.json.dto.JsonLoggerConfigDto.RenderDto;
+import javasabr.rlib.logger.impl.config.render.LogMessageRender;
+import javasabr.rlib.logger.impl.config.render.impl.CustomLogMessageRender;
+import javasabr.rlib.logger.impl.config.render.impl.SimpleLogMessageRender;
+import javasabr.rlib.logger.impl.config.render.impl.pattern.PatternLogMessageRender;
+import lombok.AccessLevel;
+import lombok.experimental.FieldDefaults;
+import tools.jackson.databind.ObjectMapper;
+
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class JsonLoggerConfigLoader implements LoggerConfigLoader {
+
+  public static final String FILE_MAIN = "rlib.logger.json";
+  public static final String FILE_TEST = "rlib.logger-test.json";
+  
+  ObjectMapper objectMapper = new ObjectMapper();
+  
+  @Override
+  public Optional<LoggerConfig> tryToLoad() {
+    ClassLoader classLoader = Thread
+        .currentThread()
+        .getContextClassLoader();
+    InputStream configStream = classLoader.getResourceAsStream(FILE_TEST);
+    if (configStream == null) {
+      configStream = classLoader.getResourceAsStream(FILE_MAIN);
+    }
+    if (configStream == null) {
+      return Optional.empty();
+    } else {
+      return Optional.of(load(configStream));
+    }
+  }
+
+  @Override
+  public int order() {
+    return LoggerConfigLoader.ORDER_NORMAL;
+  }
+
+  private LoggerConfig load(InputStream inputStream) {
+    try (var in = inputStream) {
+      JsonLoggerConfigDto configDto = objectMapper.readValue(in, JsonLoggerConfigDto.class);
+      return load(configDto);
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private LoggerConfig load(JsonLoggerConfigDto configDto) {
+
+    var builder = new LoggerConfigBuilder();
+    
+    List<CreatedRender> createdRenders = configDto
+        .renders()
+        .stream()
+        .map(this::createRender)
+        .toList();
+
+    Map<String, LogMessageRender> renderMap = createdRenders
+        .stream()
+        .collect(Collectors.toMap(CreatedRender::name, CreatedRender::render));
+
+    List<CreatedConsumer> createdConsumers = configDto
+        .consumers()
+        .stream()
+        .map(consumerDto -> createConsumer(renderMap, consumerDto))
+        .toList();
+
+    Map<String, LogMessageConsumer> consumerMap = createdConsumers
+        .stream()
+        .collect(Collectors.toMap(CreatedConsumer::name, CreatedConsumer::consumer));
+
+    for (LoggerDto loggerDto : configDto.loggers()) {
+      if (loggerDto.level() != null) {
+        builder.registerLoggerLevel(loggerDto.name(), loggerDto.level());
+      }
+      Set<String> consumerNames = loggerDto.consumerNames();
+      if (!consumerNames.isEmpty()) {
+        for (String consumerName : consumerNames) {
+          LogMessageConsumer consumer = consumerMap.get(consumerName);
+          if (consumer == null) {
+            throw new RuntimeException("Consumer " + consumerName + " not found");
+          }
+          LoggerLevel level = loggerDto.level();
+          if (level == null) {
+            level = LoggerLevel.TRACE;
+          }
+          builder.registerLoggerConsumer(loggerDto.name(), level, consumer);
+        }
+      }
+    }
+    
+    return builder.build();
+  }
+
+  CreatedRender createRender(RenderDto renderDto) {
+    LogMessageRender render = switch (renderDto.type()) {
+      case SIMPLE -> new SimpleLogMessageRender();
+      case PATTERN -> new PatternLogMessageRender(renderDto.args());
+      case CUSTOM -> createCustomRender(renderDto);
+    };
+    return new CreatedRender(renderDto.name(), render);
+  }
+
+  LogMessageRender createCustomRender(RenderDto renderDto) {
+    String className = renderDto.className();
+    if (StringUtils.isBlank(className)) {
+      throw new IllegalArgumentException("'class' attribute is required for custom render");
+    }
+    ClassLoader classLoader = Thread
+        .currentThread()
+        .getContextClassLoader();
+    try {
+      var targetClass = (Class<? extends CustomLogMessageRender>) classLoader.loadClass(className);
+      Constructor<? extends CustomLogMessageRender> constructor = targetClass.getDeclaredConstructor(Map.class);
+      return constructor.newInstance(renderDto.args());
+    } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException |
+             IllegalAccessException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  CreatedConsumer createConsumer(Map<String, LogMessageRender> renderMap, ConsumerDto consumerDto) {
+    LogMessageRender render = renderMap.get(consumerDto.renderName());
+    if (render == null) {
+      throw new IllegalArgumentException("Unknown render with name: " + consumerDto.renderName());
+    }
+    LogMessageConsumer consumer = switch (consumerDto.type()) {
+      case CONSOLE -> new ConsoleMessageConsumer(render);
+      case CUSTOM -> createCustomConsumer(render, consumerDto);
+    };
+    return new CreatedConsumer(consumerDto.name(), consumer);
+  }
+
+  LogMessageConsumer createCustomConsumer(LogMessageRender render, ConsumerDto consumerDto) {
+    String className = consumerDto.className();
+    if (StringUtils.isBlank(className)) {
+      throw new IllegalArgumentException("'class' attribute is required for custom consumer");
+    }
+    ClassLoader classLoader = Thread
+        .currentThread()
+        .getContextClassLoader();
+    try {
+      var targetClass = (Class<? extends CustomLogMessageConsumer>) classLoader.loadClass(className);
+      Constructor<? extends CustomLogMessageConsumer> constructor = targetClass
+          .getDeclaredConstructor(LogMessageRender.class, Map.class);
+      return constructor.newInstance(render, consumerDto.args());
+    } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException |
+             IllegalAccessException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private record CreatedRender(String name, LogMessageRender render) {}
+  private record CreatedConsumer(String name, LogMessageConsumer consumer) {}
+}

rlib-logger-impl-json/src/main/java/javasabr/rlib/logger/impl/config/loader/json/JsonLoggerConfigLoadersProvider.java

@@ -0,0 +1,15 @@
+package javasabr.rlib.logger.impl.config.loader.json;
+
+import javasabr.rlib.collections.array.Array;
+import javasabr.rlib.logger.impl.config.loader.LoggerConfigLoader;
+import javasabr.rlib.logger.impl.config.loader.spi.LoggerConfigLoadersProvider;
+
+public class JsonLoggerConfigLoadersProvider implements LoggerConfigLoadersProvider {
+
+  private static final Array<LoggerConfigLoader> LOADERS = Array.of(new JsonLoggerConfigLoader());
+
+  @Override
+  public Array<LoggerConfigLoader> getLoggerConfigLoaders() {
+    return LOADERS;
+  }
+}

rlib-logger-impl-json/src/main/java/javasabr/rlib/logger/impl/config/loader/json/dto/JsonLoggerConfigDto.java

@@ -0,0 +1,78 @@
+package javasabr.rlib.logger.impl.config.loader.json.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javasabr.rlib.common.util.StringUtils;
+import javasabr.rlib.logger.api.LoggerLevel;
+import org.jspecify.annotations.Nullable;
+
+public record JsonLoggerConfigDto(
+    List<LoggerDto> loggers,
+    List<RenderDto> renders,
+    List<ConsumerDto> consumers) {
+
+  public JsonLoggerConfigDto {
+    loggers = loggers == null ? List.of() : List.copyOf(loggers);
+    renders = renders == null ? List.of() : List.copyOf(renders);
+    consumers = consumers == null ? List.of() : List.copyOf(consumers);
+  }
+  
+  public record LoggerDto(
+      String name,
+      @Nullable LoggerLevel level,
+      @JsonProperty("consumers") Set<String> consumerNames) {
+
+    public LoggerDto {
+      if (StringUtils.isBlank(name)) {
+        throw new IllegalArgumentException("name is blank");
+      }
+      consumerNames = consumerNames == null ? Set.of() : Set.copyOf(consumerNames);
+    }
+  }
+  
+  public record RenderDto(
+      String name,
+      RenderType type,
+      @JsonProperty("class") @Nullable String className,
+      Map<String, Object> args) {
+
+    public RenderDto {
+      if (StringUtils.isBlank(name)) {
+        throw new IllegalArgumentException("name is blank");
+      } else if (type == null) {
+        throw new IllegalArgumentException("type is null");
+      }
+      args = args == null ? Map.of() : Map.copyOf(args);
+    }
+  }
+  
+  public enum RenderType {
+    SIMPLE,
+    PATTERN,
+    CUSTOM
+  }
+
+  public record ConsumerDto(
+      String name,
+      ConsumerType type,
+      @JsonProperty("render") String renderName,
+      @JsonProperty("class") @Nullable String className,
+      Map<String, Object> args) {
+
+    public ConsumerDto {
+      if (StringUtils.isBlank(name)) {
+        throw new IllegalArgumentException("name is blank");
+      } else if (type == null) {
+        throw new IllegalArgumentException("type is null");
+      }
+      args = args == null ? Map.of() : Map.copyOf(args);
+    }
+  }
+
+  public enum ConsumerType {
+    CONSOLE,
+    CUSTOM
+  }
+}

rlib-logger-impl-json/src/main/java/javasabr/rlib/logger/impl/config/loader/json/dto/package-info.java

@@ -0,0 +1,4 @@
+@NullMarked
+package javasabr.rlib.logger.impl.config.loader.json.dto;
+
+import org.jspecify.annotations.NullMarked;