Always reinitialize logging system

Update LoggingSystems so that they can reinitialize themselves
before logging begins. This allows reset of the root logger (which
may have been set to OFF in beforeInitialize) and also re-evaluation
of systems properties such as PID which may not have been set when
logging configuration was first loaded.

This commit may possibly reintroduce gh-1091, but it seems like
reloading is our only option.

Fixes gh-2125

Author: philwebb

spring-boot/src/main/java/org/springframework/boot/logging/AbstractLoggingSystem.java

@@ -56,6 +56,9 @@ else if (logFile != null) {
 				// Self initialization has occurred but the file has changed, reload
 				loadConfiguration(selfInitializationConfig, logFile);
 			}
+			else {
+				reinitialize();
+			}
 		}
 	}
 
@@ -93,6 +96,15 @@ protected String getSelfInitializationConfig() {
 	 */
 	protected abstract void loadConfiguration(String location, LogFile logFile);
 
+	/**
+	 * Reinitialize the logging system if required. Called when
+	 * {@link #getSelfInitializationConfig()} is used and the log file hasn't changed. May
+	 * be used to reload configuration (for example to pickup additional System
+	 * properties).
+	 */
+	protected void reinitialize() {
+	}
+
 	protected final ClassLoader getClassLoader() {
 		return this.classLoader;
 	}

spring-boot/src/main/java/org/springframework/boot/logging/LoggingApplicationListener.java

@@ -33,7 +33,6 @@
 import org.springframework.core.Ordered;
 import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.Environment;
-import org.springframework.util.ClassUtils;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
 import org.springframework.util.ResourceUtils;
@@ -98,6 +97,8 @@ public class LoggingApplicationListener implements SmartApplicationListener {
 
 	private final Log logger = LogFactory.getLog(getClass());
 
+	private LoggingSystem loggingSystem;
+
 	private int order = Ordered.HIGHEST_PRECEDENCE + 11;
 
 	private boolean parseArgs = true;
@@ -126,10 +127,16 @@ else if (event instanceof ApplicationEnvironmentPreparedEvent) {
 	}
 
 	private void onApplicationStartedEvent(ApplicationStartedEvent event) {
-		LoggingSystem.get(ClassUtils.getDefaultClassLoader()).beforeInitialize();
+		this.loggingSystem = LoggingSystem.get(event.getSpringApplication()
+				.getClassLoader());
+		this.loggingSystem.beforeInitialize();
 	}
 
 	private void onApplicationPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
+		if (this.loggingSystem == null) {
+			this.loggingSystem = LoggingSystem.get(event.getSpringApplication()
+					.getClassLoader());
+		}
 		initialize(event.getEnvironment(), event.getSpringApplication().getClassLoader());
 	}
 
@@ -142,9 +149,8 @@ protected void initialize(ConfigurableEnvironment environment, ClassLoader class
 			System.setProperty(PID_KEY, new ApplicationPid().toString());
 		}
 		initializeEarlyLoggingLevel(environment);
-		LoggingSystem system = LoggingSystem.get(classLoader);
-		initializeSystem(environment, system);
-		initializeFinalLoggingLevels(environment, system);
+		initializeSystem(environment, this.loggingSystem);
+		initializeFinalLoggingLevels(environment, this.loggingSystem);
 	}
 
 	private void initializeEarlyLoggingLevel(ConfigurableEnvironment environment) {

spring-boot/src/main/java/org/springframework/boot/logging/LoggingSystem.java

@@ -46,8 +46,8 @@ public abstract class LoggingSystem {
 
 	/**
 	 * Reset the logging system to be limit output. This method may be called before
-	 * {@link #initialize(String, LogFile)} to reduce logging noise until the
-	 * systems has been fully Initialized.
+	 * {@link #initialize(String, LogFile)} to reduce logging noise until the system has
+	 * been fully Initialized.
 	 */
 	public abstract void beforeInitialize();
 

spring-boot/src/main/java/org/springframework/boot/logging/log4j/Log4JLoggingSystem.java

@@ -92,6 +92,11 @@ protected void loadConfiguration(String location, LogFile logFile) {
 		}
 	}
 
+	@Override
+	protected void reinitialize() {
+		loadConfiguration(getSelfInitializationConfig(), null);
+	}
+
 	@Override
 	public void setLogLevel(String loggerName, LogLevel level) {
 		Logger logger = (StringUtils.hasLength(loggerName) ? LogManager

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

@@ -23,9 +23,16 @@
 
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
 import org.apache.logging.log4j.core.LoggerContext;
 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.filter.AbstractFilter;
+import org.apache.logging.log4j.message.Message;
 import org.springframework.boot.logging.LogFile;
 import org.springframework.boot.logging.LogLevel;
 import org.springframework.boot.logging.LoggingSystem;
@@ -55,6 +62,33 @@ public class Log4J2LoggingSystem extends Slf4JLoggingSystem {
 		LEVELS = Collections.unmodifiableMap(levels);
 	}
 
+	private static final Filter FILTER = new AbstractFilter() {
+
+		@Override
+		public Result filter(LogEvent event) {
+			return Result.DENY;
+		};
+
+		@Override
+		public Result filter(Logger logger, Level level, Marker marker, Message msg,
+				Throwable t) {
+			return Result.DENY;
+		};
+
+		@Override
+		public Result filter(Logger logger, Level level, Marker marker, Object msg,
+				Throwable t) {
+			return Result.DENY;
+		};
+
+		@Override
+		public Result filter(Logger logger, Level level, Marker marker, String msg,
+				Object... params) {
+			return Result.DENY;
+		};
+
+	};
+
 	public Log4J2LoggingSystem(ClassLoader classLoader) {
 		super(classLoader);
 	}
@@ -67,7 +101,13 @@ protected String[] getStandardConfigLocations() {
 	@Override
 	public void beforeInitialize() {
 		super.beforeInitialize();
-		setLogLevel("", LogLevel.FATAL);
+		getLoggerConfig(null).addFilter(FILTER);
+	}
+
+	@Override
+	public void initialize(String configLocation, LogFile logFile) {
+		getLoggerConfig(null).removeFilter(FILTER);
+		super.initialize(configLocation, logFile);
 	}
 
 	@Override
@@ -87,7 +127,7 @@ protected void loadConfiguration(String location, LogFile logFile) {
 			logFile.applyToSystemProperties();
 		}
 		try {
-			LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
+			LoggerContext ctx = getLoggerContext();
 			URL url = ResourceUtils.getURL(location);
 			ConfigurationSource source = new ConfigurationSource(url.openStream(), url);
 			ctx.start(ConfigurationFactory.getInstance().getConfiguration(source));
@@ -98,12 +138,25 @@ protected void loadConfiguration(String location, LogFile logFile) {
 		}
 	}
 
+	@Override
+	protected void reinitialize() {
+		getLoggerContext().reconfigure();
+	}
+
 	@Override
 	public void setLogLevel(String loggerName, LogLevel level) {
-		LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
-		ctx.getConfiguration().getLoggerConfig(loggerName == null ? "" : loggerName)
-				.setLevel(LEVELS.get(level));
-		ctx.updateLoggers();
+		getLoggerConfig(loggerName).setLevel(LEVELS.get(level));
+		getLoggerContext().updateLoggers();
+	}
+
+	private LoggerConfig getLoggerConfig(String loggerName) {
+		LoggerConfig loggerConfig = getLoggerContext().getConfiguration()
+				.getLoggerConfig(loggerName == null ? "" : loggerName);
+		return loggerConfig;
+	}
+
+	private LoggerContext getLoggerContext() {
+		return (LoggerContext) LogManager.getContext(false);
 	}
 
 }

spring-boot/src/main/java/org/springframework/boot/logging/logback/LogbackLoggingSystem.java

@@ -124,6 +124,12 @@ protected void loadConfiguration(String location, LogFile logFile) {
 		}
 	}
 
+	@Override
+	protected void reinitialize() {
+		getLoggerContext().reset();
+		loadConfiguration(getSelfInitializationConfig(), null);
+	}
+
 	private void configureJBossLoggingToUseSlf4j() {
 		System.setProperty("org.jboss.logging.provider", "slf4j");
 	}