Merge pull request #47424 from ppkarwasz

* pr/47424:
  Polish 'Simplify Log4J2LoggingSystem'
  Simplify Log4J2LoggingSystem

Closes gh-47424

Author: philwebb

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

@@ -18,9 +18,6 @@
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
-import java.net.URL;
-import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.LinkedHashMap;
@@ -37,15 +34,11 @@
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.AbstractConfiguration;
 import org.apache.logging.log4j.core.config.Configuration;
+import org.apache.logging.log4j.core.config.ConfigurationException;
 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.DenyAllFilter;
-import org.apache.logging.log4j.core.net.UrlConnectionFactory;
-import org.apache.logging.log4j.core.net.ssl.SslConfiguration;
-import org.apache.logging.log4j.core.net.ssl.SslConfigurationFactory;
-import org.apache.logging.log4j.core.util.AuthorizationProvider;
 import org.apache.logging.log4j.core.util.NameUtil;
 import org.apache.logging.log4j.jul.Log4jBridgeHandler;
 import org.apache.logging.log4j.status.StatusConsoleListener;
@@ -72,7 +65,6 @@
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 
 /**
@@ -100,43 +92,6 @@ public class Log4J2LoggingSystem extends AbstractLoggingSystem {
 	 */
 	static final String LOG4J_LOG_MANAGER = "org.apache.logging.log4j.jul.LogManager";
 
-	/**
-	 * JSON tree parser used by Log4j 2 (optional dependency).
-	 */
-	static final String JSON_TREE_PARSER_V2 = "com.fasterxml.jackson.databind.ObjectMapper";
-
-	/**
-	 * JSON tree parser embedded in Log4j 3.
-	 */
-	static final String JSON_TREE_PARSER_V3 = "org.apache.logging.log4j.kit.json.JsonReader";
-
-	/**
-	 * Configuration factory for properties files (Log4j 2).
-	 */
-	static final String PROPS_CONFIGURATION_FACTORY_V2 = "org.apache.logging.log4j.core.config.properties.PropertiesConfigurationFactory";
-
-	/**
-	 * Configuration factory for properties files (Log4j 3, optional dependency).
-	 */
-	static final String PROPS_CONFIGURATION_FACTORY_V3 = "org.apache.logging.log4j.config.properties.JavaPropsConfigurationFactory";
-
-	/**
-	 * YAML tree parser used by Log4j 2 (optional dependency).
-	 */
-	static final String YAML_TREE_PARSER_V2 = "com.fasterxml.jackson.dataformat.yaml.YAMLMapper";
-
-	/**
-	 * Configuration factory for YAML files (Log4j 2, embedded).
-	 */
-	static final String YAML_CONFIGURATION_FACTORY_V2 = "org.apache.logging.log4j.core.config.yaml.YamlConfigurationFactory";
-
-	/**
-	 * Configuration factory for YAML files (Log4j 3, optional dependency).
-	 */
-	static final String YAML_CONFIGURATION_FACTORY_V3 = "org.apache.logging.log4j.config.yaml.YamlConfigurationFactory";
-
-	private static final SpringEnvironmentPropertySource propertySource = new SpringEnvironmentPropertySource();
-
 	static final String ENVIRONMENT_KEY = Conventions.getQualifiedAttributeName(Log4J2LoggingSystem.class,
 			"environment");
 
