Add support for Log4j2's composite configuration

Closes gh-27110

Author: wilkinsona

spring-boot-project/spring-boot-docs/src/docs/asciidoc/howto/logging.adoc

@@ -185,3 +185,11 @@ To configure Log4j 2 to use an alternative configuration file format, add the ap
 | `com.fasterxml.jackson.core:jackson-databind`
 | `log4j2.json` + `log4j2.jsn`
 |===
+
+
+
+[[howto.logging.log4j.composite-configuration]]
+==== Use Composite Configuration to Configure Log4j 2
+Log4j 2 has support for combining multiple configuration files into a single composite configuration.
+To use this support in Spring Boot, configure configprop:logging.log4j2.config.override[] with the locations of one or more secondary configuration files.
+The secondary configuration files will be merged with the primary configuration, whether the primary's source is Spring Boot's defaults, a standard location such as `log4j.xml`, or the location configured by the configprop:logging.config[] property.

spring-boot-project/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2LoggingSystem.java

@@ -25,6 +25,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
@@ -38,10 +39,14 @@
 import org.apache.logging.log4j.core.config.ConfigurationFactory;
 import org.apache.logging.log4j.core.config.ConfigurationSource;
 import org.apache.logging.log4j.core.config.LoggerConfig;
+import org.apache.logging.log4j.core.config.composite.CompositeConfiguration;
 import org.apache.logging.log4j.core.filter.AbstractFilter;
 import org.apache.logging.log4j.core.util.NameUtil;
 import org.apache.logging.log4j.message.Message;
 
+import org.springframework.boot.context.properties.bind.BindResult;
+import org.springframework.boot.context.properties.bind.Bindable;
+import org.springframework.boot.context.properties.bind.Binder;
 import org.springframework.boot.logging.LogFile;
 import org.springframework.boot.logging.LogLevel;
 import org.springframework.boot.logging.LoggerConfiguration;
@@ -53,6 +58,7 @@
 import org.springframework.core.annotation.Order;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
+import org.springframework.util.CollectionUtils;
 import org.springframework.util.ResourceUtils;
 import org.springframework.util.StringUtils;
 
@@ -167,33 +173,70 @@ public void initialize(LoggingInitializationContext initializationContext, Strin
 	@Override
 	protected void loadDefaults(LoggingInitializationContext initializationContext, LogFile logFile) {
 		if (logFile != null) {
-			loadConfiguration(getPackagedConfigFile("log4j2-file.xml"), logFile);
+			loadConfiguration(getPackagedConfigFile("log4j2-file.xml"), logFile, getOverrides(initializationContext));
 		}
 		else {
-			loadConfiguration(getPackagedConfigFile("log4j2.xml"), logFile);
+			loadConfiguration(getPackagedConfigFile("log4j2.xml"), logFile, getOverrides(initializationContext));
 		}
 	}
 
+	private List<String> getOverrides(LoggingInitializationContext initializationContext) {
+		BindResult<List<String>> overrides = Binder.get(initializationContext.getEnvironment())
+				.bind("logging.log4j2.config.override", Bindable.listOf(String.class));
+		return overrides.orElse(Collections.emptyList());
+	}
+
 	@Override
 	protected void loadConfiguration(LoggingInitializationContext initializationContext, String location,
 			LogFile logFile) {
 		super.loadConfiguration(initializationContext, location, logFile);
-		loadConfiguration(location, logFile);
+		loadConfiguration(location, logFile, getOverrides(initializationContext));
 	}
 
+	/**
+	 * Load the configuration from the given {@code location}.
+	 * @param location the location
+	 * @param logFile log file configuration
+	 * @deprecated since 2.6.0 for removal in 2.8.0 in favor of
+	 * {@link #loadConfiguration(String, LogFile, List)}
+	 */
+	@Deprecated
 	protected void loadConfiguration(String location, LogFile logFile) {
+		this.loadConfiguration(location, logFile, Collections.emptyList());
+	}
+
+	/**
+	 * Load the configuration from the given {@code location}, creating a composite using
+	 * the configuration from the given {@code overrides}.
+	 * @param location the location
+	 * @param logFile log file configuration
+	 * @param overrides the overriding locations
+	 * @since 2.6.0
+	 */
+	protected void loadConfiguration(String location, LogFile logFile, List<String> overrides) {
 		Assert.notNull(location, "Location must not be null");
 		try {
-			LoggerContext ctx = getLoggerContext();
-			URL url = ResourceUtils.getURL(location);
-			ConfigurationSource source = getConfigurationSource(url);
-			ctx.start(ConfigurationFactory.getInstance().getConfiguration(ctx, source));
+			List<Configuration> configurations = new ArrayList<>();
+			LoggerContext context = getLoggerContext();
+			configurations.add(load(location, context));
+			for (String override : overrides) {
+				configurations.add(load(override, context));
+			}
+			Configuration configuration = (configurations.size() > 1) ? createComposite(configurations)
+					: configurations.iterator().next();
+			context.start(configuration);
 		}
 		catch (Exception ex) {
 			throw new IllegalStateException("Could not initialize Log4J2 logging from " + location, ex);
 		}
 	}
 
+	private Configuration load(String location, LoggerContext context) throws IOException {
+		URL url = ResourceUtils.getURL(location);
+		ConfigurationSource source = getConfigurationSource(url);
+		return ConfigurationFactory.getInstance().getConfiguration(context, source);
+	}
+
 	private ConfigurationSource getConfigurationSource(URL url) throws IOException {
 		InputStream stream = url.openStream();
 		if (FILE_PROTOCOL.equals(url.getProtocol())) {
@@ -202,9 +245,38 @@ private ConfigurationSource getConfigurationSource(URL url) throws IOException {
 		return new ConfigurationSource(stream, url);
 	}
 
+	private CompositeConfiguration createComposite(List<Configuration> configurations) {
+		return new CompositeConfiguration(
+				configurations.stream().map(AbstractConfiguration.class::cast).collect(Collectors.toList()));
+	}
+
 	@Override
 	protected void reinitialize(LoggingInitializationContext initializationContext) {
-		getLoggerContext().reconfigure();
+		List<String> overrides = getOverrides(initializationContext);
+		if (!CollectionUtils.isEmpty(overrides)) {
+			reinitializeWithOverrides(overrides);
+		}
+		else {
+			LoggerContext context = getLoggerContext();
+			context.reconfigure();
+		}
+	}
+
+	private void reinitializeWithOverrides(List<String> overrides) {
+		LoggerContext context = getLoggerContext();
+		Configuration base = context.getConfiguration();
+		List<AbstractConfiguration> configurations = new ArrayList<>();
+		configurations.add((AbstractConfiguration) base);
+		for (String override : overrides) {
+			try {
+				configurations.add((AbstractConfiguration) load(override, context));
+			}
+			catch (IOException ex) {
+				throw new RuntimeException("Failed to load overriding configuration from '" + override + "'", ex);
+			}
+		}
+		CompositeConfiguration composite = new CompositeConfiguration(configurations);
+		context.reconfigure(composite);
 	}
 
 	@Override

spring-boot-project/spring-boot/src/main/resources/META-INF/additional-spring-configuration-metadata.json

@@ -198,6 +198,11 @@
       "sourceType": "org.springframework.boot.context.logging.LoggingApplicationListener",
       "defaultValue": 7
     },
+    {
+      "name": "logging.log4j2.config.override",
+      "type": "java.util.List<java.lang.String>",
+      "description": "Overriding configuration files used to create a composite configuration."
+    },
     {
       "name": "spring.application.index",
       "type": "java.lang.Integer",