Fixes #26555: Fix db_connections_total Prometheus metric always zero

The db.connections.total metric was registered as a Counter but
incrementDatabaseConnections() was never called, so it always reported 0.

Replace the dead Counter with a Gauge that reads from HikariCP's auto-registered
hikaricp.connections.active and hikaricp.connections.idle gauges. This mirrors
the same values as the Dropwizard database.pool.TotalConnections metric.

Changes:
- Replace Counter with Gauge backed by HikariCP pool metrics
- Remove unused incrementDatabaseConnections() method
- Add poolTotalConnections() helper that sums active + idle connections
- Add OpenMetadataMetricsTest with coverage for gauge behavior

Author: RajdeepKushwaha5

openmetadata-service/src/main/java/org/openmetadata/service/monitoring/OpenMetadataMetrics.java

@@ -4,6 +4,7 @@
 
 import io.micrometer.core.instrument.Counter;
 import io.micrometer.core.instrument.DistributionSummary;
+import io.micrometer.core.instrument.Gauge;
 import io.micrometer.core.instrument.MeterRegistry;
 import io.micrometer.core.instrument.Timer;
 import java.time.Duration;
@@ -19,7 +20,6 @@ public class OpenMetadataMetrics {
   private final DistributionSummary httpResponseSize;
 
   private final Timer jdbiQueryTimer;
-  private final Counter jdbiConnectionCounter;
   private final Counter jdbiErrorCounter;
 
   private final Counter entityCreatedCounter;
@@ -50,10 +50,9 @@ public OpenMetadataMetrics(MeterRegistry meterRegistry) {
             .sla(LATENCY_SLA_BUCKETS)
             .register(meterRegistry);
 
-    this.jdbiConnectionCounter =
-        Counter.builder("db.connections.total")
-            .description("Total database connections created")
-            .register(meterRegistry);
+    Gauge.builder("db.connections.total", () -> poolTotalConnections())
+        .description("Total connections in the database connection pool")
+        .register(meterRegistry);
 
     this.jdbiErrorCounter =
         Counter.builder("db.errors.total")
@@ -135,10 +134,6 @@ public void recordDatabaseQuery(String queryType, long durationMs) {
         .record(Duration.ofMillis(durationMs));
   }
 
-  public void incrementDatabaseConnections() {
-    jdbiConnectionCounter.increment();
-  }
-
   public void incrementDatabaseErrors(String errorType) {
     meterRegistry.counter("db.errors.total", "type", errorType).increment();
   }
@@ -200,12 +195,20 @@ public void recordAuthenticationFailure(String authType, String reason) {
   // Gauge registration methods
   public void registerGauge(
       String name, java.util.function.Supplier<Number> supplier, String description) {
-    io.micrometer.core.instrument.Gauge.builder(name, () -> supplier.get().doubleValue())
+    Gauge.builder(name, () -> supplier.get().doubleValue())
         .description(description)
         .register(meterRegistry);
   }
 
   public MeterRegistry getMeterRegistry() {
     return meterRegistry;
   }
+
+  private double poolTotalConnections() {
+    Gauge active = meterRegistry.find("hikaricp.connections.active").gauge();
+    Gauge idle = meterRegistry.find("hikaricp.connections.idle").gauge();
+    double activeVal = active != null ? active.value() : 0.0;
+    double idleVal = idle != null ? idle.value() : 0.0;
+    return activeVal + idleVal;
+  }
 }

openmetadata-service/src/test/java/org/openmetadata/service/monitoring/OpenMetadataMetricsTest.java

@@ -0,0 +1,54 @@
+package org.openmetadata.service.monitoring;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class OpenMetadataMetricsTest {
+
+  private SimpleMeterRegistry registry;
+
+  @BeforeEach
+  void setUp() {
+    registry = new SimpleMeterRegistry();
+  }
+
+  @Test
+  void dbConnectionsTotalReflectsHikariCPPoolSize() {
+    AtomicInteger activeConnections = new AtomicInteger(5);
+    AtomicInteger idleConnections = new AtomicInteger(15);
+
+    Gauge.builder("hikaricp.connections.active", activeConnections, AtomicInteger::doubleValue)
+        .register(registry);
+    Gauge.builder("hikaricp.connections.idle", idleConnections, AtomicInteger::doubleValue)
+        .register(registry);
+
+    new OpenMetadataMetrics(registry);
+
+    Gauge total = registry.find("db.connections.total").gauge();
+    assertNotNull(total, "db.connections.total gauge should be registered");
+    assertEquals(20.0, total.value(), 0.01, "Should equal active + idle");
+
+    activeConnections.set(10);
+    idleConnections.set(10);
+    assertEquals(20.0, total.value(), 0.01, "Should reflect updated pool state");
+
+    activeConnections.set(0);
+    idleConnections.set(0);
+    assertEquals(0.0, total.value(), 0.01, "Should be zero when pool is empty");
+  }
+
+  @Test
+  void dbConnectionsTotalReturnsZeroWithoutHikariCP() {
+    new OpenMetadataMetrics(registry);
+
+    Gauge total = registry.find("db.connections.total").gauge();
+    assertNotNull(total, "db.connections.total gauge should be registered");
+    assertEquals(0.0, total.value(), 0.01, "Should be zero when HikariCP metrics are absent");
+  }
+}