Implement custom JUL bridge

qa/evil-tests/src/test/java/org/elasticsearch/common/logging/EvilLoggerConfigurationTests.java

@@ -144,7 +144,7 @@ public void testLoggingLevelsFromSettings() throws IOException, UserException {
         final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
         final Configuration config = ctx.getConfiguration();
         final Map<String, LoggerConfig> loggerConfigs = config.getLoggers();
-        assertThat(loggerConfigs.size(), equalTo(3));
+        assertThat(loggerConfigs.size(), equalTo(5));
         assertThat(loggerConfigs, hasKey(""));
         assertThat(loggerConfigs.get("").getLevel(), equalTo(rootLevel));
         assertThat(loggerConfigs, hasKey("foo"));

server/build.gradle

@@ -248,6 +248,7 @@ tasks.named("thirdPartyAudit").configure {
 
 tasks.named("dependencyLicenses").configure {
     mapping from: /lucene-.*/, to: 'lucene'
+    mapping from: /log4j-.*/, to: 'log4j'
     dependencies = project.configurations.runtimeClasspath.fileCollection {
         it.group.startsWith('org.elasticsearch') == false ||
                 // keep the following org.elasticsearch jars in

server/src/main/java/org/elasticsearch/common/logging/JULBridge.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License
+ * 2.0 and the Server Side Public License, v 1; you may not use this file except
+ * in compliance with, at your election, the Elastic License 2.0 or the Server
+ * Side Public License, v 1.
+ */
+
+package org.elasticsearch.common.logging;
+
+import org.elasticsearch.common.util.Maps;
+import org.elasticsearch.logging.Level;
+import org.elasticsearch.logging.Logger;
+import org.elasticsearch.logging.LogManager;
+
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.TreeMap;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.stream.Collectors;
+
+/**
+ * A Java Util Logging handler that writes log messages to log4j.
+ */
+class JULBridge extends Handler {
+
+    private static final Map<java.util.logging.Level, Level> levelMap = Map.of(
+        java.util.logging.Level.OFF,
+        Level.OFF,
+        java.util.logging.Level.SEVERE,
+        Level.ERROR,
+        java.util.logging.Level.WARNING,
+        Level.WARN,
+        java.util.logging.Level.INFO,
+        Level.INFO,
+        java.util.logging.Level.FINE,
+        Level.DEBUG,
+        java.util.logging.Level.FINEST,
+        Level.TRACE,
+        java.util.logging.Level.ALL,
+        Level.ALL
+    );
+
+    private static final NavigableMap<Integer, Level> sortedLevelMap =
+        levelMap.entrySet().stream().collect(Maps.toUnmodifiableSortedMap(e -> e.getKey().intValue(), Map.Entry::getValue)
+    );
+
+    public static void install() {
+        var rootJulLogger = java.util.logging.LogManager.getLogManager().getLogger("");
+        // clear out any other handlers, so eg we don't also print to stdout
+        for (var existingHandler : rootJulLogger.getHandlers()) {
+            rootJulLogger.removeHandler(existingHandler);
+        }
+        rootJulLogger.addHandler(new JULBridge());
+    }
+
+    private JULBridge() {}
+
+    @Override
+    public void publish(LogRecord record) {
+        Logger logger = LogManager.getLogger(record.getLoggerName());
+        Level level = translateJulLevel(record.getLevel());
+        Throwable thrown = record.getThrown();
+        if (thrown == null) {
+            logger.log(level, record.getMessage());
+        } else {
+            logger.log(level, record::getMessage, thrown);
+        }
+    }
+
+    private Level translateJulLevel(java.util.logging.Level julLevel) {
+        Level log4jLevel = levelMap.get(julLevel);
+        if (log4jLevel != null) {
+            return log4jLevel;
+        }
+        // no matching known level, so find the closest level by int value
+        var closestEntry = sortedLevelMap.lowerEntry(julLevel.intValue());
+        assert closestEntry != null; // not possible since ALL is min int
+        return closestEntry.getValue();
+    }
+
+    @Override
+    public void flush() {}
+
+    @Override
+    public void close() {}
+}