Add new java platform logger

driver/clirr-ignored-differences.xml

@@ -409,4 +409,10 @@
         <method>org.neo4j.driver.BaseSession session(java.lang.Class, org.neo4j.driver.SessionConfig)</method>
     </difference>
 
+    <difference>
+        <className>org/neo4j/driver/Logging</className>
+        <differenceType>7012</differenceType>
+        <method>org.neo4j.driver.Logging javaPlatformLogging()</method>
+    </difference>
+
 </differences>

driver/src/main/java/module-info.java

@@ -35,7 +35,7 @@
     requires io.netty.buffer;
     requires io.netty.codec;
     requires io.netty.resolver;
-    requires transitive java.logging;
+    requires static java.logging;
     requires transitive org.reactivestreams;
     requires static micrometer.core;
     requires static org.graalvm.nativeimage.builder;

driver/src/main/java/org/neo4j/driver/Logging.java

@@ -24,6 +24,7 @@
 import java.util.logging.Level;
 import org.neo4j.driver.internal.logging.ConsoleLogging;
 import org.neo4j.driver.internal.logging.JULogging;
+import org.neo4j.driver.internal.logging.JavaPlatformLogging;
 import org.neo4j.driver.internal.logging.Slf4jLogging;
 
 /**
@@ -33,6 +34,9 @@
  * <li>{@link #slf4j() SLF4J logging} - uses available SLF4J binding (Logback, Log4j, etc.) fails when no SLF4J implementation is available. Uses
  * application's logging configuration from XML or other type of configuration file. This logging method is the preferred one and relies on the SLF4J
  * implementation available in the classpath or modulepath.</li>
+ * <li>{@link #javaPlatformLogging() Java Logging API} - uses {@link java.lang.System.Logger} created via
+ * {@link java.lang.System#getLogger(String)}. This logging method is suitable when application
+ * uses the java system logger api for logging and provides the appropriate implementation (Logback, Log4j, etc.)</li>
  * <li>{@link #javaUtilLogging(Level) Java Logging API (JUL)} - uses {@link java.util.logging.Logger} created via
  * {@link java.util.logging.Logger#getLogger(String)}. Global java util logging configuration applies. This logging method is suitable when application
  * uses JUL for logging and explicitly configures it.</li>
@@ -118,13 +122,27 @@ static Logging slf4j() {
         return new Slf4jLogging();
     }
 
+    /**
+     * Create logging implementation that uses {@link java.lang.System.Logger}.
+     *
+     * @return new logging implementation.
+     */
+    static Logging javaPlatformLogging() {
+        return new JavaPlatformLogging();
+    }
+
     /**
      * Create logging implementation that uses {@link java.util.logging}.
      *
      * @param level the log level.
      * @return new logging implementation.
+     * @throws IllegalStateException if SLF4J is not available.
      */
     static Logging javaUtilLogging(Level level) {
+        IllegalStateException unavailabilityError = JULogging.checkAvailability();
+        if (unavailabilityError != null) {
+            throw unavailabilityError;
+        }
         return new JULogging(level);
     }
 

driver/src/main/java/org/neo4j/driver/internal/logging/JULogging.java

@@ -42,4 +42,15 @@ public JULogging(Level loggingLevel) {
     public Logger getLog(String name) {
         return new JULogger(name, loggingLevel);
     }
+
+    public static IllegalStateException checkAvailability() {
+        try {
+            Class.forName("java.util.logging.Logger");
+            return null;
+        } catch (Throwable error) {
+            return new IllegalStateException(
+                    "java.util.logging is not available. Please add the java.logging module.",
+                    error);
+        }
+    }
 }

