Add support for health indicator groups

This commit allows a user to define an arbitrary number of health
indicator groups using configuration. If a given health indicator is
defined in more than one group, a single invocation is ensured using
a AggregateHealth. A reactive counter-part is also provided.

See spring-projectsgh-14022

Author: snicoll

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

@@ -17,10 +17,10 @@
 package org.springframework.boot.actuate.autoconfigure.health;
 
 import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnAvailableEndpoint;
-import org.springframework.boot.actuate.health.CompositeHealthIndicator;
 import org.springframework.boot.actuate.health.HealthAggregator;
 import org.springframework.boot.actuate.health.HealthEndpoint;
 import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
+import org.springframework.boot.actuate.health.OverallHealthIndicator;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
 import org.springframework.context.annotation.Bean;
@@ -39,7 +39,7 @@ class HealthEndpointConfiguration {
 	@Bean
 	@ConditionalOnMissingBean
 	public HealthEndpoint healthEndpoint(HealthAggregator healthAggregator, HealthIndicatorRegistry registry) {
-		return new HealthEndpoint(new CompositeHealthIndicator(healthAggregator, registry));
+		return new HealthEndpoint(new OverallHealthIndicator(healthAggregator, registry));
 	}
 
 }

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

@@ -16,15 +16,17 @@
 
 package org.springframework.boot.actuate.autoconfigure.health;
 
+import java.util.Map;
+
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.actuate.autoconfigure.endpoint.condition.ConditionalOnAvailableEndpoint;
-import org.springframework.boot.actuate.health.CompositeReactiveHealthIndicator;
 import org.springframework.boot.actuate.health.HealthAggregator;
 import org.springframework.boot.actuate.health.HealthEndpoint;
 import org.springframework.boot.actuate.health.HealthEndpointWebExtension;
 import org.springframework.boot.actuate.health.HealthStatusHttpMapper;
 import org.springframework.boot.actuate.health.HealthWebEndpointResponseMapper;
 import org.springframework.boot.actuate.health.OrderedHealthAggregator;
+import org.springframework.boot.actuate.health.OverallReactiveHealthIndicator;
 import org.springframework.boot.actuate.health.ReactiveHealthEndpointWebExtension;
 import org.springframework.boot.actuate.health.ReactiveHealthIndicatorRegistry;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
