Rework Cloud Foundry actuator support behind a pluggable abstraction

Deprecate `EndpointExposure.CLOUD_FOUNDRY` and introduce an alternative
implementation based on a pluggable abstraction.

The new `EndpointExposureOutcomeContributor` interface may now be used
to influence `@OnAvailableEndpointCondition` exposure results. Several
infrastructure beans that previously used the condition have been
refactored to always be registered, but tolerate missing endpoints.

A new smoke test application has been added that demonstrates how the
abstraction can be used by a third-party.

Closes gh-41135

Co-authored-by: Phillip Webb <[email protected]>

Author: wilkinsona

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/cache/CachesEndpointAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2024 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.
@@ -52,7 +52,7 @@ public CachesEndpoint cachesEndpoint(Map<String, CacheManager> cacheManagers) {
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnBean(CachesEndpoint.class)
-	@ConditionalOnAvailableEndpoint(exposure = { EndpointExposure.WEB, EndpointExposure.CLOUD_FOUNDRY })
+	@ConditionalOnAvailableEndpoint(exposure = EndpointExposure.WEB)
 	public CachesEndpointWebExtension cachesEndpointWebExtension(CachesEndpoint cachesEndpoint) {
 		return new CachesEndpointWebExtension(cachesEndpoint);
 	}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/cloudfoundry/CloudFoundryEndpointExposureOutcomeContributor.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2012-2024 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.autoconfigure.cloudfoundry;
+
+import java.util.Set;
+
+import org.springframework.boot.actuate.autoconfigure.endpoint.condition.EndpointExposureOutcomeContributor;
+import org.springframework.boot.actuate.autoconfigure.endpoint.expose.EndpointExposure;
+import org.springframework.boot.actuate.autoconfigure.endpoint.expose.IncludeExcludeEndpointFilter;
+import org.springframework.boot.actuate.endpoint.EndpointId;
+import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
+import org.springframework.boot.autoconfigure.condition.ConditionMessage.Builder;
+import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
+import org.springframework.boot.cloud.CloudPlatform;
+import org.springframework.core.env.Environment;
+
+/**
+ * {@link EndpointExposureOutcomeContributor} to expose {@link EndpointExposure#WEB web}
+ * endpoints for Cloud Foundry.
+ *
+ * @author Phillip Webb
+ */
+class CloudFoundryEndpointExposureOutcomeContributor implements EndpointExposureOutcomeContributor {
+
+	private static final String PROPERTY = "management.endpoints.cloud-foundry.exposure";
+
+	private final IncludeExcludeEndpointFilter<?> filter;
+
+	CloudFoundryEndpointExposureOutcomeContributor(Environment environment) {
+		this.filter = (!CloudPlatform.CLOUD_FOUNDRY.isActive(environment)) ? null
+				: new IncludeExcludeEndpointFilter<>(ExposableEndpoint.class, environment, PROPERTY, "*");
+	}
+
+	@Override
+	public ConditionOutcome getExposureOutcome(EndpointId endpointId, Set<EndpointExposure> exposures,
+			Builder message) {
+		if (exposures.contains(EndpointExposure.WEB) && this.filter != null && this.filter.match(endpointId)) {
+			return ConditionOutcome.match(message.because("marked as exposed by a '" + PROPERTY + "' property"));
+		}
+		return null;
+	}
+
+}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/context/properties/ConfigurationPropertiesReportEndpointAutoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2022 the original author or authors.
+ * Copyright 2012-2024 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.
@@ -55,7 +55,7 @@ public ConfigurationPropertiesReportEndpoint configurationPropertiesReportEndpoi
 	@Bean
 	@ConditionalOnMissingBean
 	@ConditionalOnBean(ConfigurationPropertiesReportEndpoint.class)
-	@ConditionalOnAvailableEndpoint(exposure = { EndpointExposure.WEB, EndpointExposure.CLOUD_FOUNDRY })
+	@ConditionalOnAvailableEndpoint(exposure = EndpointExposure.WEB)
 	public ConfigurationPropertiesReportEndpointWebExtension configurationPropertiesReportEndpointWebExtension(
 			ConfigurationPropertiesReportEndpoint configurationPropertiesReportEndpoint,
 			ConfigurationPropertiesReportEndpointProperties properties) {

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/ConditionalOnAvailableEndpoint.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2021 the original author or authors.
+ * Copyright 2012-2024 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.
@@ -31,15 +31,18 @@
 /**
  * {@link Conditional @Conditional} that checks whether an endpoint is available. An
  * endpoint is considered available if it is both enabled and exposed on the specified
- * technologies. Matches enablement according to the endpoints specific
- * {@link Environment} property, falling back to
- * {@code management.endpoints.enabled-by-default} or failing that
- * {@link Endpoint#enableByDefault()}. Matches exposure according to any of the
- * {@code management.endpoints.web.exposure.<id>} or
- * {@code management.endpoints.jmx.exposure.<id>} specific properties or failing that to
- * whether the application runs on
- * {@link org.springframework.boot.cloud.CloudPlatform#CLOUD_FOUNDRY}. Both those
- * conditions should match for the endpoint to be considered available.
+ * technologies.
+ * <p>
+ * Matches enablement according to the endpoints specific {@link Environment} property,
+ * falling back to {@code management.endpoints.enabled-by-default} or failing that
+ * {@link Endpoint#enableByDefault()}.
+ * <p>
+ * Matches exposure according to any of the {@code management.endpoints.web.exposure.<id>}
+ * or {@code management.endpoints.jmx.exposure.<id>} specific properties or failing that
+ * to whether any {@link EndpointExposureOutcomeContributor} exposes the endpoint.
+ * <p>
+ * Both enablement and exposure conditions should match for the endpoint to be considered
+ * available.
  * <p>
  * When placed on a {@code @Bean} method, the endpoint defaults to the return type of the
  * factory method:
@@ -97,6 +100,8 @@
  *
  * @author Brian Clozel
  * @author Stephane Nicoll
+ * @author Andy Wilkinson
+ * @author Phillip Webb
  * @since 2.2.0
  * @see Endpoint
  */

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/EndpointExposureOutcomeContributor.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2012-2024 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.autoconfigure.endpoint.condition;
+
+import java.util.Set;
+
+import org.springframework.boot.actuate.autoconfigure.endpoint.expose.EndpointExposure;
+import org.springframework.boot.actuate.endpoint.EndpointId;
+import org.springframework.boot.autoconfigure.condition.ConditionMessage;
+import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
+import org.springframework.core.env.Environment;
+
+/**
+ * Contributor loaded from the {@code spring.factories} file and used by
+ * {@link ConditionalOnAvailableEndpoint @ConditionalOnAvailableEndpoint} to determine if
+ * an endpoint is exposed. If any contributor returns a {@link ConditionOutcome#isMatch()
+ * matching} {@link ConditionOutcome} then the endpoint is considered exposed.
+ * <p>
+ * Implementations may declare a constructor that accepts an {@link Environment} argument.
+ *
+ * @author Andy Wilkinson
+ * @author Phillip Webb
+ * @since 3.4.0
+ */
+public interface EndpointExposureOutcomeContributor {
+
+	/**
+	 * Return if the given endpoint is exposed for the given set of exposure technologies.
+	 * @param endpointId the endpoint ID
+	 * @param exposures the exposure technologies to check
+	 * @param message the condition message builder
+	 * @return a {@link ConditionOutcome#isMatch() matching} {@link ConditionOutcome} if
+	 * the endpoint is exposed or {@code null} if the contributor should not apply
+	 */
+	ConditionOutcome getExposureOutcome(EndpointId endpointId, Set<EndpointExposure> exposures,
+			ConditionMessage.Builder message);
+
+}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/condition/OnAvailableEndpointCondition.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2023 the original author or authors.
+ * Copyright 2012-2024 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.
@@ -17,9 +17,10 @@
 package org.springframework.boot.actuate.autoconfigure.endpoint.condition;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.EnumSet;
-import java.util.HashSet;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
@@ -31,15 +32,17 @@
 import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
 import org.springframework.boot.actuate.endpoint.annotation.EndpointExtension;
 import org.springframework.boot.autoconfigure.condition.ConditionMessage;
+import org.springframework.boot.autoconfigure.condition.ConditionMessage.Builder;
 import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
 import org.springframework.boot.autoconfigure.condition.SpringBootCondition;
-import org.springframework.boot.cloud.CloudPlatform;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ConditionContext;
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
 import org.springframework.core.annotation.MergedAnnotations.SearchStrategy;
 import org.springframework.core.env.Environment;
+import org.springframework.core.io.support.SpringFactoriesLoader;
+import org.springframework.core.io.support.SpringFactoriesLoader.ArgumentResolver;
 import org.springframework.core.type.AnnotatedTypeMetadata;
 import org.springframework.core.type.MethodMetadata;
 import org.springframework.util.Assert;
@@ -52,6 +55,7 @@
  * @author Brian Clozel
  * @author Stephane Nicoll
  * @author Phillip Webb
+ * @author Andy Wilkinson
  * @see ConditionalOnAvailableEndpoint
  */
 class OnAvailableEndpointCondition extends SpringBootCondition {
@@ -60,7 +64,7 @@ class OnAvailableEndpointCondition extends SpringBootCondition {
 
 	private static final String ENABLED_BY_DEFAULT_KEY = "management.endpoints.enabled-by-default";
 
-	private static final Map<Environment, Set<ExposureFilter>> exposureFiltersCache = new ConcurrentReferenceHashMap<>();
+	private static final Map<Environment, Set<EndpointExposureOutcomeContributor>> exposureOutcomeContributorsCache = new ConcurrentReferenceHashMap<>();
 
 	private static final ConcurrentReferenceHashMap<Environment, Optional<Boolean>> enabledByDefaultCache = new ConcurrentReferenceHashMap<>();
 
@@ -110,18 +114,10 @@ private ConditionOutcome getMatchOutcome(Environment environment,
 		ConditionMessage.Builder message = ConditionMessage.forCondition(ConditionalOnAvailableEndpoint.class);
 		EndpointId endpointId = EndpointId.of(environment, endpointAnnotation.getString("id"));
 		ConditionOutcome enablementOutcome = getEnablementOutcome(environment, endpointAnnotation, endpointId, message);
-		if (!enablementOutcome.isMatch()) {
-			return enablementOutcome;
-		}
-		Set<EndpointExposure> exposuresToCheck = getExposuresToCheck(conditionAnnotation);
-		Set<ExposureFilter> exposureFilters = getExposureFilters(environment);
-		for (ExposureFilter exposureFilter : exposureFilters) {
-			if (exposuresToCheck.contains(exposureFilter.getExposure()) && exposureFilter.isExposed(endpointId)) {
-				return ConditionOutcome.match(message.because("marked as exposed by a 'management.endpoints."
-						+ exposureFilter.getExposure().name().toLowerCase() + ".exposure' property"));
-			}
-		}
-		return ConditionOutcome.noMatch(message.because("no 'management.endpoints' property marked it as exposed"));
+		ConditionOutcome exposureOutcome = (!enablementOutcome.isMatch()) ? null
+				: getExposureOutcome(environment, conditionAnnotation, endpointAnnotation, endpointId, message);
+		return (exposureOutcome != null) ? exposureOutcome
+				: ConditionOutcome.noMatch(message.because("not enabled or exposed"));
 	}
 
 	private ConditionOutcome getEnablementOutcome(Environment environment,
@@ -148,54 +144,83 @@ private Boolean isEnabledByDefault(Environment environment) {
 		return enabledByDefault.orElse(null);
 	}
 
-	private Set<EndpointExposure> getExposuresToCheck(
-			MergedAnnotation<ConditionalOnAvailableEndpoint> conditionAnnotation) {
-		EndpointExposure[] exposure = conditionAnnotation.getEnumArray("exposure", EndpointExposure.class);
-		return (exposure.length == 0) ? EnumSet.allOf(EndpointExposure.class)
-				: new LinkedHashSet<>(Arrays.asList(exposure));
+	private ConditionOutcome getExposureOutcome(Environment environment,
+			MergedAnnotation<ConditionalOnAvailableEndpoint> conditionAnnotation,
+			MergedAnnotation<Endpoint> endpointAnnotation, EndpointId endpointId, Builder message) {
+		Set<EndpointExposure> exposures = getExposures(conditionAnnotation);
+		Set<EndpointExposureOutcomeContributor> outcomeContributors = getExposureOutcomeContributors(environment);
+		for (EndpointExposureOutcomeContributor outcomeContributor : outcomeContributors) {
+			ConditionOutcome outcome = outcomeContributor.getExposureOutcome(endpointId, exposures, message);
+			if (outcome != null && outcome.isMatch()) {
+				return outcome;
+			}
+		}
+		return null;
+	}
+
+	private Set<EndpointExposure> getExposures(MergedAnnotation<ConditionalOnAvailableEndpoint> conditionAnnotation) {
+		EndpointExposure[] exposures = conditionAnnotation.getEnumArray("exposure", EndpointExposure.class);
+		return replaceCloudFoundryExposure(
+				(exposures.length == 0) ? EnumSet.allOf(EndpointExposure.class) : Arrays.asList(exposures));
+	}
+
+	@SuppressWarnings("removal")
+	private Set<EndpointExposure> replaceCloudFoundryExposure(Collection<EndpointExposure> exposures) {
+		Set<EndpointExposure> result = EnumSet.copyOf(exposures);
+		if (result.remove(EndpointExposure.CLOUD_FOUNDRY)) {
+			result.add(EndpointExposure.WEB);
+		}
+		return result;
 	}
 
-	private Set<ExposureFilter> getExposureFilters(Environment environment) {
-		Set<ExposureFilter> exposureFilters = exposureFiltersCache.get(environment);
-		if (exposureFilters == null) {
-			exposureFilters = new HashSet<>(2);
+	private Set<EndpointExposureOutcomeContributor> getExposureOutcomeContributors(Environment environment) {
+		Set<EndpointExposureOutcomeContributor> contributors = exposureOutcomeContributorsCache.get(environment);
+		if (contributors == null) {
+			contributors = new LinkedHashSet<>();
+			contributors.add(new StandardExposureOutcomeContributor(environment, EndpointExposure.WEB));
 			if (environment.getProperty(JMX_ENABLED_KEY, Boolean.class, false)) {
-				exposureFilters.add(new ExposureFilter(environment, EndpointExposure.JMX));
-			}
-			if (CloudPlatform.CLOUD_FOUNDRY.isActive(environment)) {
-				exposureFilters.add(new ExposureFilter(environment, EndpointExposure.CLOUD_FOUNDRY));
+				contributors.add(new StandardExposureOutcomeContributor(environment, EndpointExposure.JMX));
 			}
-			exposureFilters.add(new ExposureFilter(environment, EndpointExposure.WEB));
-			exposureFiltersCache.put(environment, exposureFilters);
+			contributors.addAll(loadExposureOutcomeContributors(environment));
+			exposureOutcomeContributorsCache.put(environment, contributors);
 		}
-		return exposureFilters;
+		return contributors;
 	}
 
-	static final class ExposureFilter extends IncludeExcludeEndpointFilter<ExposableEndpoint<?>> {
+	private List<EndpointExposureOutcomeContributor> loadExposureOutcomeContributors(Environment environment) {
+		ArgumentResolver argumentResolver = ArgumentResolver.of(Environment.class, environment);
+		return SpringFactoriesLoader.forDefaultResourceLocation()
+			.load(EndpointExposureOutcomeContributor.class, argumentResolver);
+	}
+
+	/**
+	 * Standard {@link EndpointExposureOutcomeContributor}.
+	 */
+	private static class StandardExposureOutcomeContributor implements EndpointExposureOutcomeContributor {
 
 		private final EndpointExposure exposure;
 
-		@SuppressWarnings({ "unchecked", "rawtypes" })
-		private ExposureFilter(Environment environment, EndpointExposure exposure) {
-			super((Class) ExposableEndpoint.class, environment,
-					"management.endpoints." + getCanonicalName(exposure) + ".exposure", exposure.getDefaultIncludes());
-			this.exposure = exposure;
+		private final String property;
 
-		}
+		private final IncludeExcludeEndpointFilter<?> filter;
 
-		private static String getCanonicalName(EndpointExposure exposure) {
-			if (EndpointExposure.CLOUD_FOUNDRY.equals(exposure)) {
-				return "cloud-foundry";
-			}
-			return exposure.name().toLowerCase();
-		}
+		StandardExposureOutcomeContributor(Environment environment, EndpointExposure exposure) {
+			this.exposure = exposure;
+			String name = exposure.name().toLowerCase().replace('_', '-');
+			this.property = "management.endpoints." + name + ".exposure";
+			this.filter = new IncludeExcludeEndpointFilter<>(ExposableEndpoint.class, environment, this.property,
+					exposure.getDefaultIncludes());
 
-		EndpointExposure getExposure() {
-			return this.exposure;
 		}
 
-		boolean isExposed(EndpointId id) {
-			return super.match(id);
+		@Override
+		public ConditionOutcome getExposureOutcome(EndpointId endpointId, Set<EndpointExposure> exposures,
+				ConditionMessage.Builder message) {
+			if (exposures.contains(this.exposure) && this.filter.match(endpointId)) {
+				return ConditionOutcome
+					.match(message.because("marked as exposed by a '" + this.property + "' property"));
+			}
+			return null;
 		}
 
 	}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/endpoint/expose/EndpointExposure.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2023 the original author or authors.
+ * Copyright 2012-2024 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.
@@ -37,7 +37,10 @@ public enum EndpointExposure {
 	/**
 	 * Exposed on Cloud Foundry over `/cloudfoundryapplication`.
 	 * @since 2.6.4
+	 * @deprecated since 3.4.0 for removal in 3.6.0 in favor of using
+	 * {@link EndpointExposure#WEB}
 	 */
+	@Deprecated(since = "3.4.0", forRemoval = true)
 	CLOUD_FOUNDRY("*");
 
 	private final String[] defaultIncludes;