driver/src/main/java/org/neo4j/driver/internal/logging/JavaPlatformLogger.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.logging;
+
+import org.neo4j.driver.Logger;
+
+import java.lang.System.Logger.Level;
+import java.util.Objects;
+
+public class JavaPlatformLogger implements Logger {
+    private final java.lang.System.Logger delegate;
+
+    public JavaPlatformLogger(System.Logger delegate) {
+        this.delegate = Objects.requireNonNull(delegate);
+    }
+
+    @Override
+    public void error(String message, Throwable cause) {
+        if (delegate.isLoggable(Level.ERROR)) {
+            delegate.log(Level.ERROR, message, cause);
+        }
+    }
+
+    @Override
+    public void info(String format, Object... params) {
+        if (delegate.isLoggable(Level.INFO)) {
+            delegate.log(Level.INFO, String.format(format, params));
+        }
+    }
+
+    @Override
+    public void warn(String format, Object... params) {
+        if (delegate.isLoggable(Level.WARNING)) {
+            delegate.log(Level.WARNING, String.format(format, params));
+        }
+    }
+
+    @Override
+    public void warn(String message, Throwable cause) {
+        if (delegate.isLoggable(Level.WARNING)) {
+            delegate.log(Level.WARNING, message, cause);
+        }
+    }
+
+    @Override
+    public void debug(String format, Object... params) {
+        if (isDebugEnabled()) {
+            delegate.log(Level.DEBUG, String.format(format, params));
+        }
+    }
+
+    @Override
+    public void debug(String message, Throwable throwable) {
+        if (isDebugEnabled()) {
+            delegate.log(Level.DEBUG, message, throwable);
+        }
+    }
+
+    @Override
+    public void trace(String format, Object... params) {
+        if (isTraceEnabled()) {
+            delegate.log(Level.TRACE, String.format(format, params));
+        }
+    }
+
+    @Override
+    public boolean isTraceEnabled() {
+        return delegate.isLoggable(Level.TRACE);
+    }
+
+    @Override
+    public boolean isDebugEnabled() {
+        return delegate.isLoggable(Level.DEBUG);
+    }
+}

driver/src/main/java/org/neo4j/driver/internal/logging/JavaPlatformLogging.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.logging;
+
+import org.neo4j.driver.Logger;
+import org.neo4j.driver.Logging;
+
+import java.io.Serializable;
+
+/**
+ * Internal implementation of the java platform logging module.
+ * <b>This class should not be used directly.</b> Please use {@link Logging#javaPlatformLogging()} factory method instead.
+ *
+ * @see Logging#javaPlatformLogging()
+ */
+public class JavaPlatformLogging implements Logging, Serializable {
+    private static final long serialVersionUID = -1145576859241657833L;
+
+    public JavaPlatformLogging() {
+    }
+
+    @Override
+    public Logger getLog(String name) {
+        return new JavaPlatformLogger(System.getLogger(name));
+    }
+}

driver/src/test/java/org/neo4j/driver/ConfigTest.java

@@ -47,6 +47,7 @@
 import org.neo4j.driver.internal.logging.DevNullLogging;
 import org.neo4j.driver.internal.logging.JULogging;
 import org.neo4j.driver.internal.logging.Slf4jLogging;
+import org.neo4j.driver.internal.logging.JavaPlatformLogging;
 import org.neo4j.driver.net.ServerAddressResolver;
 import org.neo4j.driver.testutil.TestUtil;
 
@@ -486,7 +487,7 @@ void shouldSerializeSerializableLogging() throws IOException, ClassNotFoundExcep
         }
 
         @ParameterizedTest
-        @ValueSource(classes = {DevNullLogging.class, JULogging.class, ConsoleLogging.class, Slf4jLogging.class})
+        @ValueSource(classes = {DevNullLogging.class, JULogging.class, ConsoleLogging.class, Slf4jLogging.class, JavaPlatformLogging.class})
         void officialLoggingProvidersShouldBeSerializable(Class<? extends Logging> loggingClass) {
             assertTrue(Serializable.class.isAssignableFrom(loggingClass));
         }

