Java: Add Logger

java/client/src/main/java/glide/api/logging/Logger.java

@@ -0,0 +1,191 @@
+/** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
+package glide.api.logging;
+
+import static glide.ffi.resolvers.LoggerResolver.initInternal;
+import static glide.ffi.resolvers.LoggerResolver.logInternal;
+
+import lombok.Getter;
+import lombok.NonNull;
+
+/**
+ * A singleton class that allows logging which is consistent with logs from the internal rust core.
+ * The logger can be set up in 2 ways -
+ *
+ * <ol>
+ *   <li>By calling <code>Logger.init</code>, which configures the logger only if it wasn't
+ *       previously configured.
+ *   <li>By calling <code>Logger.setLoggerConfig</code>, which replaces the existing configuration,
+ *       and means that new logs will not be saved with the logs that were sent before the call.
+ * </ol>
+ *
+ * If <code>setLoggerConfig</code> wasn't called, the first log attempt will initialize a new logger
+ * with default configuration decided by Glide core.
+ */
+public final class Logger {
+    @Getter
+    public enum Level {
+        DISABLED(-2),
+        DEFAULT(-1),
+        ERROR(0),
+        WARN(1),
+        INFO(2),
+        DEBUG(3),
+        TRACE(4);
+
+        private final int level;
+
+        Level(int level) {
+            this.level = level;
+        }
+
+        public static Level fromInt(int i) {
+            switch (i) {
+                case 0:
+                    return ERROR;
+                case 1:
+                    return WARN;
+                case 2:
+                    return INFO;
+                case 3:
+                    return DEBUG;
+                case 4:
+                    return TRACE;
+                default:
+                    return DEFAULT;
+            }
+        }
+    }
+
+    @Getter private static Level loggerLevel;
+
+    private static void initLogger(@NonNull Level level, String fileName) {
+        if (level == Level.DISABLED) {
+            loggerLevel = level;
+            return;
+        }
+        loggerLevel = Level.fromInt(initInternal(level.getLevel(), fileName));
+    }
+
+    private static void initLogger(String fileName) {
+        initLogger(Level.DEFAULT, fileName);
+    }
+
+    private static void initLogger(@NonNull Level level) {
+        initLogger(level, null);
+    }
+
+    private static void initLogger() {
+        initLogger(Level.DEFAULT, null);
+    }
+
+    /**
+     * Initialize a logger if it wasn't initialized before - this method is meant to be used when
+     * there is no intention to replace an existing logger. The logger will filter all logs with a
+     * level lower than the given level. If given a <code>fileName</code> argument, will write the
+     * logs to files postfixed with <code>fileName</code>. If <code>fileName</code> isn't provided,
+     * the logs will be written to the console.
+     *
+     * @param level Set the logger level to one of <code>[DEFAULT, ERROR, WARN, INFO, DEBUG, TRACE]
+     *     </code>. If log level isn't provided, the logger will be configured with default
+     *     configuration decided by Glide core.
+     * @param fileName If provided, the target of the logs will be the file mentioned. Otherwise, logs
+     *     will be printed to the console.
+     */
+    public static void init(@NonNull Level level, String fileName) {
+        if (loggerLevel == null) {
+            initLogger(level, fileName);
+        }
+    }
+
+    /**
+     * Initialize a logger if it wasn't initialized before - this method is meant to be used when
+     * there is no intention to replace an existing logger. The logger will filter all logs with a
+     * level lower than the default level decided by Glide core. If given a <code>fileName</code>
+     * argument, will write the logs to files postfixed with <code>fileName</code>. If <code>fileName
+     * </code> isn't provided, the logs will be written to the console.
+     *
+     * @param fileName If provided, the target of the logs will be the file mentioned. Otherwise, logs
+     *     will be printed to the console.
+     */
+    public static void init(String fileName) {
+        init(Level.DEFAULT, fileName);
+    }
+
+    /**
+     * Initialize a logger if it wasn't initialized before - this method is meant to be used when
+     * there is no intention to replace an existing logger. The logger will filter all logs with a
+     * level lower than the default level decided by Glide core. The logs will be written to stdout.
+     */
+    public static void init() {
+        init(Level.DEFAULT, null);
+    }
+
+    /**
+     * Initialize a logger if it wasn't initialized before - this method is meant to be used when
+     * there is no intention to replace an existing logger. The logger will filter all logs with a
+     * level lower than the given level. The logs will be written to stdout.
+     *
+     * @param level Set the logger level to one of <code>[DEFAULT, ERROR, WARN, INFO, DEBUG, TRACE]
+     *     </code>. If log level isn't provided, the logger will be configured with default
+     *     configuration decided by Glide core.
+     */
+    public static void init(@NonNull Level level) {
+        init(level, null);
+    }
+
+    public static void log(
+            @NonNull Level level, @NonNull String logIdentifier, @NonNull String message) {
+        if (loggerLevel == null) {
+            initLogger(Level.DEFAULT, null);
+        }
+        if (!(level.getLevel() <= loggerLevel.getLevel())) {
+            return;
+        }
+        logInternal(level.getLevel(), logIdentifier, message);
+    }
+
+    /**
+     * Creates a new logger instance and configure it with the provided log level and file name.
+     *
+     * @param level Set the logger level to one of <code>[DEFAULT, ERROR, WARN, INFO, DEBUG, TRACE]
+     *     </code>. If log level isn't provided, the logger will be configured with default
+     *     configuration decided by Glide core.
+     * @param fileName If provided, the target of the logs will be the file mentioned. Otherwise, logs
+     *     will be printed to stdout.
+     */
+    public static void setLoggerConfig(@NonNull Level level, String fileName) {
+        initLogger(level, fileName);
+    }
+
+    /**
+     * Creates a new logger instance and configure it with the provided log level. The logs will be
+     * written to stdout.
+     *
+     * @param level Set the logger level to one of <code>[DEFAULT, ERROR, WARN, INFO, DEBUG, TRACE]
+     *     </code>. If log level isn't provided, the logger will be configured with default
+     *     configuration decided by Glide core.
+     */
+    public static void setLoggerConfig(@NonNull Level level) {
+        setLoggerConfig(level, null);
+    }
+
+    /**
+     * Creates a new logger instance and configure it with the provided file name and default log
+     * level. The logger will filter all logs with a level lower than the default level decided by the
+     * Glide core.
+     *
+     * @param fileName If provided, the target of the logs will be the file mentioned. Otherwise, logs
+     *     will be printed to stdout.
+     */
+    public static void setLoggerConfig(String fileName) {
+        setLoggerConfig(Level.DEFAULT, fileName);
+    }
+
+    /**
+     * Creates a new logger instance. The logger will filter all logs with a level lower than the
+     * default level decided by Glide core. The logs will be written to stdout.
+     */
+    public static void setLoggerConfig() {
+        setLoggerConfig(Level.DEFAULT, null);
+    }
+}

