Integration test

Author: ggivo

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>io.lettuce</groupId>
     <artifactId>lettuce-core</artifactId>
-    <version>6.7.0.BUILD-OBSERVABILITY-SNAPSHOT</version>
+    <version>6.7.0.BUILD-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>Lettuce</name>
@@ -90,14 +90,16 @@
   </scm>
 
     <distributionManagement>
-        <repository>
-            <id>github</id>
-            <url>https://maven.pkg.github.com/ggivo/lettuce</url>
-        </repository>
         <snapshotRepository>
-            <id>github</id>
-            <url>https://maven.pkg.github.com/ggivo/lettuce</url>
+            <id>ossrh</id>
+            <name>Sonatype Nexus Snapshots</name>
+            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
         </snapshotRepository>
+        <repository>
+            <id>ossrh</id>
+            <name>Nexus Release Repository</name>
+            <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+        </repository>
     </distributionManagement>
 
     <dependencyManagement>

src/main/java/io/lettuce/core/protocol/ConnectionWatchdog.java

@@ -165,8 +165,8 @@ public int getAttempts() {
             return attempts.get();
         }
 
-        public void increment() {
-            attempts.incrementAndGet();
+        public int incrementAndGet() {
+           return attempts.incrementAndGet();
         }
 
     }
@@ -341,8 +341,7 @@ public void scheduleReconnect() {
         if ((channel == null || !channel.isActive()) && reconnectSchedulerSync.compareAndSet(false, true)) {
             // attempts++;
             // final int attempt = attempts;
-            attempts.increment();
-            final int attempt = attempts.getAttempts();
+            final int attempt = attempts.incrementAndGet();
             connectionMonitor.incrementReconnectionAttempts(epid);
 
             Duration delay = reconnectDelay.createDelay(attempt);

src/test/java/io/lettuce/core/ConnectionMonitorIntegrationTests.java

@@ -0,0 +1,61 @@
+package io.lettuce.core;
+
+import io.lettuce.core.api.StatefulRedisConnection;
+import io.lettuce.core.api.sync.RedisCommands;
+import io.lettuce.core.metrics.MicrometerConnectionMonitor;
+import io.lettuce.core.metrics.MicrometerOptions;
+import io.lettuce.core.resource.ClientResources;
+import io.lettuce.test.LettuceExtension;
+import io.lettuce.test.Wait;
+import io.lettuce.test.resource.TestClientResources;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+
+import static io.lettuce.TestTags.INTEGRATION_TEST;
+import static io.lettuce.core.metrics.MicrometerConnectionMonitor.METRIC_CONNECTION_INACTIVE_TIME;
+import static io.lettuce.core.metrics.MicrometerConnectionMonitor.METRIC_CONNECTION_RECONNECTION_ATTEMPTS;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author Mark Paluch
+ */
+@Tag(INTEGRATION_TEST)
+@ExtendWith(LettuceExtension.class)
+class ConnectionMonitorIntegrationTests extends TestSupport {
+
+    private final MeterRegistry meterRegistry = new SimpleMeterRegistry();
+
+    private final ClientResources clientResources = TestClientResources.get();
+
+    @Test
+    void metricConnectionInactiveTime() throws InterruptedException {
+
+        MicrometerOptions options = MicrometerOptions.create();
+        MicrometerConnectionMonitor monitor = new MicrometerConnectionMonitor(meterRegistry, options);
+        ClientResources resources = clientResources.mutate().connectionMonitor(monitor).build();
+        RedisClient client = RedisClient.create(resources, RedisURI.Builder.redis(host, port).build());
+
+        try ( StatefulRedisConnection<String, String> connection = client.connect()) {
+            RedisCommands<String, String> redis = connection.sync();
+
+            // Force disconnection
+            redis.quit();
+            Wait.untilTrue(() -> !connection.isOpen()).during(Duration.ofSeconds(1)).waitOrTimeout();
+
+            // Wait for successful reconnection
+            Wait.untilTrue(() -> connection.isOpen()).during(Duration.ofSeconds(1)).waitOrTimeout();
+
+            // At least one reconnect attempt
+            assertThat(meterRegistry.find(METRIC_CONNECTION_RECONNECTION_ATTEMPTS).counter().count()).isGreaterThanOrEqualTo(1);
+            assertThat(meterRegistry.find(METRIC_CONNECTION_INACTIVE_TIME).timers()).isNotEmpty();
+            assertThat(meterRegistry.find(METRIC_CONNECTION_INACTIVE_TIME).timer().count()).isEqualTo(1);
+            assertThat(meterRegistry.find(METRIC_CONNECTION_INACTIVE_TIME).timer().totalTime(TimeUnit.NANOSECONDS)).isGreaterThan(0);
+        }
+    }
+}