@@ -48,10 +50,11 @@ class HealthEndpointWebExtensionConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public HealthStatusHttpMapper createHealthStatusHttpMapper(HealthIndicatorProperties healthIndicatorProperties) {
+	public HealthStatusHttpMapper createHealthStatusHttpMapper(HealthIndicatorProperties properties) {
 		HealthStatusHttpMapper statusHttpMapper = new HealthStatusHttpMapper();
-		if (healthIndicatorProperties.getHttpMapping() != null) {
-			statusHttpMapper.addStatusMapping(healthIndicatorProperties.getHttpMapping());
+		Map<String, Integer> httpMapping = properties.getStatus().getHttpMapping();
+		if (httpMapping != null) {
+			statusHttpMapper.addStatusMapping(httpMapping);
 		}
 		return statusHttpMapper;
 	}
@@ -75,7 +78,7 @@ static class ReactiveWebHealthConfiguration {
 		public ReactiveHealthEndpointWebExtension reactiveHealthEndpointWebExtension(
 				ObjectProvider<HealthAggregator> healthAggregator, ReactiveHealthIndicatorRegistry registry,
 				HealthWebEndpointResponseMapper responseMapper) {
-			return new ReactiveHealthEndpointWebExtension(new CompositeReactiveHealthIndicator(
+			return new ReactiveHealthEndpointWebExtension(new OverallReactiveHealthIndicator(
 					healthAggregator.getIfAvailable(OrderedHealthAggregator::new), registry), responseMapper);
 		}
 

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

@@ -16,11 +16,17 @@
 
 package org.springframework.boot.actuate.autoconfigure.health;
 
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
 
 import reactor.core.publisher.Flux;
 
 import org.springframework.boot.actuate.health.ApplicationHealthIndicator;
+import org.springframework.boot.actuate.health.GroupHealthIndicator;
+import org.springframework.boot.actuate.health.GroupReactiveHealthIndicator;
 import org.springframework.boot.actuate.health.HealthAggregator;
 import org.springframework.boot.actuate.health.HealthIndicator;
 import org.springframework.boot.actuate.health.HealthIndicatorRegistry;
@@ -59,16 +65,40 @@ public ApplicationHealthIndicator applicationHealthIndicator() {
 	@ConditionalOnMissingBean(HealthAggregator.class)
 	public OrderedHealthAggregator healthAggregator(HealthIndicatorProperties properties) {
 		OrderedHealthAggregator healthAggregator = new OrderedHealthAggregator();
-		if (properties.getOrder() != null) {
-			healthAggregator.setStatusOrder(properties.getOrder());
+		if (properties.getStatus().getOrder() != null) {
+			healthAggregator.setStatusOrder(properties.getStatus().getOrder());
 		}
 		return healthAggregator;
 	}
 
 	@Bean
 	@ConditionalOnMissingBean(HealthIndicatorRegistry.class)
-	public HealthIndicatorRegistry healthIndicatorRegistry(ApplicationContext applicationContext) {
-		return HealthIndicatorRegistryBeans.get(applicationContext);
+	public HealthIndicatorRegistry healthIndicatorRegistry(HealthIndicatorProperties properties,
+			HealthAggregator healthAggregator, ApplicationContext applicationContext) {
+		HealthIndicatorRegistry registry = HealthIndicatorRegistryBeans.get(applicationContext);
+		extractGroups(properties, registry::get).forEach((groupName, groupHealthIndicators) -> registry
+				.register(groupName, new GroupHealthIndicator(healthAggregator, registry, groupHealthIndicators)));
+		return registry;
+	}
+
+	private static <T> Map<String, Set<String>> extractGroups(HealthIndicatorProperties properties,
+			Function<String, T> healthIndicatorByName) {
+		Map<String, Set<String>> groupDefinitions = new LinkedHashMap<>();
+		properties.getGroups().forEach((groupName, indicatorNames) -> {
+			if (healthIndicatorByName.apply(groupName) != null) {
+				throw new IllegalArgumentException("Could not register health indicator group named '" + groupName
+						+ "', an health indicator with that name is already registered");
+			}
+			Set<String> groupHealthIndicators = new LinkedHashSet<>();
+			indicatorNames.forEach((name) -> {
+				T healthIndicator = healthIndicatorByName.apply(name);
+				if (healthIndicator != null) {
+					groupHealthIndicators.add(name);
+				}
+			});
+			groupDefinitions.put(groupName, groupHealthIndicators);
+		});
+		return groupDefinitions;
 	}
 
 	@Configuration(proxyBeanMethods = false)
@@ -77,11 +107,15 @@ static class ReactiveHealthIndicatorConfiguration {
 
 		@Bean
 		@ConditionalOnMissingBean
-		public ReactiveHealthIndicatorRegistry reactiveHealthIndicatorRegistry(
-				Map<String, ReactiveHealthIndicator> reactiveHealthIndicators,
+		public ReactiveHealthIndicatorRegistry reactiveHealthIndicatorRegistry(HealthIndicatorProperties properties,
+				HealthAggregator healthAggregator, Map<String, ReactiveHealthIndicator> reactiveHealthIndicators,
 				Map<String, HealthIndicator> healthIndicators) {
-			return new ReactiveHealthIndicatorRegistryFactory()
+			ReactiveHealthIndicatorRegistry registry = new ReactiveHealthIndicatorRegistryFactory()
 					.createReactiveHealthIndicatorRegistry(reactiveHealthIndicators, healthIndicators);
+			extractGroups(properties, registry::get)
+					.forEach((groupName, groupHealthIndicators) -> registry.register(groupName,
+							new GroupReactiveHealthIndicator(healthAggregator, registry, groupHealthIndicators)));
+			return registry;
 		}
 
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2017 the original author or authors.
+ * 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.
@@ -28,32 +28,52 @@
  * @author Christian Dupuis
  * @since 2.0.0
  */
-@ConfigurationProperties(prefix = "management.health.status")
+@ConfigurationProperties(prefix = "management.health")
 public class HealthIndicatorProperties {
 
 	/**
-	 * Comma-separated list of health statuses in order of severity.
+	 * Health indicator groups. Each entry maps the name of a group with a list of health
+	 * indicators to associate with the group.
 	 */
-	private List<String> order = null;
+	private final Map<String, List<String>> groups = new HashMap<>();
 
-	/**
-	 * Mapping of health statuses to HTTP status codes. By default, registered health
-	 * statuses map to sensible defaults (for example, UP maps to 200).
-	 */
-	private final Map<String, Integer> httpMapping = new HashMap<>();
+	private final Status status = new Status();
 
-	public List<String> getOrder() {
-		return this.order;
+	public Map<String, List<String>> getGroups() {
+		return this.groups;
 	}
 
-	public void setOrder(List<String> statusOrder) {
-		if (statusOrder != null && !statusOrder.isEmpty()) {
-			this.order = statusOrder;
-		}
+	public Status getStatus() {
+		return this.status;
 	}
 
-	public Map<String, Integer> getHttpMapping() {
-		return this.httpMapping;
+	public static class Status {
+
+		/**
+		 * Comma-separated list of health statuses in order of severity.
+		 */
+		private List<String> order = null;
+
+		/**
+		 * Mapping of health statuses to HTTP status codes. By default, registered health
+		 * statuses map to sensible defaults (for example, UP maps to 200).
+		 */
+		private final Map<String, Integer> httpMapping = new HashMap<>();
+
+		public List<String> getOrder() {
+			return this.order;
+		}
+
+		public void setOrder(List<String> statusOrder) {
+			if (statusOrder != null && !statusOrder.isEmpty()) {
+				this.order = statusOrder;
+			}
+		}
+
+		public Map<String, Integer> getHttpMapping() {
+			return this.httpMapping;
+		}
+
 	}
 
 }

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

@@ -0,0 +1,68 @@
+/*
+ * 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 java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Aggregates the overall health of a system by caching {@link Health} per indicator.
+ *
+ * @author Stephane Nicoll
+ * @since 2.2.0
+ */
+public class AggregatedHealth {
+
+	private static final Health UNKNOWN_HEALTH = Health.unknown().build();
+
+	private final HealthIndicatorRegistry registry;
+
+	private final Map<String, Health> healths;
+
+	/**
+	 * Create an instance based on the specified {@link HealthIndicatorRegistry}.
+	 * @param registry the registry to use to retrieve an indicator by name
+	 */
+	public AggregatedHealth(HealthIndicatorRegistry registry) {
+		this.registry = registry;
+		this.healths = new HashMap<>();
+	}
+
+	/**
+	 * Return the {@link Health} of the indicator with the specified {@code name} for this
+	 * instance or {@code null} if no such indicator exists. When calling this method
+	 * several times for a given indicator, the same {@link Health} instance is returned.
+	 * @param name the name of a {@link HealthIndicator}
+	 * @return the {@link Health} of the indicator with the specified name
+	 */
+	public Health health(String name) {
+		Health health = this.healths.computeIfAbsent(name, this::determineHealth);
+		return (health != UNKNOWN_HEALTH) ? health : null;
+	}
+
+	private Health determineHealth(String name) {
+		HealthIndicator healthIndicator = this.registry.get(name);
+		if (healthIndicator == null) {
+			return UNKNOWN_HEALTH;
+		}
+		if (healthIndicator instanceof AggregatedHealthIndicator) {
+			return ((AggregatedHealthIndicator) healthIndicator).health(this);
+		}
+		return healthIndicator.health();
+	}
+
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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;
+
+/**
+ * An extended {@link HealthIndicator} that computes a global {@link Health} based on a
+ * {@link AggregatedHealth}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.2.0
+ */
+@FunctionalInterface
+public interface AggregatedHealthIndicator extends HealthIndicator {
+
+	@Override
+	default Health health() {
+		return health(new AggregatedHealth(new DefaultHealthIndicatorRegistry()));
+	}
+
+	/**
+	 * Return an indication of health based on the specified {@link AggregatedHealth}.
+	 * @param aggregatedHealth the already computed health
+	 * @return the health that this aggregate represents
+	 */
+	Health health(AggregatedHealth aggregatedHealth);
+
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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 reactor.core.publisher.Mono;
+
+/**
+ * An extended {@link ReactiveHealthIndicator} that computes a global {@link Health} based
+ * on a {@link ReactiveAggregatedHealth}.
+ *
+ * @author Stephane Nicoll
+ * @since 2.2.0
+ */
+@FunctionalInterface
+public interface AggregatedReactiveHealthIndicator extends ReactiveHealthIndicator {
+
+	@Override
+	default Mono<Health> health() {
+		return health(new ReactiveAggregatedHealth(new DefaultReactiveHealthIndicatorRegistry()));
+	}
+
+	/**
+	 * Return an indication of health based on the specified
+	 * {@link ReactiveAggregatedHealth}.
+	 * @param aggregatedHealth the already computed health
+	 * @return a {@link Mono} to the health that this aggregate represents
+	 */
+	Mono<Health> health(ReactiveAggregatedHealth aggregatedHealth);
+
+}