Log health check failure with Reactive health indicators

See gh-17635

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/cassandra/CassandraReactiveHealthIndicator.java

@@ -40,6 +40,7 @@ public class CassandraReactiveHealthIndicator extends AbstractReactiveHealthIndi
 	 * @param reactiveCassandraOperations the Cassandra operations
 	 */
 	public CassandraReactiveHealthIndicator(ReactiveCassandraOperations reactiveCassandraOperations) {
+		super("Cassandra health check failed");
 		Assert.notNull(reactiveCassandraOperations, "ReactiveCassandraOperations must not be null");
 		this.reactiveCassandraOperations = reactiveCassandraOperations;
 	}

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/couchbase/CouchbaseReactiveHealthIndicator.java

@@ -39,6 +39,7 @@ public class CouchbaseReactiveHealthIndicator extends AbstractReactiveHealthIndi
 	 * @param cluster the Couchbase cluster
 	 */
 	public CouchbaseReactiveHealthIndicator(Cluster cluster) {
+		super("Couchbase health check failed");
 		this.cluster = cluster;
 	}
 

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/health/AbstractReactiveHealthIndicator.java

@@ -16,8 +16,15 @@
 
 package org.springframework.boot.actuate.health;
 
+import java.util.function.Function;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import reactor.core.publisher.Mono;
 
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
 /**
  * Base {@link ReactiveHealthIndicator} implementations that encapsulates creation of
  * {@link Health} instance and error handling.
@@ -28,6 +35,44 @@ import reactor.core.publisher.Mono;
  */
 public abstract class AbstractReactiveHealthIndicator implements ReactiveHealthIndicator {
 
+	private static final String NO_MESSAGE = null;
+
+	private static final String DEFAULT_MESSAGE = "Health check failed";
+
+	private final Log logger = LogFactory.getLog(getClass());
+
+	private final Function<Throwable, String> healthCheckFailedMessage;
+
+	/**
+	 * Create a new {@link AbstractReactiveHealthIndicator} instance with a default
+	 * {@code healthCheckFailedMessage}.
+	 * @since 2.1.7
+	 */
+	protected AbstractReactiveHealthIndicator() {
+		this(NO_MESSAGE);
+	}
+
+	/**
+	 * Create a new {@link AbstractReactiveHealthIndicator} instance with a specific
+	 * message to log when the health check fails.
+	 * @param healthCheckFailedMessage the message to log on health check failure
+	 * @since 2.1.7
+	 */
+	protected AbstractReactiveHealthIndicator(String healthCheckFailedMessage) {
+		this.healthCheckFailedMessage = (ex) -> healthCheckFailedMessage;
+	}
+
+	/**
+	 * Create a new {@link AbstractReactiveHealthIndicator} instance with a specific
+	 * message to log when the health check fails.
+	 * @param healthCheckFailedMessage the message to log on health check failure
+	 * @since 2.1.7
+	 */
+	protected AbstractReactiveHealthIndicator(Function<Throwable, String> healthCheckFailedMessage) {
+		Assert.notNull(healthCheckFailedMessage, "HealthCheckFailedMessage must not be null");
+		this.healthCheckFailedMessage = healthCheckFailedMessage;
+	}
+
 	@Override
 	public final Mono<Health> health() {
 		try {
@@ -39,6 +84,10 @@ public abstract class AbstractReactiveHealthIndicator implements ReactiveHealthI
 	}
 
 	private Mono<Health> handleFailure(Throwable ex) {
+		if (this.logger.isWarnEnabled()) {
+			String message = this.healthCheckFailedMessage.apply(ex);
+			this.logger.warn(StringUtils.hasText(message) ? message : DEFAULT_MESSAGE, ex);
+		}
 		return Mono.just(new Health.Builder().down(ex).build());
 	}
 

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/mongo/MongoReactiveHealthIndicator.java

@@ -36,6 +36,7 @@ public class MongoReactiveHealthIndicator extends AbstractReactiveHealthIndicato
 	private final ReactiveMongoTemplate reactiveMongoTemplate;
 
 	public MongoReactiveHealthIndicator(ReactiveMongoTemplate reactiveMongoTemplate) {
+		super("Mongo health check failed");
 		Assert.notNull(reactiveMongoTemplate, "ReactiveMongoTemplate must not be null");
 		this.reactiveMongoTemplate = reactiveMongoTemplate;
 	}

spring-boot-project/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/redis/RedisReactiveHealthIndicator.java

@@ -40,6 +40,7 @@ public class RedisReactiveHealthIndicator extends AbstractReactiveHealthIndicato
 	private final ReactiveRedisConnectionFactory connectionFactory;
 
 	public RedisReactiveHealthIndicator(ReactiveRedisConnectionFactory connectionFactory) {
+		super("Redis health check failed");
 		this.connectionFactory = connectionFactory;
 	}
 

spring-boot-project/spring-boot-actuator/src/test/java/org/springframework/boot/actuate/health/AbstractReactiveHealthIndicatorTests.java

+/*
+ * Copyright 2012-2019 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.actuate.health;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import reactor.core.publisher.Mono;
+
+import org.springframework.boot.actuate.health.Health.Builder;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link AbstractReactiveHealthIndicator}.
+ *
+ * @author Dmytro Nosan
+ */
+@ExtendWith(OutputCaptureExtension.class)
+class AbstractReactiveHealthIndicatorTests {
+
+	@Test
+	void doHealth() {
+		Health health = new SimpleReactiveHealthIndicator().health().block();
+		assertThat(health).isEqualTo(Health.up().build());
+	}
+
+	@Test
+	void doHealthCustomErrorMessage(CapturedOutput output) {
+		Health health = new ErrorMessageReactiveHealthIndicator().health().block();
+		assertThat(health).isEqualTo(Health.down(new UnsupportedOperationException()).build());
+		assertThat(output).contains("Unsupported Operation");
+	}
+
+	@Test
+	void doHealthCustomErrorMessageFunction(CapturedOutput output) {
+		Health health = new CustomErrorFunctionReactiveHealthIndicator().health().block();
+		assertThat(health).isEqualTo(Health.down(new RuntimeException()).build());
+		assertThat(output).contains("Runtime Exception");
+	}
+
+	private static final class SimpleReactiveHealthIndicator extends AbstractReactiveHealthIndicator {
+
+		@Override
+		protected Mono<Health> doHealthCheck(Builder builder) {
+			return Mono.just(builder.up().build());
+		}
+
+	}
+
+	private static final class ErrorMessageReactiveHealthIndicator extends AbstractReactiveHealthIndicator {
+
+		ErrorMessageReactiveHealthIndicator() {
+			super("Unsupported Operation");
+		}
+
+		@Override
+		protected Mono<Health> doHealthCheck(Builder builder) {
+			return Mono.error(new UnsupportedOperationException());
+		}
+
+	}
+
+	private static final class CustomErrorFunctionReactiveHealthIndicator extends AbstractReactiveHealthIndicator {
+
+		CustomErrorFunctionReactiveHealthIndicator() {
+			super((ex) -> "Runtime Exception");
+		}
+
+		@Override
+		protected Mono<Health> doHealthCheck(Builder builder) {
+			throw new RuntimeException();
+		}
+
+	}
+
+}