fallback for log4j.properties in spring configuration - spring

Question

My config is as follows:
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:META-INF/spring/environments/${env}/log4j.properties</param-value>
</context-param>
What I want is, if
META-INF/spring/environments/${env}/log4j.properties
is not found, I want web.xml to load
META-INF/spring/environments/dev/log4j.properties
Is it possible?

Answer 1

If ${env} cannot be resolved and you get an exception like Could not resolve placeholder 'env' in string value "classpath:META-INF/spring/environments/${env}/log4j.properties" then it's easy by using the following format:
<param-value>classpath:META-INF/spring/environments/${env:dev}/log4j.properties</param-value>
but I don't think this is the actual issue you are facing.
I believe you already have ${env} properly resolved but the actual log4j.properties file is not found on that, otherwise properly resolved (META-INF/spring/environments/prod/log4j.properties for example), location.
I this case I don't think what you want to achieve is available out of the box, I believe you need some custom code. I'm saying this because the Spring code that deals with configuration files not to be found for Log4J configuration is not allowing any "default" fallback option. As you can see in Log4jWebConfigurer source code, if the file is not found an IllegalArgumentException is being ultimately thrown:
catch (FileNotFoundException ex) {
throw new IllegalArgumentException("Invalid 'log4jConfigLocation' parameter: " + ex.getMessage());
}
These being said, this is my try on a possible solution:
define your own Log4jConfigListener
package com.foo.bar;
import java.io.FileNotFoundException;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import org.springframework.util.Log4jConfigurer;
import org.springframework.util.ResourceUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.util.Log4jConfigListener;
import org.springframework.web.util.Log4jWebConfigurer;
import org.springframework.web.util.ServletContextPropertyUtils;
import org.springframework.web.util.WebUtils;
public class MyLog4jConfigListener extends Log4jConfigListener {
public static final String DEFAULT_CONFIG_LOCATION_PARAM = "defaultLog4jConfigLocation";
#Override
public void contextInitialized(ServletContextEvent event) {
try {
super.contextInitialized(event);
} catch (IllegalArgumentException e) {
// the log4jConfigLocation file hasn't been found, try the default
if (!successfulDefaultLocationLookup(event)) {
// if the default parameter hasn't been set or there are issues, fallback to the initial behavior (throwing an IllegalArgumentException)
throw e;
}
}
}
private boolean successfulDefaultLocationLookup(ServletContextEvent event) {
ServletContext servletContext = event.getServletContext();
String location = servletContext.getInitParameter(DEFAULT_CONFIG_LOCATION_PARAM);
if (location != null) {
try {
// Resolve property placeholders before potentially resolving a real path.
location = ServletContextPropertyUtils.resolvePlaceholders(location, servletContext);
// Leave a URL (e.g. "classpath:" or "file:") as-is.
if (!ResourceUtils.isUrl(location)) {
// Consider a plain file path as relative to the web
// application root directory.
location = WebUtils.getRealPath(servletContext, location);
}
// Write log message to server log.
servletContext.log("Initializing log4j from default location [" + location + "]");
// Check whether refresh interval was specified.
String intervalString = servletContext.getInitParameter(Log4jWebConfigurer.REFRESH_INTERVAL_PARAM);
if (StringUtils.hasText(intervalString)) {
// Initialize with refresh interval, i.e. with log4j's watchdog thread,
// checking the file in the background.
try {
long refreshInterval = Long.parseLong(intervalString);
Log4jConfigurer.initLogging(location, refreshInterval);
}
catch (NumberFormatException ex) {
servletContext.log("Invalid 'log4jRefreshInterval' parameter for default log4j configuration file lookup: " + ex.getMessage());
return false;
}
}
else {
// Initialize without refresh check, i.e. without log4j's watchdog thread.
Log4jConfigurer.initLogging(location);
}
return true;
}
catch (FileNotFoundException ex) {
servletContext.log("Invalid 'log4jConfigLocation' parameter for default log4j configuration file lookup: " + ex.getMessage());
return false;
}
}
return false;
}
}
define the custom listener in web.xml
<listener>
<listener-class>com.foo.bar.MyLog4jConfigListener</listener-class>
</listener>
apart from your normal log4j context-param configuration, define the custom parameter for the default location
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>classpath:META-INF/spring/environments/${env}/log4j.properties</param-value>
</context-param>
<context-param>
<param-name>defaultLog4jConfigLocation</param-name>
<param-value>classpath:META-INF/spring/environments/dev/log4j.properties</param-value>
</context-param>

Answer 2

I do not know how to set it up to use a conditional IF statement but I think you could do it with wildcards. The Spring 4 docs explain the how, however due to formatting issues it is easier to read in the Spring 3 docs. But I will sum it up here for you.
You may use both the special classpath*: prefix and/or internal Ant-style regular expressions.
With the Ant-style pattern:
classpath:META-INF/spring/environments/**/log4j.properties
This search would find the first instance of META-INF/spring/environments/ and provide the next directory as a wildcard. This search will only return the first thing found.
With the classpath*: prefix:
classpath*:META-INF/spring/environments/**/log4j.properties
This search would return and merge the results of all the files that match this pattern.