java/client/src/main/java/glide/connectors/handlers/CallbackDispatcher.java

@@ -1,6 +1,9 @@
 /** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.connectors.handlers;
 
+import static glide.api.logging.Logger.Level.ERROR;
+
+import glide.api.logging.Logger;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.ConnectionException;
 import glide.api.models.exceptions.ExecAbortException;
@@ -107,11 +110,14 @@ public void completeRequest(Response response) {
             }
             future.completeAsync(() -> response);
         } else {
-            // TODO: log an error thru logger.
             // probably a response was received after shutdown or `registerRequest` call was missing
-            System.err.printf(
-                    "Received a response for not registered callback id %d, request error = %s%n",
-                    callbackId, response.getRequestError());
+            Logger.log(
+                    ERROR,
+                    "callback dispatcher",
+                    "Received a response for not registered callback id "
+                            + callbackId
+                            + ", request error = "
+                            + response.getRequestError());
             distributeClosingException("Client is in an erroneous state and should close");
         }
     }

java/client/src/main/java/glide/connectors/handlers/ReadHandler.java

@@ -1,6 +1,9 @@
 /** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.connectors.handlers;
 
+import static glide.api.logging.Logger.Level.ERROR;
+
+import glide.api.logging.Logger;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import lombok.NonNull;
@@ -29,8 +32,7 @@ public void channelRead(@NonNull ChannelHandlerContext ctx, @NonNull Object msg)
     /** Handles uncaught exceptions from {@link #channelRead(ChannelHandlerContext, Object)}. */
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-        // TODO: log thru logger
-        System.out.printf("=== exceptionCaught %s %s %n", ctx, cause);
+        Logger.log(ERROR, "read handler", "=== exceptionCaught " + ctx + " " + cause);
 
         callbackDispatcher.distributeClosingException(
                 "An unhandled error while reading from UDS channel: " + cause);

