Rationalize Logback logging properties

Deprecate and provide alternatives for logging properties that are
specific to Logback.

The following Spring Boot properties have been changed:

  * logging.pattern.rolling-file-name ->
    logging.logback.rollingpolicy.file-name-pattern

  * logging.file.clean-history-on-start ->
    logging.logback.rollingpolicy.clean-history-on-start

  * logging.file.max-size ->
    logging.logback.rollingpolicy.max-file-size

  * logging.file.total-size-cap ->
    logging.logback.rollingpolicy.total-size-cap

  * logging.file.max-history ->
    logging.logback.rollingpolicy.max-history

As have the system environment properties that they map to:

  * ROLLING_FILE_NAME_PATTERN ->
    LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN

  * LOG_FILE_CLEAN_HISTORY_ON_START ->
    LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START

  * LOG_FILE_MAX_SIZE ->
    LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE

  * LOG_FILE_TOTAL_SIZE_CAP ->
    LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP

  * LOG_FILE_MAX_HISTORY ->
    LOGBACK_ROLLINGPOLICY_MAX_HISTORY

This commit also cleans up and simplifies `DefaultLogbackConfiguration`.

Closes gh-23609

Author: philwebb

spring-boot-project/spring-boot-docs/src/docs/asciidoc/spring-boot-features.adoc

@@ -2040,17 +2040,40 @@ The following table shows how the `logging.*` properties can be used together:
 |===
 
 Log files rotate when they reach 10 MB and, as with console output, `ERROR`-level, `WARN`-level, and `INFO`-level messages are logged by default.
-Size limits can be changed using the configprop:logging.file.max-size[] property.
-Rotated log files of the last 7 days are kept by default unless the configprop:logging.file.max-history[] property has been set.
-The total size of log archives can be capped using configprop:logging.file.total-size-cap[].
-When the total size of log archives exceeds that threshold, backups will be deleted.
-To force log archive cleanup on application startup, use the configprop:logging.file.clean-history-on-start[] property.
 
 TIP: Logging properties are independent of the actual logging infrastructure.
 As a result, specific configuration keys (such as `logback.configurationFile` for Logback) are not managed by spring Boot.
 
 
 
+[[boot-features-logging-file-rotation]]
+=== File Rotation
+If you are using the Logback, it's possible to fine-tune log rotation settings using your `application.properties` or `application.yaml` file.
+For all other logging system, you'll need to configure rotation settings directly yourself (for example, if you use Log4J2 then you could add a `log4j.xml` file).
+
+The following rotation policy properties are supported:
+
+|===
+| Name | Description
+
+| configprop:logging.logback.rollingpolicy.file-name-pattern[]
+| The filename pattern used to create log archives.
+
+| configprop:logging.logback.rollingpolicy.clean-history-on-start[]
+| If log archive cleanup should occur when the application starts.
+
+| configprop:logging.logback.rollingpolicy.max-file-size[]
+| The maximum size of log file before it's archived.
+
+| configprop:logging.logback.rollingpolicy.total-size-cap[]
+| The maximum amount of size log archives can take before being deleted.
+
+| configprop:logging.logback.rollingpolicy.max-history[]
+| The number of days to keep log archives (defaults to 7)
+|===
+
+
+
 [[boot-features-custom-log-levels]]
 === Log Levels
 All the supported logging systems can have the logger levels set in the Spring `Environment` (for example, in `application.properties`) by using `+logging.level.<logger-name>=<level>+` where `level` is one of TRACE, DEBUG, INFO, WARN, ERROR, FATAL, or OFF.
@@ -2165,64 +2188,62 @@ To help with the customization, some other properties are transferred from the S
 | `LOG_EXCEPTION_CONVERSION_WORD`
 | The conversion word used when logging exceptions.
 
-| configprop:logging.file.clean-history-on-start[]
-| `LOG_FILE_CLEAN_HISTORY_ON_START`
-| Whether to clean the archive log files on startup (if LOG_FILE enabled).
-  (Only supported with the default Logback setup.)
-
 | configprop:logging.file.name[]
 | `LOG_FILE`
 | If defined, it is used in the default log configuration.
 
