Java: added Client API for retrieving internal statistics (#2672)

Author: eifrah-aws

Makefile

@@ -19,8 +19,6 @@ java:
 	@cd java && ./gradlew :client:buildAllRelease
 
 java-lint:
-	@echo "$(GREEN)Running spotlessCheck$(RESET)"
-	@cd java && ./gradlew :spotlessCheck
 	@echo "$(GREEN)Running spotlessApply$(RESET)"
 	@cd java && ./gradlew :spotlessApply
 

java/client/src/main/java/glide/api/BaseClient.java

@@ -275,6 +275,7 @@
 import glide.connectors.resources.ThreadPoolResource;
 import glide.connectors.resources.ThreadPoolResourceAllocator;
 import glide.ffi.resolvers.GlideValueResolver;
+import glide.ffi.resolvers.StatisticsResolver;
 import glide.managers.BaseResponseResolver;
 import glide.managers.CommandManager;
 import glide.managers.ConnectionManager;
@@ -385,6 +386,15 @@ protected static <T extends BaseClient> CompletableFuture<T> createClient(
         }
     }
 
+    /**
+     * Return a statistics
+     *
+     * @return Return a {@link Map} that contains the statistics collected internally by GLIDE core
+     */
+    public Map<String, String> getStatistics() {
+        return (HashMap<String, String>) StatisticsResolver.getStatistics();
+    }
+
     /**
      * Return a next pubsub message if it is present.
      *

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

@@ -0,0 +1,12 @@
+/** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
+package glide.ffi.resolvers;
+
+public class StatisticsResolver {
+    // TODO: consider lazy loading the glide_rs library
+    static {
+        NativeUtils.loadGlideLib();
+    }
+
+    /** Return the internal statistics Map object */
+    public static native Object getStatistics();
+}

java/integTest/src/test/java/glide/SharedClientTests.java

@@ -47,8 +47,14 @@ public static void init() {
         clusterClient =
                 GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get();
-
         clients = List.of(Arguments.of(standaloneClient), Arguments.of(clusterClient));
+        assertTrue(!clusterClient.getStatistics().isEmpty());
+        assertEquals(
+                clusterClient.getStatistics().size(), 2); // we expect 2 items in the statistics map
+
+        assertTrue(!standaloneClient.getStatistics().isEmpty());
+        assertEquals(
+                standaloneClient.getStatistics().size(), 2); // we expect 2 items in the statistics map
     }
 
     @AfterAll

java/src/lib.rs

@@ -13,6 +13,9 @@ use glide_core::STREAM as TYPE_STREAM;
 use glide_core::STRING as TYPE_STRING;
 use glide_core::ZSET as TYPE_ZSET;
 
+// Telemetry required for getStatistics
+use glide_core::Telemetry;
+
 use bytes::Bytes;
 use jni::errors::Error as JniError;
 use jni::objects::{JByteArray, JClass, JObject, JObjectArray, JString};
@@ -22,6 +25,7 @@ use redis::Value;
 use std::sync::mpsc;
 
 mod errors;
+mod linked_hashmap;
 
 use errors::{handle_errors, handle_panics, FFIError};
 
@@ -580,6 +584,38 @@ pub extern "system" fn Java_glide_ffi_resolvers_ObjectTypeResolver_getTypeStream
     safe_create_jstring(env, TYPE_STREAM, "getTypeStreamConstant")
 }
 
+/// Returns a Java's `HashMap` representing the statistics collected for this process.
+///
+/// This function is meant to be invoked by Java using JNI.
+///
+/// * `env`    - The JNI environment.
+/// * `_class`  - The class object. Not used.
+#[no_mangle]
+pub extern "system" fn Java_glide_ffi_resolvers_StatisticsResolver_getStatistics<'local>(
+    mut env: JNIEnv<'local>,
+    _class: JClass<'local>,
+) -> JObject<'local> {
+    let Some(mut map) = linked_hashmap::new_linked_hashmap(&mut env) else {
+        return JObject::null();
+    };
+
+    linked_hashmap::put_strings(
+        &mut env,
+        &mut map,
+        "total_connections",
+        &format!("{}", Telemetry::total_connections()),
+    );
+
+    linked_hashmap::put_strings(
+        &mut env,
+        &mut map,
+        "total_clients",
+        &format!("{}", Telemetry::total_clients()),
+    );
+
+    map
+}
+
 /// Convert a Rust string to a Java String and handle errors.
 ///
 /// * `env`             - The JNI environment.

java/src/linked_hashmap.rs

@@ -0,0 +1,70 @@
+use crate::errors;
+use jni::{objects::JObject, JNIEnv};
+
+const LINKED_HASHMAP: &str = "java/util/LinkedHashMap";
+const LINKED_HASHMAP_PUT_SIG: &str = "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;";
+
+/// Create new Java `LinkedHashMap`
+pub fn new_linked_hashmap<'a>(env: &mut JNIEnv<'a>) -> Option<JObject<'a>> {
+    let hash_map = env.new_object(LINKED_HASHMAP, "()V", &[]);
+    let Ok(hash_map) = hash_map else {
+        errors::throw_java_exception(
+            env,
+            errors::ExceptionType::RuntimeException,
+            "Failed to allocated LinkedHashMap",
+        );
+        return None;
+    };
+    Some(hash_map)
+}
+
+/// Put `key` / `value` pair into the `map`, where both `key` and `value` are of type `&str`
+/// This method is provided for convenience
+pub fn put_strings<'a>(env: &mut JNIEnv<'a>, map: &mut JObject<'a>, key: &str, value: &str) {
+    let Some(key) = string_to_jobject(env, key) else {
+        return;
+    };
+    let Some(value) = string_to_jobject(env, value) else {
+        return;
+    };
+    put_objects(env, map, key, value)
+}
+
+/// Put `key` / `value` pair into the `map`, where both `key` and `value` are of type `JObject`
+pub fn put_objects<'a>(
+    env: &mut JNIEnv<'a>,
+    map: &mut JObject<'a>,
+    key: JObject<'a>,
+    value: JObject<'a>,
+) {
+    if env
+        .call_method(
+            &map,
+            "put",
+            LINKED_HASHMAP_PUT_SIG,
+            &[(&key).into(), (&value).into()],
+        )
+        .is_err()
+    {
+        errors::throw_java_exception(
+            env,
+            errors::ExceptionType::RuntimeException,
+            "Failed to call LinkedHashMap::put method",
+        );
+    }
+}
+
+/// Construct new Java string from Rust's `str`
+fn string_to_jobject<'a>(env: &mut JNIEnv<'a>, string: &str) -> Option<JObject<'a>> {
+    match env.new_string(string) {
+        Ok(obj) => Some(JObject::from(obj)),
+        Err(_) => {
+            errors::throw_java_exception(
+                env,
+                errors::ExceptionType::RuntimeException,
+                "Failed to create Java string",
+            );
+            None
+        }
+    }
+}