@@ -157,78 +112,60 @@ public class Log4J2LoggingSystem extends AbstractLoggingSystem {
 
 	private static final Filter FILTER = DenyAllFilter.newBuilder().build();
 
-	public Log4J2LoggingSystem(ClassLoader classLoader) {
+	private static final SpringEnvironmentPropertySource propertySource = new SpringEnvironmentPropertySource();
+
+	private static final org.apache.logging.log4j.Logger statusLogger = StatusLogger.getLogger();
+
+	private final LoggerContext loggerContext;
+
+	/**
+	 * Create a new {@link Log4J2LoggingSystem} instance.
+	 * @param classLoader the class loader to use.
+	 * @param loggerContext the {@link LoggerContext} to use.
+	 */
+	Log4J2LoggingSystem(ClassLoader classLoader, LoggerContext loggerContext) {
 		super(classLoader);
+		this.loggerContext = loggerContext;
 	}
 
 	@Override
 	protected String[] getStandardConfigLocations() {
-		List<String> locations = new ArrayList<>();
-		addLocationsFromProperties(locations);
-		addStandardLocations(locations);
-		return StringUtils.toStringArray(locations);
-	}
-
-	private void addLocationsFromProperties(List<String> locations) {
-		for (String property : List.of("log4j2.configurationFile", "log4j.configuration.location")) {
-			String propertyDefinedLocation = PropertiesUtil.getProperties().getStringProperty(property);
-			if (propertyDefinedLocation != null) {
-				locations.add(propertyDefinedLocation);
-			}
-		}
+		// With Log4J2 we use the ConfigurationFactory
+		throw new IllegalStateException("Standard config locations cannot be used with Log4J2");
 	}
 
-	private void addStandardLocations(List<String> locations) {
-		LoggerContext loggerContext = getLoggerContext();
-		String contextName = loggerContext.getName();
-		List<String> extensions = getStandardConfigExtensions();
-		addLocation(locations, "log4j2-test" + contextName, extensions);
-		addLocation(locations, "log4j2-test", extensions);
-		addLocation(locations, "log4j2" + contextName, extensions);
-		addLocation(locations, "log4j2", extensions);
+	@Override
+	protected @Nullable String getSelfInitializationConfig() {
+		return getConfigLocation(getLoggerContext().getConfiguration());
 	}
 
-	private List<String> getStandardConfigExtensions() {
-		List<String> extensions = new ArrayList<>();
-		// These classes need to be visible by the classloader that loads Log4j Core.
-		ClassLoader classLoader = LoggerContext.class.getClassLoader();
-		// The order of the extensions corresponds to the order in which Log4j Core 2 and
-		// 3 will try to load them, in decreasing value of @Order.
-		if (isPresent(classLoader, PROPS_CONFIGURATION_FACTORY_V2)
-				|| isPresent(classLoader, PROPS_CONFIGURATION_FACTORY_V3)) {
-			extensions.add(".properties");
-		}
-		if (isPresent(classLoader, YAML_CONFIGURATION_FACTORY_V2, YAML_TREE_PARSER_V2)
-				|| isPresent(classLoader, YAML_CONFIGURATION_FACTORY_V3)) {
-			Collections.addAll(extensions, ".yaml", ".yml");
-		}
-		if (isPresent(classLoader, JSON_TREE_PARSER_V2) || isPresent(classLoader, JSON_TREE_PARSER_V3)) {
-			Collections.addAll(extensions, ".json", ".jsn");
+	@Override
+	protected @Nullable String getSpringInitializationConfig() {
+		ConfigurationFactory configurationFactory = ConfigurationFactory.getInstance();
+		try {
+			Configuration springConfiguration = configurationFactory.getConfiguration(getLoggerContext(), "-spring",
+					null, getClassLoader());
+			String configLocation = getConfigLocation(springConfiguration);
+			return (configLocation != null && configLocation.contains("-spring")) ? configLocation : null;
 		}
-		extensions.add(".xml");
-		return extensions;
-	}
-
-	private void addLocation(List<String> locations, String location, List<String> extensions) {
-		extensions.forEach((extension) -> locations.add(location + extension));
-	}
-
-	private boolean isPresent(ClassLoader classLoader, String... classNames) {
-		for (String className : classNames) {
-			if (!isClassAvailable(classLoader, className)) {
-				return false;
-			}
+		catch (ConfigurationException ex) {
+			statusLogger.warn("Could not load Spring-specific Log4j Core configuration", ex);
+			return null;
 		}
-		return true;
-	}
-
-	protected boolean isClassAvailable(ClassLoader classLoader, String className) {
-		return ClassUtils.isPresent(className, classLoader);
 	}
 
-	@Deprecated(since = "4.0.0", forRemoval = true)
-	protected boolean isClassAvailable(String className) {
-		return ClassUtils.isPresent(className, getClassLoader());
+	/**
+	 * Return the configuration location. The result may be:
+	 * <ul>
+	 * <li>{@code null}: if DefaultConfiguration is used (no explicit config loaded)</li>
+	 * <li>A file path: if provided explicitly by the user</li>
+	 * <li>A URI: if loaded from the classpath default or a custom location</li>
+	 * </ul>
+	 * @param configuration the source configuration
+	 * @return the config location or {@code null}
+	 */
+	private @Nullable String getConfigLocation(Configuration configuration) {
+		return configuration.getConfigurationSource().getLocation();
 	}
 
 	@Override
@@ -335,7 +272,7 @@ private void load(LoggingInitializationContext initializationContext, String loc
 		Environment environment = initializationContext.getEnvironment();
 		Assert.state(environment != null, "'environment' must not be null");
 		applySystemProperties(environment, logFile);
-		loadConfiguration(location, logFile, overrides);
+		reconfigure(location, overrides);
 	}
 
 	private List<String> getOverrides(LoggingInitializationContext initializationContext) {
@@ -346,66 +283,51 @@ private List<String> getOverrides(LoggingInitializationContext initializationCon
 		return overrides.orElse(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, @Nullable LogFile logFile, List<String> overrides) {
+	private void reconfigure(String location, List<String> overrides) {
 		Assert.notNull(location, "'location' must not be null");
 		try {
 			List<Configuration> configurations = new ArrayList<>();
-			LoggerContext context = getLoggerContext();
-			ResourceLoader resourceLoader = ApplicationResourceLoader.get();
-			configurations.add(load(resourceLoader.getResource(location), context));
+			ResourceLoader resourceLoader = ApplicationResourceLoader.get(getClassLoader());
+			configurations.add(load(resourceLoader, location));
 			for (String override : overrides) {
-				Configuration overrideConfiguration = loadOverride(resourceLoader, override, context);
+				Configuration overrideConfiguration = loadOverride(resourceLoader, override);
 				if (overrideConfiguration != null) {
 					configurations.add(overrideConfiguration);
 				}
 			}
-			context.reconfigure(mergeConfigurations(configurations));
+			this.loggerContext.reconfigure(mergeConfigurations(configurations));
 		}
 		catch (Exception ex) {
-			throw new IllegalStateException("Could not initialize Log4J2 logging from " + location, ex);
+			throw new IllegalStateException("Could not initialize Log4J2 logging from %s%s".formatted(location,
+					(overrides.isEmpty() ? "" : " with overrides " + overrides)), ex);
 		}
 	}
 
-	private Configuration load(Resource resource, LoggerContext context) throws IOException {
-		ConfigurationFactory factory = ConfigurationFactory.getInstance();
-		if (resource.isFile()) {
-			try (InputStream inputStream = resource.getInputStream()) {
-				return factory.getConfiguration(context, new ConfigurationSource(inputStream, resource.getFile()));
-			}
-		}
-		URL url = resource.getURL();
-		AuthorizationProvider authorizationProvider = ConfigurationFactory
-			.authorizationProvider(PropertiesUtil.getProperties());
-		SslConfiguration sslConfiguration = url.getProtocol().equals("https")
-				? SslConfigurationFactory.getSslConfiguration() : null;
-		URLConnection connection = UrlConnectionFactory.createConnection(url, 0, sslConfiguration,
-				authorizationProvider);
-		try (InputStream inputStream = connection.getInputStream()) {
-			return factory.getConfiguration(context,
-					new ConfigurationSource(inputStream, url, connection.getLastModified()));
+	private Configuration load(ResourceLoader resourceLoader, String location) throws IOException {
+		ConfigurationFactory configurationFactory = ConfigurationFactory.getInstance();
+		Resource resource = resourceLoader.getResource(location);
+		Configuration configuration = configurationFactory.getConfiguration(getLoggerContext(), null, resource.getURI(),
+				getClassLoader());
+		// The error handling in Log4j Core 2.25.x is not consistent, some loading and
+		// parsing errors result in a null configuration, others in an exception.
+		if (configuration == null) {
+			throw new ConfigurationException("Could not load Log4j Core configuration from " + location);
 		}
+		return configuration;
 	}
 
-	private @Nullable Configuration loadOverride(ResourceLoader resourceLoader, String location, LoggerContext context)
-			throws IOException {
+	private @Nullable Configuration loadOverride(ResourceLoader resourceLoader, String location) throws IOException {
 		if (location.startsWith(OPTIONAL_PREFIX)) {
-			Resource resource = resourceLoader.getResource(location.substring(OPTIONAL_PREFIX.length()));
+			String actualLocation = location.substring(OPTIONAL_PREFIX.length());
+			Resource resource = resourceLoader.getResource(actualLocation);
 			try {
-				return (resource.exists()) ? load(resource, context) : null;
+				return (resource.exists()) ? load(resourceLoader, actualLocation) : null;
 			}
 			catch (FileNotFoundException ex) {
 				return null;
 			}
 		}
-		return load(resourceLoader.getResource(location), context);
+		return load(resourceLoader, location);
 	}
 
 	private Configuration mergeConfigurations(List<Configuration> configurations) {
@@ -417,33 +339,9 @@ private Configuration mergeConfigurations(List<Configuration> configurations) {
 
 	@Override
 	protected void reinitialize(LoggingInitializationContext initializationContext) {
-		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();
-		List<Configuration> configurations = new ArrayList<>();
-		configurations.add(context.getConfiguration());
-		ResourceLoader resourceLoader = ApplicationResourceLoader.get();
-		for (String override : overrides) {
-			try {
-				Configuration overrideConfiguration = loadOverride(resourceLoader, override, context);
-				if (overrideConfiguration != null) {
-					configurations.add(overrideConfiguration);
-				}
-			}
-			catch (IOException ex) {
-				throw new RuntimeException("Failed to load overriding configuration from '" + override + "'", ex);
-			}
-		}
-		context.reconfigure(mergeConfigurations(configurations));
+		String currentLocation = getSelfInitializationConfig();
+		Assert.notNull(currentLocation, "'currentLocation' must not be null");
+		load(initializationContext, currentLocation, null);
 	}
 
 	@Override
@@ -584,8 +482,8 @@ public void cleanUp() {
 		return configuration.getLoggers().get(name);
 	}
 
-	private LoggerContext getLoggerContext() {
-		return (LoggerContext) LogManager.getContext(false);
+	LoggerContext getLoggerContext() {
+		return this.loggerContext;
 	}
 
 	private boolean isAlreadyInitialized(LoggerContext loggerContext) {
@@ -630,7 +528,11 @@ public static class Factory implements LoggingSystemFactory {
 		@Override
 		public @Nullable LoggingSystem getLoggingSystem(ClassLoader classLoader) {
 			if (PRESENT) {
-				return new Log4J2LoggingSystem(classLoader);
+				org.apache.logging.log4j.spi.LoggerContext spiLoggerContext = LogManager.getContext(classLoader, false);
+				Assert.state(spiLoggerContext instanceof LoggerContext, "");
+				if (spiLoggerContext instanceof LoggerContext coreLoggerContext) {
+					return new Log4J2LoggingSystem(classLoader, coreLoggerContext);
+				}
 			}
 			return null;
 		}

core/spring-boot/src/main/java/org/springframework/boot/logging/log4j2/Log4J2RuntimeHints.java

@@ -44,13 +44,6 @@ private void registerLog4j2Hints(RuntimeHints hints, @Nullable ClassLoader class
 		hints.resources().registerPattern("org/springframework/boot/logging/log4j2/log4j2-file.xml");
 		hints.resources().registerPattern("log4j2.springboot");
 		// Declares the types that Log4j2LoggingSystem checks for existence reflectively.
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.JSON_TREE_PARSER_V2);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.JSON_TREE_PARSER_V3);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.PROPS_CONFIGURATION_FACTORY_V2);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.PROPS_CONFIGURATION_FACTORY_V3);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.YAML_TREE_PARSER_V2);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.YAML_CONFIGURATION_FACTORY_V2);
-		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.YAML_CONFIGURATION_FACTORY_V3);
 		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.LOG4J_BRIDGE_HANDLER);
 		hints.reflection().registerTypeIfPresent(classLoader, Log4J2LoggingSystem.LOG4J_LOG_MANAGER);
 	}