-| configprop:logging.file.max-size[]
-| `LOG_FILE_MAX_SIZE`
-| Maximum log file size (if LOG_FILE enabled).
-  (Only supported with the default Logback setup.)
-
-| configprop:logging.file.max-history[]
-| `LOG_FILE_MAX_HISTORY`
-| Maximum number of archive log files to keep (if LOG_FILE enabled).
-  (Only supported with the default Logback setup.)
-
 | configprop:logging.file.path[]
 | `LOG_PATH`
 | If defined, it is used in the default log configuration.
 
-| configprop:logging.file.total-size-cap[]
-| `LOG_FILE_TOTAL_SIZE_CAP`
-| Total size of log backups to be kept (if LOG_FILE enabled).
-  (Only supported with the default Logback setup.)
-
 | configprop:logging.pattern.console[]
 | `CONSOLE_LOG_PATTERN`
 | The log pattern to use on the console (stdout).
-  (Only supported with the default Logback setup.)
 
 | configprop:logging.pattern.dateformat[]
 | `LOG_DATEFORMAT_PATTERN`
 | Appender pattern for log date format.
-  (Only supported with the default Logback setup.)
 
 | configprop:logging.pattern.file[]
 | `FILE_LOG_PATTERN`
 | The log pattern to use in a file (if `LOG_FILE` is enabled).
-  (Only supported with the default Logback setup.)
 
 | configprop:logging.pattern.level[]
 | `LOG_LEVEL_PATTERN`
 | The format to use when rendering the log level (default `%5p`).
-  (Only supported with the default Logback setup.)
-
-| configprop:logging.pattern.rolling-file-name[]
-| `ROLLING_FILE_NAME_PATTERN`
-| Pattern for rolled-over log file names (default `$\{LOG_FILE}.%d\{yyyy-MM-dd}.%i.gz`).
-  (Only supported with the default Logback setup.)
 
 | `PID`
 | `PID`
 | The current process ID (discovered if possible and when not already defined as an OS environment variable).
 |===
 
+If you're using Logback, the following properties are also transfered:
+
+|===
+| Spring Environment | System Property | Comments
+
+| configprop:logging.logback.rollingpolicy.file-name-pattern[]
+| `LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN`
+| Pattern for rolled-over log file names (default `$\{LOG_FILE}.%d\{yyyy-MM-dd}.%i.gz`).
+
+| configprop:logging.logback.rollingpolicy.clean-history-on-start[]
+| `LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START`
+| Whether to clean the archive log files on startup.
+
+| configprop:logging.logback.rollingpolicy.max-file-size[]
+| `LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE`
+| Maximum log file size.
+
+| configprop:logging.logback.rollingpolicy.total-size-cap[]
+| `LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP`
+| Total size of log backups to be kept.
+
+| configprop:logging.logback.rollingpolicy.max-history[]
+| `LOGBACK_ROLLINGPOLICY_MAX_HISTORY`
+| Maximum number of archive log files to keep.
+|===
+
+
 All the supported logging systems can consult System properties when parsing their configuration files.
 See the default configurations in `spring-boot.jar` for examples:
 

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

