Use SizeAndTimeBasedRollingPolicy for default file appender

Previously, `FixedWindowRollingPolicy` with size limit of 10 MB was used as default file appender.

This commit changes the default file appender to use `SizeAndTimeBasedRollingPolicy` and introduces two new properties to improve log file configuration capabilities - `logging.file.max-history` to limit the number of archive log files to keep and `logging.file.max-size` to limit the log file size.

Author: vpavic

spring-boot-docs/src/main/asciidoc/appendix-application-properties.adoc

@@ -41,6 +41,8 @@ content into your application; rather pick only the properties that you need.
 	logging.config= # Location of the logging configuration file. For instance `classpath:logback.xml` for Logback
 	logging.exception-conversion-word=%wEx # Conversion word used when logging exceptions.
 	logging.file= # Log file name. For instance `myapp.log`
+	logging.file.max-history= # Maximum of archive log files to keep. Only supported with the default logback setup.
+	logging.file.max-size= # Maximum log file size. Only supported with the default logback setup.
 	logging.level.*= # Log levels severity mapping. For instance `logging.level.org.springframework=DEBUG`
 	logging.path= # Location of the log file. For instance `/var/log`
 	logging.pattern.console= # Appender pattern for output to the console. Only supported with the default logback setup.

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

@@ -1304,8 +1304,13 @@ current directory.
 relative to the current directory.
 |===
 
-Log files will rotate when they reach 10 Mb and as with console output, `ERROR`, `WARN`
-and `INFO` level messages are logged by default.
+Log files will rotate daily and, in addition to time limit, when they reach the size limit
+which is 10 MB by default. Size limit can be changed using `logging.file.max-size`
+property. By default, archived log file is unbounded meaning entire history will be
+preserved. You can use `logging.file.max-history` property to limit the number of archive
+files to keep.
+
+As with console output, `ERROR`, `WARN` and `INFO` level messages are logged by default.
 
 NOTE: The logging system is initialized early in the application lifecycle and as such
 logging properties will not be found in property files loaded via `@PropertySource`
@@ -1392,6 +1397,14 @@ To help with the customization some other properties are transferred from the Sp
 |`LOG_FILE`
 |Used in default log configuration if defined.
 
