Add support for configuring start timeout for JMS health checks

See gh-50957

Signed-off-by: Venkata Naga Sai Srikanth Gollapudi <42247688+gollapudisrikanth@users.noreply.github.com>

Author: GollapudiSrikanth

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/health/JmsHealthContributorAutoConfiguration.java

@@ -24,6 +24,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.health.autoconfigure.contributor.CompositeHealthContributorConfiguration;
 import org.springframework.boot.health.autoconfigure.contributor.ConditionalOnEnabledHealthIndicator;
 import org.springframework.boot.health.contributor.HealthContributor;
@@ -35,17 +36,19 @@
  * {@link EnableAutoConfiguration Auto-configuration} for {@link JmsHealthIndicator}.
  *
  * @author Stephane Nicoll
+ * @author Venkata Naga Sai Srikanth Gollapudi
  * @since 4.0.0
  */
 @AutoConfiguration(after = JmsAutoConfiguration.class)
 @ConditionalOnClass({ ConnectionFactory.class, JmsHealthIndicator.class })
 @ConditionalOnBean(ConnectionFactory.class)
 @ConditionalOnEnabledHealthIndicator("jms")
+@EnableConfigurationProperties(JmsHealthIndicatorProperties.class)
 public final class JmsHealthContributorAutoConfiguration
 		extends CompositeHealthContributorConfiguration<JmsHealthIndicator, ConnectionFactory> {
 
-	JmsHealthContributorAutoConfiguration() {
-		super(JmsHealthIndicator::new);
+	JmsHealthContributorAutoConfiguration(JmsHealthIndicatorProperties properties) {
+		super((connectionFactory) -> new JmsHealthIndicator(connectionFactory, properties.getTimeout()));
 	}
 
 	@Bean

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/health/JmsHealthIndicatorProperties.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2012-present the original author or authors.
+ *
+ * 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 org.springframework.boot.jms.autoconfigure.health;
+
+import java.time.Duration;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.boot.jms.health.JmsHealthIndicator;
+import org.springframework.util.Assert;
+
+/**
+ * External configuration properties for {@link JmsHealthIndicator}.
+ *
+ * @author Venkata Naga Sai Srikanth Gollapudi
+ * @since 4.x
+ */
+@ConfigurationProperties("management.health.jms")
+public class JmsHealthIndicatorProperties {
+
+	/**
+	 * Timeout to use when starting a connection for the health check.
+	 */
+	private Duration timeout = Duration.ofSeconds(5);
+
+	public Duration getTimeout() {
+		return this.timeout;
+	}
+
+	public void setTimeout(Duration timeout) {
+		Assert.notNull(timeout, "'timeout' must not be null");
+		Assert.isTrue(timeout.compareTo(Duration.ZERO) > 0, "'timeout' must be greater than 0");
+		this.timeout = timeout;
+	}
+
+}

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/health/JmsHealthIndicator.java

@@ -16,6 +16,7 @@
 
 package org.springframework.boot.jms.health;
 
+import java.time.Duration;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
@@ -25,25 +26,40 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
+import org.springframework.boot.convert.DurationStyle;
 import org.springframework.boot.health.contributor.AbstractHealthIndicator;
 import org.springframework.boot.health.contributor.Health;
 import org.springframework.boot.health.contributor.HealthIndicator;
+import org.springframework.core.log.LogMessage;
+import org.springframework.util.Assert;
 
 /**
  * {@link HealthIndicator} for a JMS {@link ConnectionFactory}.
  *
  * @author Stephane Nicoll
+ * @author Venkata Naga Sai Srikanth Gollapudi
  * @since 4.0.0
  */
 public class JmsHealthIndicator extends AbstractHealthIndicator {
 
+	private static final Duration DEFAULT_TIMEOUT = Duration.ofSeconds(5);
+
 	private final Log logger = LogFactory.getLog(JmsHealthIndicator.class);
 
 	private final ConnectionFactory connectionFactory;
 
+	private final Duration timeout;
+
 	public JmsHealthIndicator(ConnectionFactory connectionFactory) {
+		this(connectionFactory, DEFAULT_TIMEOUT);
+	}
+
+	public JmsHealthIndicator(ConnectionFactory connectionFactory, Duration timeout) {
 		super("JMS health check failed");
+		Assert.notNull(timeout, "'timeout' must not be null");
+		Assert.isTrue(timeout.compareTo(Duration.ZERO) > 0, "'timeout' must be greater than 0");
 		this.connectionFactory = connectionFactory;
+		this.timeout = timeout;
 	}
 
 	@Override
@@ -67,9 +83,10 @@ private final class MonitoredConnection {
 		void start() throws JMSException {
 			new Thread(() -> {
 				try {
-					if (!this.latch.await(5, TimeUnit.SECONDS)) {
+					if (!this.latch.await(JmsHealthIndicator.this.timeout.toNanos(), TimeUnit.NANOSECONDS)) {
 						JmsHealthIndicator.this.logger
-							.warn("Connection failed to start within 5 seconds and will be closed.");
+							.warn(LogMessage.format("Connection failed to start within %s and will be closed.",
+									DurationStyle.SIMPLE.print(JmsHealthIndicator.this.timeout)));
 						closeConnection();
 					}
 				}

module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/health/JmsHealthContributorAutoConfigurationTests.java

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.jms.autoconfigure.health;
 
+import java.time.Duration;
+
 import jakarta.jms.ConnectionFactory;
 import org.junit.jupiter.api.Test;
 
@@ -31,6 +33,7 @@
  * Tests for {@link JmsHealthContributorAutoConfiguration}.
  *
  * @author Phillip Webb
+ * @author Venkata Naga Sai Srikanth Gollapudi
  */
 class JmsHealthContributorAutoConfigurationTests {
 
@@ -44,6 +47,27 @@ void runShouldCreateIndicator() {
 		this.contextRunner.run((context) -> assertThat(context).hasSingleBean(JmsHealthIndicator.class));
 	}
 
+	@Test
+	void runWhenTimeoutIsConfiguredShouldCreateIndicatorWithConfiguredTimeout() {
+		this.contextRunner.withPropertyValues("management.health.jms.timeout=10ms").run((context) -> {
+			assertThat(context).hasSingleBean(JmsHealthIndicator.class);
+			assertThat(context).hasSingleBean(JmsHealthIndicatorProperties.class);
+			assertThat(context.getBean(JmsHealthIndicatorProperties.class).getTimeout())
+				.isEqualTo(Duration.ofMillis(10));
+			assertThat(context.getBean(JmsHealthIndicator.class)).hasFieldOrPropertyWithValue("timeout",
+					Duration.ofMillis(10));
+		});
+	}
+
+	@Test
+	void runWhenTimeoutIsZeroShouldFail() {
+		this.contextRunner.withPropertyValues("management.health.jms.timeout=0ms")
+			.run((context) -> assertThat(context).hasFailed()
+				.getFailure()
+				.rootCause()
+				.hasMessage("'timeout' must be greater than 0"));
+	}
+
 	@Test
 	void runWhenDisabledShouldNotCreateIndicator() {
 		this.contextRunner.withPropertyValues("management.health.jms.enabled:false")

module/spring-boot-jms/src/test/java/org/springframework/boot/jms/health/JmsHealthIndicatorTests.java

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.jms.health;
 
+import java.time.Duration;
+
 import jakarta.jms.Connection;
 import jakarta.jms.ConnectionFactory;
 import jakarta.jms.ConnectionMetaData;
@@ -28,6 +30,7 @@
 import org.springframework.boot.health.contributor.Status;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.BDDMockito.then;
 import static org.mockito.BDDMockito.willAnswer;
@@ -38,9 +41,33 @@
  * Tests for {@link JmsHealthIndicator}.
  *
  * @author Stephane Nicoll
+ * @author Venkata Naga Sai Srikanth Gollapudi
  */
 class JmsHealthIndicatorTests {
 
+	@Test
+	@SuppressWarnings("NullAway") // Test null check
+	void createWhenTimeoutIsNullThrowsException() {
+		ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
+		assertThatIllegalArgumentException().isThrownBy(() -> new JmsHealthIndicator(connectionFactory, null))
+			.withMessage("'timeout' must not be null");
+	}
+
+	@Test
+	void createWhenTimeoutIsZeroThrowsException() {
+		ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
+		assertThatIllegalArgumentException().isThrownBy(() -> new JmsHealthIndicator(connectionFactory, Duration.ZERO))
+			.withMessage("'timeout' must be greater than 0");
+	}
+
+	@Test
+	void createWhenTimeoutIsNegativeThrowsException() {
+		ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
+		assertThatIllegalArgumentException()
+			.isThrownBy(() -> new JmsHealthIndicator(connectionFactory, Duration.ofMillis(-1)))
+			.withMessage("'timeout' must be greater than 0");
+	}
+
 	@Test
 	void jmsBrokerIsUp() throws JMSException {
 		ConnectionMetaData connectionMetaData = mock(ConnectionMetaData.class);
@@ -98,6 +125,19 @@ void jmsBrokerUsesFailover() throws JMSException {
 
 	@Test
 	void whenConnectionStartIsUnresponsiveStatusIsDown() throws JMSException {
+		Health health = healthWhenConnectionStartIsUnresponsive(Duration.ofSeconds(5));
+		assertThat(health.getStatus()).isEqualTo(Status.DOWN);
+		assertThat((String) health.getDetails().get("error")).contains("Connection closed");
+	}
+
+	@Test
+	void whenConnectionStartIsUnresponsiveUsesConfiguredTimeout() throws JMSException {
+		Health health = healthWhenConnectionStartIsUnresponsive(Duration.ofMillis(10));
+		assertThat(health.getStatus()).isEqualTo(Status.DOWN);
+		assertThat((String) health.getDetails().get("error")).contains("Connection closed");
+	}
+
+	private Health healthWhenConnectionStartIsUnresponsive(Duration timeout) throws JMSException {
 		ConnectionMetaData connectionMetaData = mock(ConnectionMetaData.class);
 		given(connectionMetaData.getJMSProviderName()).willReturn("JMS test provider");
 		Connection connection = mock(Connection.class);
@@ -109,10 +149,8 @@ void whenConnectionStartIsUnresponsiveStatusIsDown() throws JMSException {
 		}).given(connection).close();
 		ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
 		given(connectionFactory.createConnection()).willReturn(connection);
-		JmsHealthIndicator indicator = new JmsHealthIndicator(connectionFactory);
-		Health health = indicator.health();
-		assertThat(health.getStatus()).isEqualTo(Status.DOWN);
-		assertThat((String) health.getDetails().get("error")).contains("Connection closed");
+		JmsHealthIndicator indicator = new JmsHealthIndicator(connectionFactory, timeout);
+		return indicator.health();
 	}
 
 	private static final class UnresponsiveStartAnswer implements Answer<Void> {