@@ -271,7 +271,7 @@ private void onApplicationFailedEvent() {
 	 * @param classLoader the classloader
 	 */
 	protected void initialize(ConfigurableEnvironment environment, ClassLoader classLoader) {
-		new LoggingSystemProperties(environment).apply();
+		getLoggingSystemProperties(environment).apply();
 		this.logFile = LogFile.get(environment);
 		if (this.logFile != null) {
 			this.logFile.applyToSystemProperties();
@@ -283,6 +283,11 @@ protected void initialize(ConfigurableEnvironment environment, ClassLoader class
 		registerShutdownHookIfNecessary(environment, this.loggingSystem);
 	}
 
+	private LoggingSystemProperties getLoggingSystemProperties(ConfigurableEnvironment environment) {
+		return (this.loggingSystem != null) ? this.loggingSystem.getSystemProperties(environment)
+				: new LoggingSystemProperties(environment);
+	}
+
 	private void initializeEarlyLoggingLevel(ConfigurableEnvironment environment) {
 		if (this.parseArgs && this.springBootLogging == null) {
 			if (isSet(environment, "debug")) {

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

@@ -22,6 +22,7 @@
 import java.util.List;
 import java.util.Set;
 
+import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
@@ -57,6 +58,16 @@ public abstract class LoggingSystem {
 
 	private static final LoggingSystemFactory SYSTEM_FACTORY = LoggingSystemFactory.fromSpringFactories();
 
+	/**
+	 * Return the {@link LoggingSystemProperties} that should be applied.
+	 * @param environment the {@link ConfigurableEnvironment} used to obtain value
+	 * @return the {@link LoggingSystemProperties} to apply
+	 * @since 2.4.0
+	 */
+	public LoggingSystemProperties getSystemProperties(ConfigurableEnvironment environment) {
+		return new LoggingSystemProperties(environment);
+	}
+
 	/**
 	 * Reset the logging system to be limit output. This method may be called before
 	 * {@link #initialize(LoggingInitializationContext, String, LogFile)} to reduce

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2019 the original author or authors.
+ * Copyright 2012-2020 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.
@@ -62,30 +62,51 @@ public class LoggingSystemProperties {
 	public static final String CONSOLE_LOG_PATTERN = "CONSOLE_LOG_PATTERN";
 
 	/**
-	 * The name of the System property that contains the clean history on start flag.
+	 * The name of the System property that contains the file log pattern.
 	 */
-	public static final String FILE_CLEAN_HISTORY_ON_START = "LOG_FILE_CLEAN_HISTORY_ON_START";
+	public static final String FILE_LOG_PATTERN = "FILE_LOG_PATTERN";
 
 	/**
-	 * The name of the System property that contains the file log pattern.
+	 * The name of the System property that contains the rolled-over log file name
+	 * pattern.
+	 * @deprecated since 2.4.0 in favor of
+	 * {@link org.springframework.boot.logging.logback.LogbackLoggingSystemProperties#ROLLINGPOLICY_FILE_NAME_PATTERN}
 	 */
-	public static final String FILE_LOG_PATTERN = "FILE_LOG_PATTERN";
+	@Deprecated
+	public static final String ROLLING_FILE_NAME_PATTERN = "ROLLING_FILE_NAME_PATTERN";
 
 	/**
-	 * The name of the System property that contains the file log max history.
+	 * The name of the System property that contains the clean history on start flag.
+	 * @deprecated since 2.4.0 in favor of
+	 * {@link org.springframework.boot.logging.logback.LogbackLoggingSystemProperties#ROLLINGPOLICY_CLEAN_HISTORY_ON_START}
 	 */
-	public static final String FILE_MAX_HISTORY = "LOG_FILE_MAX_HISTORY";
+	@Deprecated
+	public static final String FILE_CLEAN_HISTORY_ON_START = "LOG_FILE_CLEAN_HISTORY_ON_START";
 
 	/**
 	 * The name of the System property that contains the file log max size.
+	 * @deprecated since 2.4.0 in favor of
+	 * {@link org.springframework.boot.logging.logback.LogbackLoggingSystemProperties#ROLLINGPOLICY_MAX_FILE_SIZE}
 	 */
+	@Deprecated
 	public static final String FILE_MAX_SIZE = "LOG_FILE_MAX_SIZE";
 
 	/**
 	 * The name of the System property that contains the file total size cap.
+	 * @deprecated since 2.4.0 in favor of
+	 * {@link org.springframework.boot.logging.logback.LogbackLoggingSystemProperties#ROLLINGPOLICY_TOTAL_SIZE_CAP}
 	 */
+	@Deprecated
 	public static final String FILE_TOTAL_SIZE_CAP = "LOG_FILE_TOTAL_SIZE_CAP";
 
+	/**
+	 * The name of the System property that contains the file log max history.
+	 * @deprecated since 2.4.0 in favor of
+	 * {@link org.springframework.boot.logging.logback.LogbackLoggingSystemProperties#ROLLINGPOLICY_MAX_HISTORY}
+	 */
+	@Deprecated
+	public static final String FILE_MAX_HISTORY = "LOG_FILE_MAX_HISTORY";
+
 	/**
 	 * The name of the System property that contains the log level pattern.
 	 */
@@ -96,12 +117,6 @@ public class LoggingSystemProperties {
 	 */
 	public static final String LOG_DATEFORMAT_PATTERN = "LOG_DATEFORMAT_PATTERN";
 
-	/**
-	 * The name of the System property that contains the rolled-over log file name
-	 * pattern.
-	 */
-	public static final String ROLLING_FILE_NAME_PATTERN = "ROLLING_FILE_NAME_PATTERN";
-
 	private final Environment environment;
 
 	/**
@@ -113,43 +128,52 @@ public LoggingSystemProperties(Environment environment) {
 		this.environment = environment;
 	}
 
-	public void apply() {
+	public final void apply() {
 		apply(null);
 	}
 
-	public void apply(LogFile logFile) {
+	public final void apply(LogFile logFile) {
 		PropertyResolver resolver = getPropertyResolver();
-		setSystemProperty(resolver, EXCEPTION_CONVERSION_WORD, "exception-conversion-word");
+		apply(logFile, resolver);
+	}
+
+	protected void apply(LogFile logFile, PropertyResolver resolver) {
+		setSystemProperty(resolver, EXCEPTION_CONVERSION_WORD, "logging.exception-conversion-word");
 		setSystemProperty(PID_KEY, new ApplicationPid().toString());
-		setSystemProperty(resolver, CONSOLE_LOG_PATTERN, "pattern.console");
-		setSystemProperty(resolver, FILE_LOG_PATTERN, "pattern.file");
-		setSystemProperty(resolver, FILE_CLEAN_HISTORY_ON_START, "file.clean-history-on-start");
-		setSystemProperty(resolver, FILE_MAX_HISTORY, "file.max-history");
-		setSystemProperty(resolver, FILE_MAX_SIZE, "file.max-size");
-		setSystemProperty(resolver, FILE_TOTAL_SIZE_CAP, "file.total-size-cap");
-		setSystemProperty(resolver, LOG_LEVEL_PATTERN, "pattern.level");
-		setSystemProperty(resolver, LOG_DATEFORMAT_PATTERN, "pattern.dateformat");
-		setSystemProperty(resolver, ROLLING_FILE_NAME_PATTERN, "pattern.rolling-file-name");
+		setSystemProperty(resolver, CONSOLE_LOG_PATTERN, "logging.pattern.console");
+		setSystemProperty(resolver, LOG_DATEFORMAT_PATTERN, "logging.pattern.dateformat");
+		setSystemProperty(resolver, FILE_LOG_PATTERN, "logging.pattern.file");
+		setSystemProperty(resolver, LOG_LEVEL_PATTERN, "logging.pattern.level");
+		applyDeprecated(resolver);
 		if (logFile != null) {
 			logFile.applyToSystemProperties();
 		}
 	}
 
+	private void applyDeprecated(PropertyResolver resolver) {
+		setSystemProperty(resolver, FILE_CLEAN_HISTORY_ON_START, "logging.file.clean-history-on-start");
+		setSystemProperty(resolver, FILE_MAX_HISTORY, "logging.file.max-history");
+		setSystemProperty(resolver, FILE_MAX_SIZE, "logging.file.max-size");
+		setSystemProperty(resolver, FILE_TOTAL_SIZE_CAP, "logging.file.total-size-cap");
+		setSystemProperty(resolver, ROLLING_FILE_NAME_PATTERN, "logging.pattern.rolling-file-name");
+	}
+
 	private PropertyResolver getPropertyResolver() {
 		if (this.environment instanceof ConfigurableEnvironment) {
 			PropertySourcesPropertyResolver resolver = new PropertySourcesPropertyResolver(
 					((ConfigurableEnvironment) this.environment).getPropertySources());
+			resolver.setConversionService(((ConfigurableEnvironment) this.environment).getConversionService());
 			resolver.setIgnoreUnresolvableNestedPlaceholders(true);
 			return resolver;
 		}
 		return this.environment;
 	}
 
-	private void setSystemProperty(PropertyResolver resolver, String systemPropertyName, String propertyName) {
-		setSystemProperty(systemPropertyName, resolver.getProperty("logging." + propertyName));
+	protected final void setSystemProperty(PropertyResolver resolver, String systemPropertyName, String propertyName) {
+		setSystemProperty(systemPropertyName, resolver.getProperty(propertyName));
 	}
 
-	private void setSystemProperty(String name, String value) {
+	protected final void setSystemProperty(String name, String value) {
 		if (System.getProperty(name) == null && value != null) {
 			System.setProperty(name, value);
 		}