+|`logging.file.max-size`
+|`LOG_FILE_MAX_SIZE`
+|Maximum log file size (if LOG_FILE enabled). (Only supported with the default logback setup.)
+
+|`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.)
+
 |`logging.path`
 |`LOG_PATH`
 |Used in default log configuration if defined.

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

@@ -136,6 +136,16 @@ public class LoggingApplicationListener implements GenericApplicationListener {
 	 */
 	public static final String FILE_LOG_PATTERN = LoggingSystemProperties.FILE_LOG_PATTERN;
 
+	/**
+	 * The name of the System property that contains the file log max history.
+	 */
+	public static final String FILE_MAX_HISTORY = LoggingSystemProperties.FILE_MAX_HISTORY;
+
+	/**
+	 * The name of the System property that contains the file log max size.
+	 */
+	public static final String FILE_MAX_SIZE = LoggingSystemProperties.FILE_MAX_SIZE;
+
 	/**
 	 * The name of the System property that contains the log level pattern.
 	 */

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

@@ -36,6 +36,10 @@ class LoggingSystemProperties {
 
 	static final String FILE_LOG_PATTERN = "FILE_LOG_PATTERN";
 
+	static final String FILE_MAX_HISTORY = "LOG_FILE_MAX_HISTORY";
+
+	static final String FILE_MAX_SIZE = "LOG_FILE_MAX_SIZE";
+
 	static final String LOG_LEVEL_PATTERN = "LOG_LEVEL_PATTERN";
 
 	private final Environment environment;
@@ -55,6 +59,8 @@ public void apply(LogFile logFile) {
 				"exception-conversion-word");
 		setSystemProperty(propertyResolver, CONSOLE_LOG_PATTERN, "pattern.console");
 		setSystemProperty(propertyResolver, FILE_LOG_PATTERN, "pattern.file");
+		setSystemProperty(propertyResolver, FILE_MAX_HISTORY, "file.max-history");
+		setSystemProperty(propertyResolver, FILE_MAX_SIZE, "file.max-size");
 		setSystemProperty(propertyResolver, LOG_LEVEL_PATTERN, "pattern.level");
 		setSystemProperty(PID_KEY, new ApplicationPid().toString());
 		if (logFile != null) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2015 the original author or authors.
+ * Copyright 2012-2016 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.
@@ -23,9 +23,9 @@
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.Appender;
 import ch.qos.logback.core.ConsoleAppender;
-import ch.qos.logback.core.rolling.FixedWindowRollingPolicy;
+import ch.qos.logback.core.CoreConstants;
 import ch.qos.logback.core.rolling.RollingFileAppender;
-import ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy;
+import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy;
 import ch.qos.logback.core.util.OptionHelper;
 
 import org.springframework.boot.bind.RelaxedPropertyResolver;
@@ -41,6 +41,7 @@
  * and {@code file-appender.xml} files provided for classic {@code logback.xml} use.
  *
  * @author Phillip Webb
+ * @author Vedran Pavic
  * @since 1.1.2
  */
 class DefaultLogbackConfiguration {
@@ -53,23 +54,25 @@ class DefaultLogbackConfiguration {
 	private static final String FILE_LOG_PATTERN = "%d{yyyy-MM-dd HH:mm:ss.SSS} "
 			+ "${LOG_LEVEL_PATTERN:-%5p} ${PID:- } --- [%t] %-40.40logger{39} : %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}";
 
+	private static final String MAX_FILE_SIZE = "10MB";
+
 	private static final Charset UTF8 = Charset.forName("UTF-8");
 
-	private final PropertyResolver patterns;
+	private final PropertyResolver resolver;
 
 	private final LogFile logFile;
 
 	DefaultLogbackConfiguration(LoggingInitializationContext initializationContext,
 			LogFile logFile) {
-		this.patterns = getPatternsResolver(initializationContext.getEnvironment());
+		this.resolver = getLoggingResolver(initializationContext.getEnvironment());
 		this.logFile = logFile;
 	}
 
-	private PropertyResolver getPatternsResolver(Environment environment) {
+	private PropertyResolver getLoggingResolver(Environment environment) {
 		if (environment == null) {
 			return new PropertySourcesPropertyResolver(null);
 		}
-		return new RelaxedPropertyResolver(environment, "logging.pattern.");
+		return new RelaxedPropertyResolver(environment, "logging.");
 	}
 
 	public void apply(LogbackConfigurator config) {
@@ -115,7 +118,8 @@ private void base(LogbackConfigurator config) {
 	private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) {
 		ConsoleAppender<ILoggingEvent> appender = new ConsoleAppender<ILoggingEvent>();
 		PatternLayoutEncoder encoder = new PatternLayoutEncoder();
-		String logPattern = this.patterns.getProperty("console", CONSOLE_LOG_PATTERN);
+		String logPattern = this.resolver.getProperty("pattern.console",
+				CONSOLE_LOG_PATTERN);
 		encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
 		encoder.setCharset(UTF8);
 		config.start(encoder);
@@ -126,26 +130,28 @@ private Appender<ILoggingEvent> consoleAppender(LogbackConfigurator config) {
 
 	private Appender<ILoggingEvent> fileAppender(LogbackConfigurator config,
 			String logFile) {
-		RollingFileAppender<ILoggingEvent> appender = new RollingFileAppender<ILoggingEvent>();
+		RollingFileAppender<ILoggingEvent> appender =
+				new RollingFileAppender<ILoggingEvent>();
 		PatternLayoutEncoder encoder = new PatternLayoutEncoder();
-		String logPattern = this.patterns.getProperty("file", FILE_LOG_PATTERN);
+		String logPattern = this.resolver.getProperty("pattern.file", FILE_LOG_PATTERN);
 		encoder.setPattern(OptionHelper.substVars(logPattern, config.getContext()));
 		appender.setEncoder(encoder);
 		config.start(encoder);
 
 		appender.setFile(logFile);
 
-		FixedWindowRollingPolicy rollingPolicy = new FixedWindowRollingPolicy();
-		rollingPolicy.setFileNamePattern(logFile + ".%i");
+		SizeAndTimeBasedRollingPolicy<ILoggingEvent> rollingPolicy =
+				new SizeAndTimeBasedRollingPolicy<ILoggingEvent>();
+		rollingPolicy.setFileNamePattern(logFile + ".%d{yyyy-MM-dd}.%i.gz");
+		String maxFileSize = this.resolver.getProperty("file.max-size",
+				MAX_FILE_SIZE);
+		rollingPolicy.setMaxFileSize(maxFileSize);
+		int maxHistory = this.resolver.getProperty("file.max-history", Integer.class,
+				CoreConstants.UNBOUND_HISTORY);
+		rollingPolicy.setMaxHistory(maxHistory);
 		appender.setRollingPolicy(rollingPolicy);
 		rollingPolicy.setParent(appender);
 		config.start(rollingPolicy);
-
-		SizeBasedTriggeringPolicy<ILoggingEvent> triggeringPolicy = new SizeBasedTriggeringPolicy<ILoggingEvent>();
-		triggeringPolicy.setMaxFileSize("10MB");
-		appender.setTriggeringPolicy(triggeringPolicy);
-		config.start(triggeringPolicy);
-
 		config.appender("FILE", appender);
 		return appender;
 	}

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

@@ -69,6 +69,20 @@
     "description": "Name of the log file. Names can be an exact location or relative to the current directory.",
     "sourceType": "org.springframework.boot.logging.LoggingApplicationListener"
   },
+  {
+    "name": "logging.file.max-size",
+    "type": "java.lang.String",
+    "description": "Maximum log file size. Only supported with the default logback setup.",
+    "sourceType": "org.springframework.boot.logging.LoggingApplicationListener",
+    "defaultValue": "10MB"
+  },
+  {
+    "name": "logging.file.max-history",
+    "type": "java.lang.Integer",
+    "description": "Maximum number of archive log files to keep. Only supported with the default logback setup.",
+    "sourceType": "org.springframework.boot.logging.LoggingApplicationListener",
+    "defaultValue": 0
+  },
   {
     "name": "logging.level",
     "type": "java.util.Map<java.lang.String,java.lang.String>",

spring-boot/src/main/resources/org/springframework/boot/logging/logback/file-appender.xml

@@ -12,12 +12,10 @@ initialization performed by Boot
 			<pattern>${FILE_LOG_PATTERN}</pattern>
 		</encoder>
 		<file>${LOG_FILE}</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-			<fileNamePattern>${LOG_FILE}.%i</fileNamePattern>
+		<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+			<fileNamePattern>${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz</fileNamePattern>
+			<maxFileSize>${MAX_FILE_SIZE:-10MB}</maxFileSize>
+			<maxHistory>${MAX_HISTORY:-0}</maxHistory>
 		</rollingPolicy>
-		<triggeringPolicy
-			class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-			<MaxFileSize>10MB</MaxFileSize>
-		</triggeringPolicy>
 	</appender>
 </included>

spring-boot/src/test/java/org/springframework/boot/logging/logback/LogbackLoggingSystemTests.java

@@ -24,6 +24,11 @@
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.LoggerContext;
 import ch.qos.logback.classic.spi.LoggerContextListener;
+import ch.qos.logback.core.ConsoleAppender;
+import ch.qos.logback.core.CoreConstants;
+import ch.qos.logback.core.rolling.RollingFileAppender;
+import ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP;
+import ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.impl.SLF4JLogFactory;
 import org.hamcrest.Matcher;
@@ -59,6 +64,7 @@
  * @author Dave Syer
  * @author Phillip Webb
  * @author Andy Wilkinson
+ * @author Vedran Pavic
  */
 public class LogbackLoggingSystemTests extends AbstractLoggingSystemTests {
 
@@ -113,15 +119,17 @@ public void withFile() throws Exception {
 		assertThat(getLineWithText(output, "Hello world")).contains("INFO");
 		assertThat(file.exists()).isTrue();
 		assertThat(getLineWithText(file, "Hello world")).contains("INFO");
+		SizeAndTimeBasedFNATP triggeringPolicy = (SizeAndTimeBasedFNATP) getRollingPolicy()
+				.getTimeBasedFileNamingAndTriggeringPolicy();
+		assertThat(triggeringPolicy.getMaxFileSize()).isEqualTo("10MB");
+		assertThat(getRollingPolicy().getMaxHistory()).isEqualTo(
+				CoreConstants.UNBOUND_HISTORY);
 	}
 
 	@Test
 	public void testBasicConfigLocation() throws Exception {
 		this.loggingSystem.beforeInitialize();
-		ILoggerFactory factory = StaticLoggerBinder.getSingleton().getLoggerFactory();
-		LoggerContext context = (LoggerContext) factory;
-		Logger root = context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
-		assertThat(root.getAppender("CONSOLE")).isNotNull();
+		assertThat(getConsoleAppender()).isNotNull();
 	}
 
 	@Test
@@ -272,6 +280,36 @@ public void testFilePatternProperty() throws Exception {
 		assertThat(getLineWithText(file, "Hello world")).doesNotContain("INFO");
 	}
 
+	@Test
+	public void testMaxFileSizeProperty() throws Exception {
+		MockEnvironment environment = new MockEnvironment();
+		environment.setProperty("logging.file.max-size", "100MB");
+		LoggingInitializationContext loggingInitializationContext =
+				new LoggingInitializationContext(environment);
+		File file = new File(tmpDir(), "logback-test.log");
+		LogFile logFile = getLogFile(file.getPath(), null);
+		this.loggingSystem.initialize(loggingInitializationContext, null, logFile);
+		this.logger.info("Hello world");
+		assertThat(getLineWithText(file, "Hello world")).contains("INFO");
+		SizeAndTimeBasedFNATP triggeringPolicy = (SizeAndTimeBasedFNATP) getRollingPolicy()
+				.getTimeBasedFileNamingAndTriggeringPolicy();
+		assertThat(triggeringPolicy.getMaxFileSize()).isEqualTo("100MB");
+	}
+
+	@Test
+	public void testMaxHistoryProperty() throws Exception {
+		MockEnvironment environment = new MockEnvironment();
+		environment.setProperty("logging.file.max-history", "30");
+		LoggingInitializationContext loggingInitializationContext =
+				new LoggingInitializationContext(environment);
+		File file = new File(tmpDir(), "logback-test.log");
+		LogFile logFile = getLogFile(file.getPath(), null);
+		this.loggingSystem.initialize(loggingInitializationContext, null, logFile);
+		this.logger.info("Hello world");
+		assertThat(getLineWithText(file, "Hello world")).contains("INFO");
+		assertThat(getRollingPolicy().getMaxHistory()).isEqualTo(30);
+	}
+
 	@Test
 	public void exceptionsIncludeClassPackaging() throws Exception {
 		this.loggingSystem.beforeInitialize();
@@ -337,6 +375,24 @@ public void initializationIsOnlyPerformedOnceUntilCleanedUp() throws Exception {
 		verify(listener, times(2)).onReset(loggerContext);
 	}
 
+	private static Logger getRootLogger() {
+		ILoggerFactory factory = StaticLoggerBinder.getSingleton().getLoggerFactory();
+		LoggerContext context = (LoggerContext) factory;
+		return context.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
+	}
+
+	private static ConsoleAppender getConsoleAppender() {
+		return (ConsoleAppender) getRootLogger().getAppender("CONSOLE");
+	}
+
+	private static RollingFileAppender getFileAppender() {
+		return (RollingFileAppender) getRootLogger().getAppender("FILE");
+	}
+
+	private static SizeAndTimeBasedRollingPolicy getRollingPolicy() {
+		return (SizeAndTimeBasedRollingPolicy) getFileAppender().getRollingPolicy();
+	}
+
 	private String getLineWithText(File file, String outputSearch) throws Exception {
 		return getLineWithText(FileCopyUtils.copyToString(new FileReader(file)),
 				outputSearch);