Merge branch 'gh-32109'

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLogger.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012-2022 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.autoconfigure.logging;
+
+import java.util.function.Supplier;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport;
+import org.springframework.boot.logging.LogLevel;
+import org.springframework.util.Assert;
+
+/**
+ * Logs the {@link ConditionEvaluationReport}.
+ *
+ * @author Greg Turnquist
+ * @author Dave Syer
+ * @author Phillip Webb
+ * @author Andy Wilkinson
+ * @author Madhura Bhave
+ */
+class ConditionEvaluationReportLogger {
+
+	private final Log logger = LogFactory.getLog(getClass());
+
+	private final Supplier<ConditionEvaluationReport> reportSupplier;
+
+	private final LogLevel logLevel;
+
+	ConditionEvaluationReportLogger(LogLevel logLevel, Supplier<ConditionEvaluationReport> reportSupplier) {
+		Assert.isTrue(isInfoOrDebug(logLevel), "LogLevel must be INFO or DEBUG");
+		this.logLevel = logLevel;
+		this.reportSupplier = reportSupplier;
+	}
+
+	private boolean isInfoOrDebug(LogLevel logLevelForReport) {
+		return LogLevel.INFO.equals(logLevelForReport) || LogLevel.DEBUG.equals(logLevelForReport);
+	}
+
+	void logReport(boolean isCrashReport) {
+		ConditionEvaluationReport report = this.reportSupplier.get();
+		if (report == null) {
+			this.logger.info("Unable to provide the condition evaluation report");
+			return;
+		}
+		if (!report.getConditionAndOutcomesBySource().isEmpty()) {
+			if (this.logLevel.equals(LogLevel.INFO)) {
+				if (this.logger.isInfoEnabled()) {
+					this.logger.info(new ConditionEvaluationReportMessage(report));
+				}
+				else if (isCrashReport) {
+					logMessage("info");
+				}
+			}
+			else {
+				if (this.logger.isDebugEnabled()) {
+					this.logger.debug(new ConditionEvaluationReportMessage(report));
+				}
+				else if (isCrashReport) {
+					logMessage("debug");
+				}
+			}
+		}
+	}
+
+	private void logMessage(String logLevel) {
+		this.logger.info(String.format("%n%nError starting ApplicationContext. To display the "
+				+ "condition evaluation report re-run your application with '" + logLevel + "' enabled."));
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLoggingListener.java

@@ -16,8 +16,7 @@
 
 package org.springframework.boot.autoconfigure.logging;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import java.util.function.Supplier;
 
 import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport;
 import org.springframework.boot.context.event.ApplicationFailedEvent;
@@ -51,12 +50,6 @@
 public class ConditionEvaluationReportLoggingListener
 		implements ApplicationContextInitializer<ConfigurableApplicationContext> {
 
-	private final Log logger = LogFactory.getLog(getClass());
-
-	private ConfigurableApplicationContext applicationContext;
-
-	private ConditionEvaluationReport report;
-
 	private final LogLevel logLevelForReport;
 
 	public ConditionEvaluationReportLoggingListener() {
@@ -84,71 +77,36 @@ public static ConditionEvaluationReportLoggingListener forLogLevel(LogLevel logL
 		return new ConditionEvaluationReportLoggingListener(logLevelForReport);
 	}
 
-	public LogLevel getLogLevelForReport() {
-		return this.logLevelForReport;
-	}
-
 	@Override
 	public void initialize(ConfigurableApplicationContext applicationContext) {
-		this.applicationContext = applicationContext;
-		applicationContext.addApplicationListener(new ConditionEvaluationReportListener());
-		if (applicationContext instanceof GenericApplicationContext) {
-			// Get the report early in case the context fails to load
-			this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
-		}
+		applicationContext.addApplicationListener(new ConditionEvaluationReportListener(applicationContext));
 	}
 
-	protected void onApplicationEvent(ApplicationEvent event) {
-		ConfigurableApplicationContext initializerApplicationContext = this.applicationContext;
-		if (event instanceof ContextRefreshedEvent contextRefreshedEvent) {
-			if (contextRefreshedEvent.getApplicationContext() == initializerApplicationContext) {
-				logAutoConfigurationReport();
-			}
-		}
-		else if (event instanceof ApplicationFailedEvent applicationFailedEvent
-				&& applicationFailedEvent.getApplicationContext() == initializerApplicationContext) {
-			logAutoConfigurationReport(true);
-		}
-	}
+	private final class ConditionEvaluationReportListener implements GenericApplicationListener {
 
-	private void logAutoConfigurationReport() {
-		logAutoConfigurationReport(!this.applicationContext.isActive());
-	}
+		private final ConfigurableApplicationContext context;
 
-	public void logAutoConfigurationReport(boolean isCrashReport) {
-		if (this.report == null) {
-			if (this.applicationContext == null) {
-				this.logger.info("Unable to provide the conditions report due to missing ApplicationContext");
-				return;
-			}
-			this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
-		}
-		if (!this.report.getConditionAndOutcomesBySource().isEmpty()) {
-			if (getLogLevelForReport().equals(LogLevel.INFO)) {
-				if (this.logger.isInfoEnabled()) {
-					this.logger.info(new ConditionEvaluationReportMessage(this.report));
-				}
-				else if (isCrashReport) {
-					logMessage("info");
-				}
+		private final ConditionEvaluationReportLogger logger;
+
+		private ConditionEvaluationReportListener(ConfigurableApplicationContext context) {
+			this.context = context;
+			Supplier<ConditionEvaluationReport> reportSupplier;
+			if (context instanceof GenericApplicationContext) {
+				// Get the report early when the context allows early access to the bean
+				// factory in case the context subsequently fails to load
+				ConditionEvaluationReport report = getReport();
+				reportSupplier = () -> report;
 			}
 			else {
-				if (this.logger.isDebugEnabled()) {
-					this.logger.debug(new ConditionEvaluationReportMessage(this.report));
-				}
-				else if (isCrashReport) {
-					logMessage("debug");
-				}
+				reportSupplier = this::getReport;
 			}
+			this.logger = new ConditionEvaluationReportLogger(
+					ConditionEvaluationReportLoggingListener.this.logLevelForReport, reportSupplier);
 		}
-	}
 
-	private void logMessage(String logLevel) {
-		this.logger.info(String.format("%n%nError starting ApplicationContext. To display the "
-				+ "conditions report re-run your application with '" + logLevel + "' enabled."));
-	}
-
-	private class ConditionEvaluationReportListener implements GenericApplicationListener {
+		private ConditionEvaluationReport getReport() {
+			return ConditionEvaluationReport.get(this.context.getBeanFactory());
+		}
 
 		@Override
 		public int getOrder() {
@@ -172,7 +130,15 @@ public boolean supportsSourceType(Class<?> sourceType) {
 
 		@Override
 		public void onApplicationEvent(ApplicationEvent event) {
-			ConditionEvaluationReportLoggingListener.this.onApplicationEvent(event);
+			if (event instanceof ContextRefreshedEvent contextRefreshedEvent) {
+				if (contextRefreshedEvent.getApplicationContext() == this.context) {
+					this.logger.logReport(false);
+				}
+			}
+			else if (event instanceof ApplicationFailedEvent applicationFailedEvent
+					&& applicationFailedEvent.getApplicationContext() == this.context) {
+				this.logger.logReport(false);
+			}
 		}
 
 	}

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLoggingProcessor.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2012-2022 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.autoconfigure.logging;
+
+import org.springframework.beans.factory.aot.BeanFactoryInitializationAotContribution;
+import org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport;
+import org.springframework.boot.logging.LogLevel;
+
+/**
+ * {@link BeanFactoryInitializationAotProcessor} that logs the
+ * {@link ConditionEvaluationReport} during ahead-of-time processing.
+ *
+ * @author Andy Wilkinson
+ */
+class ConditionEvaluationReportLoggingProcessor implements BeanFactoryInitializationAotProcessor {
+
+	@Override
+	public BeanFactoryInitializationAotContribution processAheadOfTime(ConfigurableListableBeanFactory beanFactory) {
+		logConditionEvaluationReport(beanFactory);
+		return null;
+	}
+
+	private void logConditionEvaluationReport(ConfigurableListableBeanFactory beanFactory) {
+		new ConditionEvaluationReportLogger(LogLevel.DEBUG, () -> ConditionEvaluationReport.get(beanFactory))
+				.logReport(false);
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring/aot.factories

@@ -1,2 +1,5 @@
 org.springframework.aot.hint.RuntimeHintsRegistrar=\
 org.springframework.boot.autoconfigure.template.TemplateRuntimeHints
+
+org.springframework.beans.factory.aot.BeanFactoryInitializationAotProcessor=\
+org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingProcessor

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/logging/ConditionEvaluationReportLoggerTests.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2012-2022 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.autoconfigure.logging;
+
+import java.util.Arrays;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.LoggerContext;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.boot.autoconfigure.condition.ConditionEvaluationReport;
+import org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListenerTests.Config;
+import org.springframework.boot.logging.LogLevel;
+import org.springframework.boot.test.system.CapturedOutput;
+import org.springframework.boot.test.system.OutputCaptureExtension;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+
+/**
+ * Tests for {@link ConditionEvaluationReportLogger}.
+ *
+ * @author Andy Wilkinson
+ */
+@ExtendWith(OutputCaptureExtension.class)
+class ConditionEvaluationReportLoggerTests {
+
+	@Test
+	void noErrorIfNotInitialized(CapturedOutput output) {
+		new ConditionEvaluationReportLogger(LogLevel.INFO, () -> null).logReport(true);
+		assertThat(output).contains("Unable to provide the condition evaluation report");
+	}
+
+	@Test
+	void supportsOnlyInfoAndDebugLogLevels() {
+		assertThatIllegalArgumentException()
+				.isThrownBy(() -> new ConditionEvaluationReportLogger(LogLevel.TRACE, () -> null))
+				.withMessageContaining("LogLevel must be INFO or DEBUG");
+	}
+
+	@Test
+	void loggerWithInfoLevelShouldLogAtInfo(CapturedOutput output) {
+		try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+			ConditionEvaluationReportLogger logger = new ConditionEvaluationReportLogger(LogLevel.INFO,
+					() -> ConditionEvaluationReport.get(context.getBeanFactory()));
+			context.register(Config.class);
+			context.refresh();
+			logger.logReport(false);
+			assertThat(output).contains("CONDITIONS EVALUATION REPORT");
+		}
+	}
+
+	@Test
+	void loggerWithDebugLevelShouldLogAtDebug(CapturedOutput output) {
+		try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+			ConditionEvaluationReportLogger logger = new ConditionEvaluationReportLogger(LogLevel.DEBUG,
+					() -> ConditionEvaluationReport.get(context.getBeanFactory()));
+			context.register(Config.class);
+			context.refresh();
+			logger.logReport(false);
+			assertThat(output).doesNotContain("CONDITIONS EVALUATION REPORT");
+			withDebugLogging(() -> logger.logReport(false));
+			assertThat(output).contains("CONDITIONS EVALUATION REPORT");
+		}
+	}
+
+	@Test
+	void logsInfoOnErrorIfDebugDisabled(CapturedOutput output) {
+		try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+			ConditionEvaluationReportLogger logger = new ConditionEvaluationReportLogger(LogLevel.DEBUG,
+					() -> ConditionEvaluationReport.get(context.getBeanFactory()));
+			context.register(Config.class);
+			context.refresh();
+			logger.logReport(true);
+			assertThat(output).contains("Error starting ApplicationContext. To display the condition "
+					+ "evaluation report re-run your application with 'debug' enabled.");
+		}
+	}
+
+	@Test
+	void logsOutput(CapturedOutput output) {
+		try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+			ConditionEvaluationReportLogger logger = new ConditionEvaluationReportLogger(LogLevel.DEBUG,
+					() -> ConditionEvaluationReport.get(context.getBeanFactory()));
+			context.register(Config.class);
+			ConditionEvaluationReport.get(context.getBeanFactory()).recordExclusions(Arrays.asList("com.foo.Bar"));
+			context.refresh();
+			withDebugLogging(() -> logger.logReport(false));
+			assertThat(output).contains("not a servlet web application (OnWebApplicationCondition)");
+		}
+	}
+
+	private void withDebugLogging(Runnable runnable) {
+		Logger logger = ((LoggerContext) LoggerFactory.getILoggerFactory())
+				.getLogger(ConditionEvaluationReportLogger.class);
+		Level currentLevel = logger.getLevel();
+		logger.setLevel(Level.DEBUG);
+		try {
+			runnable.run();
+		}
+		finally {
+			logger.setLevel(currentLevel);
+		}
+	}
+
+}