java/client/src/main/java/glide/ffi/resolvers/LoggerResolver.java

@@ -0,0 +1,13 @@
+/** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
+package glide.ffi.resolvers;
+
+public class LoggerResolver {
+    // TODO: consider lazy loading the glide_rs library
+    static {
+        NativeUtils.loadGlideLib();
+    }
+
+    public static native int initInternal(int level, String fileName);
+
+    public static native void logInternal(int level, String logIdentifier, String message);
+}

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

@@ -1,6 +1,7 @@
 module glide.api {
     exports glide.api;
     exports glide.api.commands;
+    exports glide.api.logging;
     exports glide.api.models;
     exports glide.api.models.commands;
     exports glide.api.models.commands.stream;

java/client/src/test/java/glide/ExceptionHandlingTests.java

@@ -6,13 +6,15 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mockStatic;
 import static redis_request.RedisRequestOuterClass.RequestType.CustomCommand;
 import static response.ResponseOuterClass.RequestErrorType.Disconnect;
 import static response.ResponseOuterClass.RequestErrorType.ExecAbort;
 import static response.ResponseOuterClass.RequestErrorType.Timeout;
 import static response.ResponseOuterClass.RequestErrorType.Unspecified;
 
 import connection_request.ConnectionRequestOuterClass;
+import glide.api.logging.Logger;
 import glide.api.models.configuration.RedisClientConfiguration;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.ConnectionException;
@@ -35,26 +37,36 @@
 import java.util.stream.Stream;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.MockedStatic;
 import redis_request.RedisRequestOuterClass.RedisRequest;
 import response.ResponseOuterClass.RequestError;
 import response.ResponseOuterClass.RequestErrorType;
 import response.ResponseOuterClass.Response;
 
 public class ExceptionHandlingTests {
+    private MockedStatic<Logger> mockedLogger;
+
     @BeforeEach
     public void init() {
+        mockedLogger = mockStatic(Logger.class);
         var threadPoolResource = ThreadPoolResourceAllocator.getOrCreate(() -> null);
         if (threadPoolResource != null) {
             threadPoolResource.getEventLoopGroup().shutdownGracefully();
             ThreadPoolResourceAllocator.getOrCreate(() -> null);
         }
     }
 
+    @AfterEach
+    public void teardown() {
+        mockedLogger.close();
+    }
+
     /**
      * This test shows how exception handling works in the middle of future pipeline The client has
      * similar stuff, but it rethrows an exception.

java/client/src/test/java/glide/connection/ConnectionWithGlideMockTests.java

@@ -11,6 +11,7 @@
 import connection_request.ConnectionRequestOuterClass.ConnectionRequest;
 import connection_request.ConnectionRequestOuterClass.NodeAddress;
 import glide.api.RedisClient;
+import glide.api.logging.Logger;
 import glide.api.models.exceptions.ClosingException;
 import glide.connectors.handlers.CallbackDispatcher;
 import glide.connectors.handlers.ChannelHandler;
@@ -37,6 +38,7 @@ public class ConnectionWithGlideMockTests extends RustCoreLibMockTestBase {
     @BeforeEach
     @SneakyThrows
     public void createTestClient() {
+        Logger.setLoggerConfig(Logger.Level.DISABLED);
         channelHandler =
                 new ChannelHandler(
                         new CallbackDispatcher(), socketPath, Platform.getThreadPoolResourceSupplier().get());

java/integTest/build.gradle

@@ -134,7 +134,6 @@ tasks.withType(Test) {
         events "started", "skipped", "passed", "failed"
         showStandardStreams true
     }
-    jvmArgs "-Djava.library.path=${project.rootDir}/target/release"
     afterTest { desc, result ->
         logger.quiet "${desc.className}.${desc.name}: ${result.resultType} ${(result.getEndTime() - result.getStartTime())/1000}s"
     }