driver/src/test/java/org/neo4j/driver/internal/logging/JULoggingTest.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.logging;
+
+import org.junit.jupiter.api.Test;
+import org.neo4j.driver.Logger;
+
+import java.util.logging.Level;
+
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.junit.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class JULoggingTest {
+    @Test
+    void shouldCreateLoggers() {
+        JULogging logging = new JULogging(Level.ALL);
+
+        Logger logger = logging.getLog("My Log");
+
+        assertThat(logger, instanceOf(JULogger.class));
+    }
+
+    @Test
+    void shouldCheckIfAvailable() {
+        assertNull(JULogging.checkAvailability());
+    }
+}

driver/src/test/java/org/neo4j/driver/internal/logging/JavaPlatformLoggerTest.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal.logging;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.System.Logger;
+import java.lang.System.Logger.Level;
+
+class JavaPlatformLoggerTest {
+    private final Logger logger = Mockito.mock(Logger.class);
+    private final JavaPlatformLogger javaPlatformLogger = new JavaPlatformLogger(logger);
+
+    @Test
+    void shouldLogErrorWithMessageAndThrowable() {
+        Mockito.when(logger.isLoggable(Level.ERROR)).thenReturn(true);
+        String message = "Hello";
+        IllegalArgumentException error = new IllegalArgumentException("World");
+
+        javaPlatformLogger.error(message, error);
+
+        Mockito.verify(logger).log(Level.ERROR, message, error);
+    }
+
+    @Test
+    void shouldLogInfoWithMessageAndParams() {
+        Mockito.when(logger.isLoggable(Level.INFO)).thenReturn(true);
+        String message = "One %s, two %s, three %s";
+        Object[] params = {"111", "222", "333"};
+
+        javaPlatformLogger.info(message, params);
+
+        Mockito.verify(logger).log(Level.INFO, "One 111, two 222, three 333");
+    }
+
+    @Test
+    void shouldLogWarnWithMessageAndParams() {
+        Mockito.when(logger.isLoggable(Level.WARNING)).thenReturn(true);
+        String message = "C for %s, d for %s";
+        Object[] params = {"cat", "dog"};
+
+        javaPlatformLogger.warn(message, params);
+
+        Mockito.verify(logger).log(Level.WARNING, "C for cat, d for dog");
+    }
+
+    @Test
+    void shouldLogWarnWithMessageAndThrowable() {
+        Mockito.when(logger.isLoggable(Level.WARNING)).thenReturn(true);
+        String message = "Hello";
+        RuntimeException error = new RuntimeException("World");
+
+        javaPlatformLogger.warn(message, error);
+
+        Mockito.verify(logger).log(Level.WARNING, message, error);
+    }
+
+    @Test
+    void shouldLogDebugWithMessageAndParams() {
+        Mockito.when(logger.isLoggable(Level.DEBUG)).thenReturn(true);
+        String message = "Hello%s%s!";
+        Object[] params = {" ", "World"};
+
+        javaPlatformLogger.debug(message, params);
+
+        Mockito.verify(logger).log(Level.DEBUG, "Hello World!");
+    }
+
+    @Test
+    void shouldLogTraceWithMessageAndParams() {
+        Mockito.when(logger.isLoggable(Level.TRACE)).thenReturn(true);
+        String message = "I'll be %s!";
+        Object[] params = {"back"};
+
+        javaPlatformLogger.trace(message, params);
+
+        Mockito.verify(logger).log(Level.TRACE, "I'll be back!");
+    }
+
+    @Test
+    void shouldCheckIfDebugIsEnabled() {
+        Mockito.when(logger.isLoggable(Level.DEBUG)).thenReturn(false);
+        assertFalse(javaPlatformLogger.isDebugEnabled());
+
+        Mockito.when(logger.isLoggable(Level.DEBUG)).thenReturn(true);
+        assertTrue(javaPlatformLogger.isDebugEnabled());
+    }
+
+    @Test
+    void shouldCheckIfTraceIsEnabled() {
+        Mockito.when(logger.isLoggable(Level.TRACE)).thenReturn(false);
+        assertFalse(javaPlatformLogger.isTraceEnabled());
+
+        Mockito.when(logger.isLoggable(Level.TRACE)).thenReturn(true);
+        assertTrue(javaPlatformLogger.isTraceEnabled());
+    }
+}