Bump com.hazelcast:hazelcast from 5.3.8 to 5.6.0 (#6802)

* Bump com.hazelcast:hazelcast from 5.3.8 to 5.6.0

Bumps [com.hazelcast:hazelcast](https://github.com/hazelcast/hazelcast) from 5.3.8 to 5.6.0.
- [Release notes](https://github.com/hazelcast/hazelcast/releases)
- [Commits](hazelcast/hazelcast@v5.3.8...v5.6.0)

---
updated-dependencies:
- dependency-name: com.hazelcast:hazelcast
  dependency-version: 5.6.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

* Use latest hazelcast in integration test only

It requires Java 17. Use the last version that supported Java 11 when compiling against Hazelcast for our instrumentation and running our cache TCK.
Also copies the TCK to the Hazelcast sample to run it against the latest Hazelcast version.

* Add missing junit platform launcher runtime dependency

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Tommy Ludwig <8924140+shakuzen@users.noreply.github.com>

Author: dependabot[bot]

gradle/libs.versions.toml

@@ -22,7 +22,6 @@ grpcKotlin = "1.4.3"
 guava = "32.1.3-jre"
 guice = "5.1.0"
 h2 = "2.4.240"
-hazelcast = "5.3.8"
 hdrhistogram = "2.2.2"
 hibernate = "5.6.15.Final"
 # 2.6.0 requires JDK 11
@@ -117,7 +116,8 @@ grpcKotlinStub = { module = "io.grpc:grpc-kotlin-stub", version.ref = "grpcKotli
 guava = { module = "com.google.guava:guava", version.ref = "guava" }
 guice = { module = "com.google.inject:guice", version.ref = "guice" }
 h2 = { module = "com.h2database:h2", version.ref = "h2" }
-hazelcast = { module = "com.hazelcast:hazelcast", version.ref = "hazelcast" }
+# latest hazelcast version to run integration tests with
+hazelcast = { module = "com.hazelcast:hazelcast", version = "5.6.0" }
 hdrhistogram = { module = "org.hdrhistogram:HdrHistogram", version.ref = "hdrhistogram" }
 hibernateEntitymanager = { module = "org.hibernate:hibernate-entitymanager", version.ref = "hibernate" }
 hsqldb = { module = "org.hsqldb:hsqldb", version.ref = "hsqldb" }

micrometer-core/build.gradle

@@ -114,7 +114,8 @@ dependencies {
     optionalApi libs.caffeine
     optionalApi libs.ehcache2
     optionalApi libs.javax.cacheApi
-    optionalApi libs.hazelcast
+    // hard-coded to last hazelcast version to support Java 11
+    optionalApi("com.hazelcast:hazelcast:5.3.8")
     optionalApi libs.hibernateEntitymanager
 
     // server runtime monitoring

micrometer-test/build.gradle

@@ -38,7 +38,8 @@ dependencies {
     testImplementation libs.ehcache2
     testImplementation libs.javax.cacheApi
     testImplementation libs.jakarta.jmsApi
-    testImplementation libs.hazelcast
+    // hard-coded to last hazelcast version to support Java 11
+    testImplementation("com.hazelcast:hazelcast:5.3.8")
     testImplementation libs.okhttp
     testImplementation libs.httpcomponents.client
     testImplementation libs.httpcomponents.async

samples/micrometer-samples-hazelcast/build.gradle

@@ -2,8 +2,28 @@ plugins {
     id 'java'
 }
 
+// Latest version of Hazelcast requires Java 17
+if (!javaLanguageVersion.canCompileOrRun(17)) {
+    project.tasks.configureEach { task -> task.enabled = false }
+}
+
 dependencies {
     implementation project(':micrometer-core')
     implementation libs.hazelcast
     implementation libs.logback12
+
+    testImplementation(platform(libs.junitBom))
+    testImplementation(project(":micrometer-test"))
+    testImplementation(libs.junitJupiter)
+    testRuntimeOnly(libs.junitPlatformLauncher)
+}
+
+java {
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+compileJava {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+    options.release = 17
 }

samples/micrometer-samples-hazelcast/src/test/java/io/micrometer/samples/hazelcast4/HazelcastCacheMetricsCompatibilityTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2017 VMware, Inc.
+ *
+ * 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
+ *
+ * https://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 io.micrometer.samples.hazelcast4;
+
+import com.hazelcast.config.Config;
+import com.hazelcast.core.Hazelcast;
+import com.hazelcast.map.IMap;
+import io.micrometer.core.Issue;
+import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
+import io.micrometer.core.instrument.binder.cache.CacheMeterBinderCompatibilityKit;
+import io.micrometer.core.instrument.binder.cache.HazelcastCacheMetrics;
+import org.jspecify.annotations.Nullable;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import static java.util.Collections.emptyList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Run the cache TCK against the latest version of Hazelcast.
+ */
+class HazelcastCacheMetricsCompatibilityTest extends CacheMeterBinderCompatibilityKit<Object> {
+
+    private Config config = new Config();
+
+    private IMap<String, String> cache;
+
+    @BeforeEach
+    @SuppressWarnings("unchecked")
+    void setup() {
+        this.cache = (IMap<String, String>) super.cache;
+    }
+
+    @Override
+    @SuppressWarnings("NullAway")
+    public void dereferenceCache() {
+        super.dereferenceCache();
+        this.cache.destroy();
+        this.cache = null;
+    }
+
+    @Disabled("This only demonstrates why we can't support miss count in Hazelcast.")
+    @Issue("#586")
+    @Test
+    void multiInstanceMissCount() {
+        IMap<String, String> cache2 = Hazelcast.newHazelcastInstance(config).getMap("mycache");
+
+        // Since each member owns 1/N (N being the number of members in the cluster)
+        // entries of a distributed map,
+        // we add two entries so we can deterministically say that each cache will "own"
+        // one entry.
+        cache.put("k1", "v");
+        cache.put("k2", "v");
+
+        cache.get("k1");
+        cache.get("k2");
+
+        // cache stats: hits = 1, gets = 2, puts = 2
+        // cache2 stats: hits = 1, gets = 0, puts = 0
+
+        assertThat(cache.getLocalMapStats().getHits()).isEqualTo(1);
+        assertThat(cache.getLocalMapStats().getGetOperationCount()).isEqualTo(2);
+        assertThat(cache2.getLocalMapStats().getHits()).isEqualTo(1);
+
+        // ... and this is why we can't calculate miss count in Hazelcast. sorry!
+    }
+
+    @AfterEach
+    void cleanup() {
+        Hazelcast.shutdownAll();
+    }
+
+    @Override
+    public IMap<String, String> createCache() {
+        return Hazelcast.newHazelcastInstance(config).getMap("mycache");
+    }
+
+    @Override
+    public CacheMeterBinder<Object> binder() {
+        return new HazelcastCacheMetrics(super.cache, emptyList());
+    }
+
+    @Override
+    public void put(String key, String value) {
+        this.cache.put(key, value);
+    }
+
+    @Override
+    public @Nullable String get(String key) {
+        return this.cache.get(key);
+    }
+
+}