Add Log4j2 rolling policy configuration

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

@@ -26,6 +26,7 @@
 
 import org.jspecify.annotations.Nullable;
 
+import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.Environment;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.util.Assert;
@@ -180,7 +181,10 @@ protected final String getPackagedConfigFile(String fileName) {
 	}
 
 	protected final void applySystemProperties(Environment environment, @Nullable LogFile logFile) {
-		new LoggingSystemProperties(environment, getDefaultValueResolver(environment), null).apply(logFile);
+		LoggingSystemProperties systemProperties = (environment instanceof ConfigurableEnvironment configurableEnvironment)
+				? getSystemProperties(configurableEnvironment)
+				: new LoggingSystemProperties(environment, getDefaultValueResolver(environment), null);
+		systemProperties.apply(logFile);
 	}
 
 	/**

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

@@ -58,8 +58,10 @@
 import org.springframework.boot.logging.LoggingInitializationContext;
 import org.springframework.boot.logging.LoggingSystem;
 import org.springframework.boot.logging.LoggingSystemFactory;
+import org.springframework.boot.logging.LoggingSystemProperties;
 import org.springframework.core.Conventions;
 import org.springframework.core.annotation.Order;
+import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.core.env.Environment;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceLoader;
@@ -128,6 +130,11 @@ public class Log4J2LoggingSystem extends AbstractLoggingSystem {
 		this.loggerContext = loggerContext;
 	}
 
+	@Override
+	public LoggingSystemProperties getSystemProperties(ConfigurableEnvironment environment) {
+		return new Log4j2LoggingSystemProperties(environment, getDefaultValueResolver(environment), null);
+	}
+
 	@Override
 	protected String[] getStandardConfigLocations() {
 		// With Log4J2 we use the ConfigurationFactory

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

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2012-present 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.logging.log4j2;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import org.jspecify.annotations.Nullable;
+
+import org.springframework.boot.logging.LogFile;
+import org.springframework.boot.logging.LoggingSystemProperties;
+import org.springframework.core.convert.ConversionFailedException;
+import org.springframework.core.convert.ConverterNotFoundException;
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.PropertyResolver;
+import org.springframework.util.unit.DataSize;
+
+/**
+ * {@link LoggingSystemProperties} for Log4j2.
+ *
+ * @author HoJoo Moon
+ * @since 4.0.0
+ * @see Log4j2RollingPolicySystemProperty
+ */
+public class Log4j2LoggingSystemProperties extends LoggingSystemProperties {
+
+	public Log4j2LoggingSystemProperties(Environment environment) {
+		super(environment);
+	}
+
+	/**
+	 * Create a new {@link Log4j2LoggingSystemProperties} instance.
+	 * @param environment the source environment
+	 * @param setter setter used to apply the property
+	 */
+	public Log4j2LoggingSystemProperties(Environment environment,
+			@Nullable BiConsumer<String, @Nullable String> setter) {
+		super(environment, setter);
+	}
+
+	/**
+	 * Create a new {@link Log4j2LoggingSystemProperties} instance.
+	 * @param environment the source environment
+	 * @param defaultValueResolver function used to resolve default values or {@code null}
+	 * @param setter setter used to apply the property or {@code null} for system
+	 * properties
+	 */
+	public Log4j2LoggingSystemProperties(Environment environment,
+			Function<@Nullable String, @Nullable String> defaultValueResolver,
+			@Nullable BiConsumer<String, @Nullable String> setter) {
+		super(environment, defaultValueResolver, setter);
+	}
+
+	@Override
+	protected void apply(@Nullable LogFile logFile, PropertyResolver resolver) {
+		super.apply(logFile, resolver);
+		applyRollingPolicyProperties(resolver);
+	}
+
+	private void applyRollingPolicyProperties(PropertyResolver resolver) {
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.STRATEGY, resolver);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.TIME_INTERVAL, resolver, Integer.class);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.TIME_MODULATE, resolver, Boolean.class);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.CRON_SCHEDULE, resolver);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.FILE_NAME_PATTERN, resolver);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.MAX_FILE_SIZE, resolver, DataSize.class);
+		applyRollingPolicy(Log4j2RollingPolicySystemProperty.MAX_HISTORY, resolver);
+	}
+
+	private void applyRollingPolicy(Log4j2RollingPolicySystemProperty property, PropertyResolver resolver) {
+		applyRollingPolicy(property, resolver, String.class);
+	}
+
+	private <T> void applyRollingPolicy(Log4j2RollingPolicySystemProperty property, PropertyResolver resolver,
+			Class<T> type) {
+		T value = getProperty(resolver, property.getApplicationPropertyName(), type);
+		if (value == null && property.getDeprecatedApplicationPropertyName() != null) {
+			value = getProperty(resolver, property.getDeprecatedApplicationPropertyName(), type);
+		}
+		if (value != null) {
+			String stringValue = String.valueOf((value instanceof DataSize dataSize) ? dataSize.toBytes() : value);
+			setSystemProperty(property.getEnvironmentVariableName(), stringValue);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T> @Nullable T getProperty(PropertyResolver resolver, String key, Class<T> type) {
+		try {
+			return resolver.getProperty(key, type);
+		}
+		catch (ConversionFailedException | ConverterNotFoundException ex) {
+			if (type != DataSize.class) {
+				throw ex;
+			}
+			// Fallback for Log4j2 compatibility - try parsing as string if DataSize
+			// conversion fails
+			String value = resolver.getProperty(key);
+			if (value != null) {
+				try {
+					return (T) DataSize.parse(value);
+				}
+				catch (Exception parseEx) {
+					ex.addSuppressed(parseEx);
+					throw ex;
+				}
+			}
+			return null;
+		}
+	}
+
+}

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

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2012-present 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.boot.logging.log4j2;
+
+import org.jspecify.annotations.Nullable;
+
+/**
+ * Log4j2 rolling policy system properties that can later be used by log configuration
+ * files.
+ *
+ * @author HoJoo Moon
+ * @since 4.0.0
+ * @see Log4j2LoggingSystemProperties
+ */
+public enum Log4j2RollingPolicySystemProperty {
+
+	/**
+	 * Logging system property for the rolled-over log file name pattern.
+	 */
+	FILE_NAME_PATTERN("file-name-pattern", "logging.pattern.rolling-file-name"),
+
+	/**
+	 * Logging system property for the file log max size.
+	 */
+	MAX_FILE_SIZE("max-file-size", "logging.file.max-size"),
+
+	/**
+	 * Logging system property for the file log max history.
+	 */
+	MAX_HISTORY("max-history", "logging.file.max-history"),
+
+	/**
+	 * Logging system property for the rolling policy strategy.
+	 */
+	STRATEGY("strategy", null),
+
+	/**
+	 * Logging system property for the rolling policy time interval.
+	 */
+	TIME_INTERVAL("time-based.interval", null),
+
+	/**
+	 * Logging system property for the rolling policy time modulate flag.
+	 */
+	TIME_MODULATE("time-based.modulate", null),
+
+	/**
+	 * Logging system property for the cron based schedule.
+	 */
+	CRON_SCHEDULE("cron.schedule", null);
+
+	private final String environmentVariableName;
+
+	private final String applicationPropertyName;
+
+	private final @Nullable String deprecatedApplicationPropertyName;
+
+	Log4j2RollingPolicySystemProperty(String applicationPropertyName,
+			@Nullable String deprecatedApplicationPropertyName) {
+		this.environmentVariableName = "LOG4J2_ROLLINGPOLICY_" + name();
+		this.applicationPropertyName = "logging.log4j2.rollingpolicy." + applicationPropertyName;
+		this.deprecatedApplicationPropertyName = deprecatedApplicationPropertyName;
+	}
+
+	/**
+	 * Return the name of environment variable that can be used to access this property.
+	 * @return the environment variable name
+	 */
+	public String getEnvironmentVariableName() {
+		return this.environmentVariableName;
+	}
+
+	String getApplicationPropertyName() {
+		return this.applicationPropertyName;
+	}
+
+	@Nullable String getDeprecatedApplicationPropertyName() {
+		return this.deprecatedApplicationPropertyName;
+	}
+
+}