diff --git a/pom.xml b/pom.xml
index 0479b05..2c7ac4a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -456,6 +456,32 @@
+
+ io.github.git-commit-id
+ git-commit-id-maven-plugin
+ 7.0.0
+
+
+ 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.springframework.boot
spring-boot-maven-plugin
diff --git a/src/main/java/com/wipro/fhir/controller/health/HealthController.java b/src/main/java/com/wipro/fhir/controller/health/HealthController.java
new file mode 100644
index 0000000..b0aaf77
--- /dev/null
+++ b/src/main/java/com/wipro/fhir/controller/health/HealthController.java
@@ -0,0 +1,62 @@
+package com.wipro.fhir.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.wipro.fhir.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.info("Health check endpoint called");
+
+ try {
+ Map healthStatus = healthService.checkHealth();
+ String overallStatus = (String) healthStatus.get("status");
+
+ // Return 503 only if DOWN; 200 for both UP and DEGRADED (DEGRADED = operational with warnings)
+ 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/wipro/fhir/controller/version/VersionController.java b/src/main/java/com/wipro/fhir/controller/version/VersionController.java
new file mode 100644
index 0000000..7a5af18
--- /dev/null
+++ b/src/main/java/com/wipro/fhir/controller/version/VersionController.java
@@ -0,0 +1,79 @@
+/*
+* 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.wipro.fhir.controller.version;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+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 final Logger logger = LoggerFactory.getLogger(this.getClass().getSimpleName());
+
+ private static final String UNKNOWN_VALUE = "unknown";
+
+ @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");
+ 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) {
+ 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 ResponseEntity.ok(response);
+ }
+
+ private Properties loadGitProperties() throws IOException {
+ Properties properties = new Properties();
+ try (InputStream input = getClass().getClassLoader()
+ .getResourceAsStream("git.properties")) {
+ if (input != null) {
+ properties.load(input);
+ }
+ }
+ return properties;
+ }
+}
diff --git a/src/main/java/com/wipro/fhir/service/health/HealthService.java b/src/main/java/com/wipro/fhir/service/health/HealthService.java
new file mode 100644
index 0000000..4072bb5
--- /dev/null
+++ b/src/main/java/com/wipro/fhir/service/health/HealthService.java
@@ -0,0 +1,573 @@
+/*
+* 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.wipro.fhir.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.concurrent.ExecutionException;
+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);
+
+ // Status constants
+ 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";
+
+ // Severity levels and keys
+ 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";
+
+ // Response keys
+ private static final String ERROR_KEY = "error";
+ private static final String MESSAGE_KEY = "message";
+ private static final String RESPONSE_TIME_KEY = "responseTimeMs";
+
+ // Component names
+ private static final String MYSQL_COMPONENT = "MySQL";
+ private static final String REDIS_COMPONENT = "Redis";
+
+ // Timeouts (in seconds)
+ private static final long MYSQL_TIMEOUT_SECONDS = 3;
+ private static final long REDIS_TIMEOUT_SECONDS = 3;
+ private static final long ADVANCED_CHECKS_TIMEOUT_MS = 500L;
+ private static final long ADVANCED_CHECKS_THROTTLE_SECONDS = 30;
+ private static final long RESPONSE_TIME_THRESHOLD_MS = 2000;
+
+ // Diagnostic event codes for concise logging
+ 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 final ExecutorService advancedCheckExecutor;
+ private volatile long lastAdvancedCheckTime = 0;
+ private volatile AdvancedCheckResult cachedAdvancedCheckResult = null;
+ private final ReentrantReadWriteLock advancedCheckLock = new ReentrantReadWriteLock();
+
+ // Deadlock check resilience - disable after first permission error
+ private volatile boolean deadlockCheckDisabled = false;
+
+ // Advanced checks always enabled
+ 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(6);
+ this.advancedCheckExecutor = Executors.newSingleThreadExecutor(r -> {
+ Thread t = new Thread(r, "health-advanced-check");
+ t.setDaemon(true);
+ return t;
+ });
+ }
+
+ @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);
+ }
+ }
+ if (advancedCheckExecutor != null && !advancedCheckExecutor.isShutdown()) {
+ advancedCheckExecutor.shutdownNow();
+ }
+ }
+
+ public Map checkHealth() {
+ Map response = new LinkedHashMap<>();
+ response.put("timestamp", Instant.now().toString());
+
+ Map mysqlStatus = new ConcurrentHashMap<>();
+ Map redisStatus = new ConcurrentHashMap<>();
+
+ if (!executorService.isShutdown()) {
+ performHealthChecks(mysqlStatus, redisStatus);
+ }
+
+ ensurePopulated(mysqlStatus, MYSQL_COMPONENT);
+ ensurePopulated(redisStatus, REDIS_COMPONENT);
+
+ Map> components = new LinkedHashMap<>();
+ components.put("mysql", mysqlStatus);
+ components.put("redis", redisStatus);
+
+ response.put("components", components);
+ response.put(STATUS_KEY, computeOverallStatus(components));
+
+ return response;
+ }
+
+ private void performHealthChecks(Map mysqlStatus, Map redisStatus) {
+ Future mysqlFuture = executorService.submit(
+ () -> performHealthCheck(MYSQL_COMPONENT, mysqlStatus, this::checkMySQLHealthSync));
+ Future redisFuture = executorService.submit(
+ () -> performHealthCheck(REDIS_COMPONENT, redisStatus, this::checkRedisHealthSync));
+
+ try {
+ awaitHealthChecks(mysqlFuture, redisFuture);
+ } catch (TimeoutException e) {
+ logger.warn("Health check aggregate timeout after {} seconds", getMaxTimeout());
+ 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());
+ mysqlFuture.cancel(true);
+ redisFuture.cancel(true);
+ }
+ }
+
+ private void awaitHealthChecks(Future mysqlFuture, Future redisFuture) throws TimeoutException, InterruptedException, ExecutionException {
+ long maxTimeout = getMaxTimeout();
+ long deadlineNs = System.nanoTime() + TimeUnit.SECONDS.toNanos(maxTimeout);
+
+ mysqlFuture.get(maxTimeout, TimeUnit.SECONDS);
+ long remainingNs = deadlineNs - System.nanoTime();
+
+ if (remainingNs > 0) {
+ redisFuture.get(remainingNs, TimeUnit.NANOSECONDS);
+ } else {
+ redisFuture.cancel(true);
+ }
+ }
+
+ private long getMaxTimeout() {
+ return Math.max(MYSQL_TIMEOUT_SECONDS, REDIS_TIMEOUT_SECONDS) + 1;
+ }
+
+
+ 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()) {
+ // Basic health check passed, now run advanced checks with throttling
+ boolean isDegraded = performAdvancedMySQLChecksWithThrottle();
+ 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;
+
+ // Determine status: DOWN (unhealthy), DEGRADED (healthy but with issues), or UP
+ String componentStatus;
+ if (!result.isHealthy) {
+ componentStatus = STATUS_DOWN;
+ } else if (result.isDegraded) {
+ componentStatus = STATUS_DEGRADED;
+ } else {
+ componentStatus = STATUS_UP;
+ }
+ status.put(STATUS_KEY, componentStatus);
+
+ // Set response time
+ status.put(RESPONSE_TIME_KEY, responseTime);
+
+ // Determine severity based on health, response time, and degradation flags
+ String severity = determineSeverity(result.isHealthy, responseTime, result.isDegraded);
+ status.put(SEVERITY_KEY, severity);
+
+ // Include message or error based on health status
+ if (result.error != null) {
+ // Use MESSAGE_KEY for informational messages when healthy
+ // Use ERROR_KEY for actual error messages when unhealthy
+ 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;
+ }
+
+ // Internal advanced health checks for MySQL - do not expose details in responses
+ private boolean performAdvancedMySQLChecksWithThrottle() {
+ if (!ADVANCED_HEALTH_CHECKS_ENABLED) {
+ return false; // Advanced checks disabled
+ }
+
+ long currentTime = System.currentTimeMillis();
+
+ // Check throttle window - use read lock first for fast path
+ advancedCheckLock.readLock().lock();
+ try {
+ if (cachedAdvancedCheckResult != null &&
+ (currentTime - lastAdvancedCheckTime) < ADVANCED_CHECKS_THROTTLE_SECONDS * 1000) {
+ // Return cached result - within throttle window
+ return cachedAdvancedCheckResult.isDegraded;
+ }
+ } finally {
+ advancedCheckLock.readLock().unlock();
+ }
+
+ // Outside throttle window - acquire write lock and run checks
+ advancedCheckLock.writeLock().lock();
+ try {
+ // Double-check after acquiring write lock
+ if (cachedAdvancedCheckResult != null &&
+ (currentTime - lastAdvancedCheckTime) < ADVANCED_CHECKS_THROTTLE_SECONDS * 1000) {
+ return cachedAdvancedCheckResult.isDegraded;
+ }
+
+ AdvancedCheckResult result;
+ Future future =
+ advancedCheckExecutor.submit(this::performAdvancedMySQLChecks);
+ try {
+ result = future.get(ADVANCED_CHECKS_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+ } catch (TimeoutException ex) {
+ logger.debug("Advanced MySQL checks timed out after {}ms", ADVANCED_CHECKS_TIMEOUT_MS);
+ future.cancel(true);
+ result = new AdvancedCheckResult(true); // treat timeout as degraded
+ } catch (ExecutionException ex) {
+ future.cancel(true);
+ // Check if the cause is an InterruptedException
+ if (ex.getCause() instanceof InterruptedException) {
+ Thread.currentThread().interrupt();
+ logger.debug("Advanced MySQL checks were interrupted");
+ } else {
+ logger.debug("Advanced MySQL checks failed: {}", ex.getCause() != null ? ex.getCause().getMessage() : ex.getMessage());
+ }
+ result = new AdvancedCheckResult(true);
+ } catch (InterruptedException ex) {
+ Thread.currentThread().interrupt();
+ logger.debug("Advanced MySQL checks interrupted");
+ future.cancel(true);
+ result = new AdvancedCheckResult(true);
+ } catch (Exception ex) {
+ logger.debug("Advanced MySQL checks failed: {}", ex.getMessage());
+ future.cancel(true);
+ result = new AdvancedCheckResult(true);
+ }
+
+ // Cache the result
+ lastAdvancedCheckTime = currentTime;
+ cachedAdvancedCheckResult = result;
+
+ return result.isDegraded;
+ } finally {
+ advancedCheckLock.writeLock().unlock();
+ }
+ }
+
+ private AdvancedCheckResult performAdvancedMySQLChecks() {
+ try (Connection connection = dataSource.getConnection()) {
+ return performAdvancedCheckLogic(connection);
+ } catch (Exception e) {
+ logger.debug("Advanced MySQL checks could not obtain connection: {}", e.getMessage());
+ return new AdvancedCheckResult(true);
+ }
+ }
+
+ private AdvancedCheckResult performAdvancedCheckLogic(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 = SUBSTRING_INDEX(USER(), '@', 1)")) {
+ stmt.setQueryTimeout(2);
+ stmt.setInt(1, 10); // Queries running longer than 10 seconds
+ try (ResultSet rs = stmt.executeQuery()) {
+ if (rs.next()) {
+ int slowQueryCount = rs.getInt(1);
+ return slowQueryCount > 3; // Alert if more than 3 slow queries
+ }
+ }
+ } catch (Exception e) {
+ logger.debug("Could not check for slow queries");
+ }
+ return false;
+ }
+
+ private boolean hasConnectionPoolExhaustion() {
+ // Use HikariCP metrics if available
+ if (dataSource instanceof HikariDataSource hikariDataSource) {
+ try {
+ HikariPoolMXBean poolMXBean = hikariDataSource.getHikariPoolMXBean();
+
+ if (poolMXBean != null) {
+ int activeConnections = poolMXBean.getActiveConnections();
+ int maxPoolSize = hikariDataSource.getMaximumPoolSize();
+
+ // Alert if > 80% of pool is exhausted
+ int threshold = (int) (maxPoolSize * 0.8);
+ return activeConnections > threshold;
+ }
+ } catch (Exception e) {
+ logger.debug("Could not retrieve HikariCP pool metrics");
+ }
+ }
+
+ // Fallback: try to get pool metrics via JMX if HikariCP is not directly available
+ 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");
+ }
+
+ // No pool metrics available - disable this check
+ 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/wipro/fhir/utils/JwtUserIdValidationFilter.java b/src/main/java/com/wipro/fhir/utils/JwtUserIdValidationFilter.java
index b415fc3..631f206 100644
--- a/src/main/java/com/wipro/fhir/utils/JwtUserIdValidationFilter.java
+++ b/src/main/java/com/wipro/fhir/utils/JwtUserIdValidationFilter.java
@@ -160,7 +160,9 @@ private boolean shouldSkipPath(String path, String contextPath) {
|| path.equalsIgnoreCase(contextPath + "/user/logOutUserFromConcurrentSession")
|| path.startsWith(contextPath + "/swagger-ui")
|| path.startsWith(contextPath + "/v3/api-docs")
- || path.startsWith(contextPath + "/public");
+ || path.startsWith(contextPath + "/public")
+ || path.equals(contextPath +"/version")
+ || path.equals(contextPath +"/health");
}
private String getJwtTokenFromCookies(HttpServletRequest request) {