diff --git a/pom.xml b/pom.xml
index f818762c..64717ff3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -551,6 +551,33 @@
+
+
+ io.github.git-commit-id
+ git-commit-id-maven-plugin
+ 9.0.2
+
+
+ get-the-git-infos
+
+ revision
+
+ initialize
+
+
+
+ true
+ ${project.build.outputDirectory}/git.properties
+
+ ^git.branch$
+ ^git.commit.id.abbrev$
+ ^git.build.version$
+ ^git.build.time$
+
+ false
+ false
+
+
org.apache.maven.plugins
maven-resources-plugin
diff --git a/src/main/java/com/iemr/common/controller/health/HealthController.java b/src/main/java/com/iemr/common/controller/health/HealthController.java
new file mode 100644
index 00000000..795e370e
--- /dev/null
+++ b/src/main/java/com/iemr/common/controller/health/HealthController.java
@@ -0,0 +1,83 @@
+/*
+* AMRIT – Accessible Medical Records via Integrated Technology
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+
+package com.iemr.common.controller.health;
+
+import java.time.Instant;
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.iemr.common.service.health.HealthService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@RestController
+@RequestMapping("/health")
+@Tag(name = "Health Check", description = "APIs for checking infrastructure health status")
+public class HealthController {
+
+ private static final Logger logger = LoggerFactory.getLogger(HealthController.class);
+
+ private final HealthService healthService;
+
+ public HealthController(HealthService healthService) {
+ this.healthService = healthService;
+ }
+
+ @GetMapping
+ @Operation(summary = "Check infrastructure health",
+ description = "Returns the health status of MySQL, Redis, and other configured services")
+ @ApiResponses({
+ @ApiResponse(responseCode = "200", description = "Services are UP or DEGRADED (operational with warnings)"),
+ @ApiResponse(responseCode = "503", description = "One or more critical services are DOWN")
+ })
+ public ResponseEntity> checkHealth() {
+ logger.debug("Health check endpoint called");
+
+ try {
+ Map healthStatus = healthService.checkHealth();
+ String overallStatus = (String) healthStatus.get("status");
+
+ HttpStatus httpStatus = "DOWN".equals(overallStatus) ? HttpStatus.SERVICE_UNAVAILABLE : HttpStatus.OK;
+
+ logger.debug("Health check completed with status: {}", overallStatus);
+ return new ResponseEntity<>(healthStatus, httpStatus);
+
+ } catch (Exception e) {
+ logger.error("Unexpected error during health check", e);
+
+ Map errorResponse = Map.of(
+ "status", "DOWN",
+ "timestamp", Instant.now().toString()
+ );
+
+ return new ResponseEntity<>(errorResponse, HttpStatus.SERVICE_UNAVAILABLE);
+ }
+ }
+}
diff --git a/src/main/java/com/iemr/common/controller/version/VersionController.java b/src/main/java/com/iemr/common/controller/version/VersionController.java
index 705fccdc..db055f49 100644
--- a/src/main/java/com/iemr/common/controller/version/VersionController.java
+++ b/src/main/java/com/iemr/common/controller/version/VersionController.java
@@ -20,58 +20,59 @@
* along with this program. If not, see https://www.gnu.org/licenses/.
*/
package com.iemr.common.controller.version;
-
-import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
-import java.io.InputStreamReader;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Properties;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RestController;
-import com.iemr.common.utils.response.OutputResponse;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
import io.swagger.v3.oas.annotations.Operation;
-
@RestController
public class VersionController {
- private Logger logger = LoggerFactory.getLogger(this.getClass().getSimpleName());
+ private final Logger logger = LoggerFactory.getLogger(this.getClass().getSimpleName());
+
+ private static final String UNKNOWN_VALUE = "unknown";
- @Operation(summary = "Get version")
- @RequestMapping(value = "/version", method = { RequestMethod.GET })
- public String versionInformation() {
- OutputResponse output = new OutputResponse();
+ @Operation(summary = "Get version information")
+ @GetMapping(value = "/version", produces = MediaType.APPLICATION_JSON_VALUE)
+ public ResponseEntity> versionInformation() {
+ Map response = new LinkedHashMap<>();
try {
logger.info("version Controller Start");
- output.setResponse(readGitProperties());
+ Properties gitProperties = loadGitProperties();
+ response.put("buildTimestamp", gitProperties.getProperty("git.build.time", UNKNOWN_VALUE));
+ response.put("version", gitProperties.getProperty("git.build.version", UNKNOWN_VALUE));
+ response.put("branch", gitProperties.getProperty("git.branch", UNKNOWN_VALUE));
+ response.put("commitHash", gitProperties.getProperty("git.commit.id.abbrev", UNKNOWN_VALUE));
} catch (Exception e) {
- output.setError(e);
+ logger.error("Failed to load version information", e);
+ response.put("buildTimestamp", UNKNOWN_VALUE);
+ response.put("version", UNKNOWN_VALUE);
+ response.put("branch", UNKNOWN_VALUE);
+ response.put("commitHash", UNKNOWN_VALUE);
}
-
logger.info("version Controller End");
- return output.toString();
- }
-
- private String readGitProperties() throws Exception {
- ClassLoader classLoader = getClass().getClassLoader();
- InputStream inputStream = classLoader.getResourceAsStream("git.properties");
-
- return readFromInputStream(inputStream);
+ return ResponseEntity.ok(response);
}
- private String readFromInputStream(InputStream inputStream) throws IOException {
- StringBuilder resultStringBuilder = new StringBuilder();
- try (BufferedReader br = new BufferedReader(new InputStreamReader(inputStream))) {
- String line;
- while ((line = br.readLine()) != null) {
- resultStringBuilder.append(line).append("\n");
+ private Properties loadGitProperties() throws IOException {
+ Properties properties = new Properties();
+ try (InputStream input = getClass().getClassLoader()
+ .getResourceAsStream("git.properties")) {
+ if (input != null) {
+ properties.load(input);
}
}
- return resultStringBuilder.toString();
+ return properties;
}
}
diff --git a/src/main/java/com/iemr/common/service/health/HealthService.java b/src/main/java/com/iemr/common/service/health/HealthService.java
new file mode 100644
index 00000000..4215c2eb
--- /dev/null
+++ b/src/main/java/com/iemr/common/service/health/HealthService.java
@@ -0,0 +1,478 @@
+/*
+* AMRIT – Accessible Medical Records via Integrated Technology
+* Integrated EHR (Electronic Health Records) Solution
+*
+* Copyright (C) "Piramal Swasthya Management and Research Institute"
+*
+* This file is part of AMRIT.
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see https://www.gnu.org/licenses/.
+*/
+
+package com.iemr.common.service.health;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.time.Instant;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Supplier;
+import jakarta.annotation.PreDestroy;
+import javax.sql.DataSource;
+import com.zaxxer.hikari.HikariDataSource;
+import com.zaxxer.hikari.HikariPoolMXBean;
+import java.lang.management.ManagementFactory;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+@Service
+public class HealthService {
+
+ private static final Logger logger = LoggerFactory.getLogger(HealthService.class);
+
+ private static final String STATUS_KEY = "status";
+ private static final String STATUS_UP = "UP";
+ private static final String STATUS_DOWN = "DOWN";
+ private static final String STATUS_DEGRADED = "DEGRADED";
+ private static final String SEVERITY_KEY = "severity";
+ private static final String SEVERITY_OK = "OK";
+ private static final String SEVERITY_WARNING = "WARNING";
+ private static final String SEVERITY_CRITICAL = "CRITICAL";
+ private static final String ERROR_KEY = "error";
+ private static final String MESSAGE_KEY = "message";
+ private static final String RESPONSE_TIME_KEY = "responseTimeMs";
+ private static final long MYSQL_TIMEOUT_SECONDS = 3;
+ private static final long REDIS_TIMEOUT_SECONDS = 3;
+
+ private static final long ADVANCED_CHECKS_THROTTLE_SECONDS = 30;
+ private static final long RESPONSE_TIME_THRESHOLD_MS = 2000;
+
+ private static final String DIAGNOSTIC_LOCK_WAIT = "MYSQL_LOCK_WAIT";
+ private static final String DIAGNOSTIC_SLOW_QUERIES = "MYSQL_SLOW_QUERIES";
+ private static final String DIAGNOSTIC_POOL_EXHAUSTED = "MYSQL_POOL_EXHAUSTED";
+ private static final String DIAGNOSTIC_LOG_TEMPLATE = "Diagnostic: {}";
+
+ private final DataSource dataSource;
+ private final RedisTemplate redisTemplate;
+ private final ExecutorService executorService;
+
+ private volatile long lastAdvancedCheckTime = 0;
+ private volatile AdvancedCheckResult cachedAdvancedCheckResult = null;
+ private final ReentrantReadWriteLock advancedCheckLock = new ReentrantReadWriteLock();
+
+ private static final boolean ADVANCED_HEALTH_CHECKS_ENABLED = true;
+
+ public HealthService(DataSource dataSource,
+ @Autowired(required = false) RedisTemplate redisTemplate) {
+ this.dataSource = dataSource;
+ this.redisTemplate = redisTemplate;
+ this.executorService = Executors.newFixedThreadPool(2);
+ }
+
+ @PreDestroy
+ public void shutdown() {
+ if (executorService != null && !executorService.isShutdown()) {
+ try {
+ executorService.shutdown();
+ if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
+ executorService.shutdownNow();
+ logger.warn("ExecutorService did not terminate gracefully");
+ }
+ } catch (InterruptedException e) {
+ executorService.shutdownNow();
+ Thread.currentThread().interrupt();
+ logger.warn("ExecutorService shutdown interrupted", e);
+ }
+ }
+ }
+
+ public Map checkHealth() {
+ Map response = new LinkedHashMap<>();
+ response.put("timestamp", Instant.now().toString());
+
+ Map mysqlStatus = new ConcurrentHashMap<>();
+ Map redisStatus = new ConcurrentHashMap<>();
+
+ Future mysqlFuture = executorService.submit(
+ () -> performHealthCheck("MySQL", mysqlStatus, this::checkMySQLHealthSync));
+ Future redisFuture = executorService.submit(
+ () -> performHealthCheck("Redis", redisStatus, this::checkRedisHealthSync));
+
+ long maxTimeout = Math.max(MYSQL_TIMEOUT_SECONDS, REDIS_TIMEOUT_SECONDS) + 1;
+ long deadlineNs = System.nanoTime() + TimeUnit.SECONDS.toNanos(maxTimeout);
+ try {
+ mysqlFuture.get(maxTimeout, TimeUnit.SECONDS);
+ long remainingNs = deadlineNs - System.nanoTime();
+ if (remainingNs > 0) {
+ redisFuture.get(remainingNs, TimeUnit.NANOSECONDS);
+ } else {
+ redisFuture.cancel(true);
+ }
+ } catch (TimeoutException e) {
+ logger.warn("Health check aggregate timeout after {} seconds", maxTimeout);
+ mysqlFuture.cancel(true);
+ redisFuture.cancel(true);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ logger.warn("Health check was interrupted");
+ mysqlFuture.cancel(true);
+ redisFuture.cancel(true);
+ } catch (Exception e) {
+ logger.warn("Health check execution error: {}", e.getMessage());
+ }
+
+ ensurePopulated(mysqlStatus, "MySQL");
+ ensurePopulated(redisStatus, "Redis");
+
+ Map> components = new LinkedHashMap<>();
+ components.put("mysql", mysqlStatus);
+ components.put("redis", redisStatus);
+
+ response.put("components", components);
+
+ String overallStatus = computeOverallStatus(components);
+ response.put(STATUS_KEY, overallStatus);
+
+ return response;
+ }
+
+ private void ensurePopulated(Map status, String componentName) {
+ if (!status.containsKey(STATUS_KEY)) {
+ status.put(STATUS_KEY, STATUS_DOWN);
+ status.put(SEVERITY_KEY, SEVERITY_CRITICAL);
+ status.put(ERROR_KEY, componentName + " health check did not complete in time");
+ }
+ }
+
+ private HealthCheckResult checkMySQLHealthSync() {
+ try (Connection connection = dataSource.getConnection();
+ PreparedStatement stmt = connection.prepareStatement("SELECT 1 as health_check")) {
+
+ stmt.setQueryTimeout((int) MYSQL_TIMEOUT_SECONDS);
+
+ try (ResultSet rs = stmt.executeQuery()) {
+ if (rs.next()) {
+ boolean isDegraded = performAdvancedMySQLChecksWithThrottle(connection);
+ return new HealthCheckResult(true, null, isDegraded);
+ }
+ }
+
+ return new HealthCheckResult(false, "No result from health check query", false);
+
+ } catch (Exception e) {
+ logger.warn("MySQL health check failed: {}", e.getMessage(), e);
+ return new HealthCheckResult(false, "MySQL connection failed", false);
+ }
+ }
+
+ private HealthCheckResult checkRedisHealthSync() {
+ if (redisTemplate == null) {
+ return new HealthCheckResult(true, "Redis not configured — skipped", false);
+ }
+
+ try {
+ String pong = redisTemplate.execute((org.springframework.data.redis.core.RedisCallback) (connection) -> connection.ping());
+
+ if ("PONG".equals(pong)) {
+ return new HealthCheckResult(true, null, false);
+ }
+
+ return new HealthCheckResult(false, "Redis PING failed", false);
+
+ } catch (Exception e) {
+ logger.warn("Redis health check failed: {}", e.getMessage(), e);
+ return new HealthCheckResult(false, "Redis connection failed", false);
+ }
+ }
+
+ private Map performHealthCheck(String componentName,
+ Map status,
+ Supplier checker) {
+ long startTime = System.currentTimeMillis();
+
+ try {
+ HealthCheckResult result = checker.get();
+ long responseTime = System.currentTimeMillis() - startTime;
+
+ String componentStatus;
+ if (!result.isHealthy) {
+ componentStatus = STATUS_DOWN;
+ } else if (result.isDegraded) {
+ componentStatus = STATUS_DEGRADED;
+ } else {
+ componentStatus = STATUS_UP;
+ }
+ status.put(STATUS_KEY, componentStatus);
+
+ status.put(RESPONSE_TIME_KEY, responseTime);
+
+ String severity = determineSeverity(result.isHealthy, responseTime, result.isDegraded);
+ status.put(SEVERITY_KEY, severity);
+
+ if (result.error != null) {
+ String fieldKey = result.isHealthy ? MESSAGE_KEY : ERROR_KEY;
+ status.put(fieldKey, result.error);
+ }
+
+ return status;
+
+ } catch (Exception e) {
+ long responseTime = System.currentTimeMillis() - startTime;
+ logger.error("{} health check failed with exception: {}", componentName, e.getMessage(), e);
+
+ status.put(STATUS_KEY, STATUS_DOWN);
+ status.put(RESPONSE_TIME_KEY, responseTime);
+ status.put(SEVERITY_KEY, SEVERITY_CRITICAL);
+ status.put(ERROR_KEY, "Health check failed with an unexpected error");
+
+ return status;
+ }
+ }
+
+ private String determineSeverity(boolean isHealthy, long responseTimeMs, boolean isDegraded) {
+ if (!isHealthy) {
+ return SEVERITY_CRITICAL;
+ }
+
+ if (isDegraded) {
+ return SEVERITY_WARNING;
+ }
+
+ if (responseTimeMs > RESPONSE_TIME_THRESHOLD_MS) {
+ return SEVERITY_WARNING;
+ }
+
+ return SEVERITY_OK;
+ }
+
+ private String computeOverallStatus(Map> components) {
+ boolean hasCritical = false;
+ boolean hasDegraded = false;
+
+ for (Map componentStatus : components.values()) {
+ String status = (String) componentStatus.get(STATUS_KEY);
+ String severity = (String) componentStatus.get(SEVERITY_KEY);
+
+ if (STATUS_DOWN.equals(status) || SEVERITY_CRITICAL.equals(severity)) {
+ hasCritical = true;
+ }
+
+ if (STATUS_DEGRADED.equals(status)) {
+ hasDegraded = true;
+ }
+
+ if (SEVERITY_WARNING.equals(severity)) {
+ hasDegraded = true;
+ }
+ }
+
+ if (hasCritical) {
+ return STATUS_DOWN;
+ }
+
+ if (hasDegraded) {
+ return STATUS_DEGRADED;
+ }
+
+ return STATUS_UP;
+ }
+
+ private boolean performAdvancedMySQLChecksWithThrottle(Connection connection) {
+ if (!ADVANCED_HEALTH_CHECKS_ENABLED) {
+ return false;
+ }
+
+ long currentTime = System.currentTimeMillis();
+
+ advancedCheckLock.readLock().lock();
+ try {
+ if (cachedAdvancedCheckResult != null &&
+ (currentTime - lastAdvancedCheckTime) < ADVANCED_CHECKS_THROTTLE_SECONDS * 1000) {
+ return cachedAdvancedCheckResult.isDegraded;
+ }
+ } finally {
+ advancedCheckLock.readLock().unlock();
+ }
+
+ advancedCheckLock.writeLock().lock();
+ try {
+ if (cachedAdvancedCheckResult != null &&
+ (currentTime - lastAdvancedCheckTime) < ADVANCED_CHECKS_THROTTLE_SECONDS * 1000) {
+ return cachedAdvancedCheckResult.isDegraded;
+ }
+
+ AdvancedCheckResult result = performAdvancedMySQLChecks(connection);
+
+ lastAdvancedCheckTime = currentTime;
+ cachedAdvancedCheckResult = result;
+
+ return result.isDegraded;
+ } finally {
+ advancedCheckLock.writeLock().unlock();
+ }
+ }
+
+ private AdvancedCheckResult performAdvancedMySQLChecks(Connection connection) {
+ try {
+ boolean hasIssues = false;
+
+ if (hasLockWaits(connection)) {
+ logger.warn(DIAGNOSTIC_LOG_TEMPLATE, DIAGNOSTIC_LOCK_WAIT);
+ hasIssues = true;
+ }
+
+ if (hasSlowQueries(connection)) {
+ logger.warn(DIAGNOSTIC_LOG_TEMPLATE, DIAGNOSTIC_SLOW_QUERIES);
+ hasIssues = true;
+ }
+
+ if (hasConnectionPoolExhaustion()) {
+ logger.warn(DIAGNOSTIC_LOG_TEMPLATE, DIAGNOSTIC_POOL_EXHAUSTED);
+ hasIssues = true;
+ }
+
+ return new AdvancedCheckResult(hasIssues);
+ } catch (Exception e) {
+ logger.debug("Advanced MySQL checks encountered exception, marking degraded");
+ return new AdvancedCheckResult(true);
+ }
+ }
+
+ private boolean hasLockWaits(Connection connection) {
+ try (PreparedStatement stmt = connection.prepareStatement(
+ "SELECT COUNT(*) FROM INFORMATION_SCHEMA.PROCESSLIST " +
+ "WHERE (state = 'Waiting for table metadata lock' " +
+ " OR state = 'Waiting for row lock' " +
+ " OR state = 'Waiting for lock') " +
+ "AND user = SUBSTRING_INDEX(USER(), '@', 1)")) {
+ stmt.setQueryTimeout(2);
+ try (ResultSet rs = stmt.executeQuery()) {
+ if (rs.next()) {
+ int lockCount = rs.getInt(1);
+ return lockCount > 0;
+ }
+ }
+ } catch (Exception e) {
+ logger.debug("Could not check for lock waits");
+ }
+ return false;
+ }
+
+
+
+ private boolean hasSlowQueries(Connection connection) {
+ try (PreparedStatement stmt = connection.prepareStatement(
+ "SELECT COUNT(*) FROM INFORMATION_SCHEMA.PROCESSLIST " +
+ "WHERE command != 'Sleep' AND time > ? AND user NOT IN ('event_scheduler', 'system user')")) {
+ stmt.setQueryTimeout(2);
+ stmt.setInt(1, 10);
+ try (ResultSet rs = stmt.executeQuery()) {
+ if (rs.next()) {
+ int slowQueryCount = rs.getInt(1);
+ return slowQueryCount > 3;
+ }
+ }
+ } catch (Exception e) {
+ logger.debug("Could not check for slow queries");
+ }
+ return false;
+ }
+
+ private boolean hasConnectionPoolExhaustion() {
+ if (dataSource instanceof HikariDataSource hikariDataSource) {
+ try {
+ HikariPoolMXBean poolMXBean = hikariDataSource.getHikariPoolMXBean();
+
+ if (poolMXBean != null) {
+ int activeConnections = poolMXBean.getActiveConnections();
+ int maxPoolSize = hikariDataSource.getMaximumPoolSize();
+
+ int threshold = (int) (maxPoolSize * 0.8);
+ return activeConnections > threshold;
+ }
+ } catch (Exception e) {
+ logger.debug("Could not retrieve HikariCP pool metrics");
+ }
+ }
+
+ return checkPoolMetricsViaJMX();
+ }
+
+ private boolean checkPoolMetricsViaJMX() {
+ try {
+ MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
+ ObjectName objectName = new ObjectName("com.zaxxer.hikari:type=Pool (*)");
+ var mBeans = mBeanServer.queryMBeans(objectName, null);
+
+ for (var mBean : mBeans) {
+ if (evaluatePoolMetrics(mBeanServer, mBean.getObjectName())) {
+ return true;
+ }
+ }
+ } catch (Exception e) {
+ logger.debug("Could not access HikariCP pool metrics via JMX");
+ }
+
+ logger.debug("Pool exhaustion check disabled: HikariCP metrics unavailable");
+ return false;
+ }
+
+ private boolean evaluatePoolMetrics(MBeanServer mBeanServer, ObjectName objectName) {
+ try {
+ Integer activeConnections = (Integer) mBeanServer.getAttribute(objectName, "ActiveConnections");
+ Integer maximumPoolSize = (Integer) mBeanServer.getAttribute(objectName, "MaximumPoolSize");
+
+ if (activeConnections != null && maximumPoolSize != null) {
+ int threshold = (int) (maximumPoolSize * 0.8);
+ return activeConnections > threshold;
+ }
+ } catch (Exception e) {
+ // Continue to next MBean
+ }
+ return false;
+ }
+
+ private static class AdvancedCheckResult {
+ final boolean isDegraded;
+
+ AdvancedCheckResult(boolean isDegraded) {
+ this.isDegraded = isDegraded;
+ }
+ }
+
+ private static class HealthCheckResult {
+ final boolean isHealthy;
+ final String error;
+ final boolean isDegraded;
+
+ HealthCheckResult(boolean isHealthy, String error, boolean isDegraded) {
+ this.isHealthy = isHealthy;
+ this.error = error;
+ this.isDegraded = isDegraded;
+ }
+ }
+}
diff --git a/src/main/java/com/iemr/common/utils/JwtUserIdValidationFilter.java b/src/main/java/com/iemr/common/utils/JwtUserIdValidationFilter.java
index 81d79221..364aa12d 100644
--- a/src/main/java/com/iemr/common/utils/JwtUserIdValidationFilter.java
+++ b/src/main/java/com/iemr/common/utils/JwtUserIdValidationFilter.java
@@ -251,7 +251,9 @@ private boolean shouldSkipAuthentication(String path, String contextPath) {
|| path.startsWith(contextPath + "/user/userLogout")
|| path.startsWith(contextPath + "/user/validateSecurityQuestionAndAnswer")
|| path.startsWith(contextPath + "/user/logOutUserFromConcurrentSession")
- || path.startsWith(contextPath + "/user/refreshToken");
+ || path.startsWith(contextPath + "/user/refreshToken")
+ || path.equals(contextPath + "/health")
+ || path.equals(contextPath + "/version");
}
private String getJwtTokenFromCookies(HttpServletRequest request) {