Remove log4j dependency from elasticsearch-core

libs/elasticsearch-core/build.gradle

@@ -35,8 +35,6 @@ publishing {
 }
 
 dependencies {
-    compile "org.apache.logging.log4j:log4j-api:${versions.log4j}"
-
     testCompile "com.carrotsearch.randomizedtesting:randomizedtesting-runner:${versions.randomizedrunner}"
     testCompile "junit:junit:${versions.junit}"
     testCompile "org.hamcrest:hamcrest-all:${versions.hamcrest}"
@@ -78,4 +76,4 @@ thirdPartyAudit.excludes = [
         'org/osgi/framework/SynchronousBundleListener',
         'org/osgi/framework/wiring/BundleWire',
         'org/osgi/framework/wiring/BundleWiring'
-]
+]

libs/elasticsearch-core/src/main/java/org/elasticsearch/bootstrap/JarHell.java

@@ -19,10 +19,8 @@
 
 package org.elasticsearch.bootstrap;
 
-import org.apache.logging.log4j.Logger;
 import org.elasticsearch.common.SuppressForbidden;
 import org.elasticsearch.common.io.PathUtils;
-import org.elasticsearch.common.logging.Loggers;
 
 import java.io.IOException;
 import java.net.MalformedURLException;
@@ -43,6 +41,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Consumer;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
@@ -68,25 +67,23 @@ private JarHell() {}
     @SuppressForbidden(reason = "command line tool")
     public static void main(String args[]) throws Exception {
         System.out.println("checking for jar hell...");
-        checkJarHell();
+        checkJarHell(System.out::println);
         System.out.println("no jar hell found");
     }
 
     /**
      * Checks the current classpath for duplicate classes
+     * @param output A {@link String} {@link Consumer} to which debug output will be sent
      * @throws IllegalStateException if jar hell was found
      */
-    public static void checkJarHell() throws IOException, URISyntaxException {
+    public static void checkJarHell(Consumer<String> output) throws IOException, URISyntaxException {
         ClassLoader loader = JarHell.class.getClassLoader();
-        Logger logger = Loggers.getLogger(JarHell.class);
-        if (logger.isDebugEnabled()) {
-            logger.debug("java.class.path: {}", System.getProperty("java.class.path"));
-            logger.debug("sun.boot.class.path: {}", System.getProperty("sun.boot.class.path"));
-            if (loader instanceof URLClassLoader ) {
-                logger.debug("classloader urls: {}", Arrays.toString(((URLClassLoader)loader).getURLs()));
-             }
+        output.accept("java.class.path: " + System.getProperty("java.class.path"));
+        output.accept("sun.boot.class.path: " + System.getProperty("sun.boot.class.path"));
+        if (loader instanceof URLClassLoader) {
+            output.accept("classloader urls: " + Arrays.toString(((URLClassLoader)loader).getURLs()));
         }
-        checkJarHell(parseClassPath());
+        checkJarHell(parseClassPath(), output);
     }
 
     /**
@@ -152,31 +149,32 @@ static Set<URL> parseClassPath(String classPath) {
 
     /**
      * Checks the set of URLs for duplicate classes
+     * @param urls A set of URLs from the classpath to be checked for conflicting jars
+     * @param output A {@link String} {@link Consumer} to which debug output will be sent
      * @throws IllegalStateException if jar hell was found
      */
     @SuppressForbidden(reason = "needs JarFile for speed, just reading entries")
-    public static void checkJarHell(Set<URL> urls) throws URISyntaxException, IOException {
-        Logger logger = Loggers.getLogger(JarHell.class);
+    public static void checkJarHell(Set<URL> urls, Consumer<String> output) throws URISyntaxException, IOException {
         // we don't try to be sneaky and use deprecated/internal/not portable stuff
         // like sun.boot.class.path, and with jigsaw we don't yet have a way to get
         // a "list" at all. So just exclude any elements underneath the java home
         String javaHome = System.getProperty("java.home");
-        logger.debug("java.home: {}", javaHome);
+        output.accept("java.home: " + javaHome);
         final Map<String,Path> clazzes = new HashMap<>(32768);
         Set<Path> seenJars = new HashSet<>();
         for (final URL url : urls) {
             final Path path = PathUtils.get(url.toURI());
             // exclude system resources
             if (path.startsWith(javaHome)) {
-                logger.debug("excluding system resource: {}", path);
+                output.accept("excluding system resource: " + path);
                 continue;
             }
             if (path.toString().endsWith(".jar")) {
                 if (!seenJars.add(path)) {
                     throw new IllegalStateException("jar hell!" + System.lineSeparator() +
                                                     "duplicate jar on classpath: " + path);
                 }
-                logger.debug("examining jar: {}", path);
+                output.accept("examining jar: " + path);
                 try (JarFile file = new JarFile(path.toString())) {
                     Manifest manifest = file.getManifest();
                     if (manifest != null) {
@@ -194,7 +192,7 @@ public static void checkJarHell(Set<URL> urls) throws URISyntaxException, IOExce
                     }
                 }
             } else {
-                logger.debug("examining directory: {}", path);
+                output.accept("examining directory: " + path);
                 // case for tests: where we have class files in the classpath
                 final Path root = PathUtils.get(url.toURI());
                 final String sep = root.getFileSystem().getSeparator();