
Recently one of my blog reader *Surisetty *send me a question, asking me if it is possible **to write log messages of different levels (info, debug, etc) into different log files**? To answer his question, **yes, it is possible. **We can do this\*\* \*\*by extending the FileAppender class and writing our own logic.

Below is the proof of concept code written to demonstrate this. Before that, you can download the Eclipse project file to run this code in your environment.

[Download the Source code][1]

[1]: http://www.box.net/shared/g3esrz13q4

## To write different log levels in different log files

1.  Create a custom Log4j appender extending _FileAppender._
2.  In that, override the *append() *method and check for the log level before writing a log message. Based on the level, call the *setFile() *method to switch between corresponding log file.
3.  Also, use MDC to store the original log file name mentioned in the _log4j.properties_. This is needed because *setFile() *changes the log file name every time you call it. So, we need to keep a track of the original file name somehow. And, we can use [Log4j MDC][2] for this.

[2]: https://veerasundar.com/blog/log4j-mdc-mapped-diagnostic-context-what-and-why

## Custom Appender: LogLevelFilterFileAppender

```java
    package com.veerasundar.log4j;

    import java.io.File;
    import java.io.IOException;

    import org.apache.log4j.FileAppender;
    import org.apache.log4j.Layout;
    import org.apache.log4j.MDC;
    import org.apache.log4j.spi.ErrorCode;
    import org.apache.log4j.spi.LoggingEvent;

    /**
     * This customized Log4j appender will separate the log messages based on their
     * LEVELS and will write them into separate files. For example, all DEBUG
     * messages will go to a file and all INFO messages will go to a different file.
     *
     * @author Veera Sundar | https://veerasundar.com
     *
     */
    public class LogLevelFilterFileAppender extends FileAppender {

    	private final static String DOT = ".";
    	private final static String HIPHEN = "-";
    	private static final String ORIG_LOG_FILE_NAME = "OrginalLogFileName";

    	public LogLevelFilterFileAppender() {

    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName,
    			boolean append, boolean bufferedIO, int bufferSize)
    			throws IOException {
    		super(layout, fileName, append, bufferedIO, bufferSize);
    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName,
    			boolean append) throws IOException {
    		super(layout, fileName, append);
    	}

    	public LogLevelFilterFileAppender(Layout layout, String fileName)
    			throws IOException {
    		super(layout, fileName);
    	}

    	@Override
    	public void activateOptions() {
    		MDC.put(ORIG_LOG_FILE_NAME, fileName);
    		super.activateOptions();
    	}

    	@Override
    	public void append(LoggingEvent event) {
    		try {
    			setFile(appendLevelToFileName((String) MDC.get(ORIG_LOG_FILE_NAME),
    					event.getLevel().toString()), fileAppend, bufferedIO,
    					bufferSize);
    		} catch (IOException ie) {
    			errorHandler
    					.error(
    							"Error occured while setting file for the log level "
    									  event.getLevel(), ie,
    							ErrorCode.FILE_OPEN_FAILURE);
    		}
    		super.append(event);
    	}

    	private String appendLevelToFileName(String oldLogFileName, String level) {
    		if (oldLogFileName != null) {
    			final File logFile = new File(oldLogFileName);
    			String newFileName = "";
    			final String fn = logFile.getName();
    			final int dotIndex = fn.indexOf(DOT);
    			if (dotIndex != -1) {
    				// the file name has an extension. so, insert the level
    				// between the file name and the extension
    				newFileName = fn.substring(0, dotIndex)   HIPHEN   level   DOT
    						  fn.substring(dotIndex   1);
    			} else {
    				// the file name has no extension. So, just append the level
    				// at the end.
    				newFileName = fn   HIPHEN   level;
    			}
    			return logFile.getParent()   File.separator   newFileName;
    		}
    		return null;
    	}
    }
```

## log4j.properties file

```
    log4j.rootLogger = DEBUG, fileout
    log4j.appender.fileout = com.veerasundar.log4j.LogLevelFilterFileAppender
    log4j.appender.fileout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c - %m%n
    log4j.appender.fileout.layout = org.apache.log4j.PatternLayout
    log4j.appender.fileout.File = C:/vraa/temp/logs.log
```

## Let's test our code

```java
    package com.veerasundar.log4j;

    import org.apache.log4j.Logger;

    public class Log4jDemo {

    	private static final Logger logger = Logger.getLogger(Log4jDemo.class);

    	public static void main(String args[]) {
    		logger.debug("This is a debug message");
    		logger.info("This is a information message");
    		logger.warn("This is a warning message");
    		logger.error("This is an error message");
    		logger.fatal("This is a fatal message");
    		logger.debug("This is another debug message");
    		logger.info("This is another information message");
    		logger.warn("This is another warning message");
    		logger.error("This is another error message");
    		logger.fatal("This is another fatal message");
    	}
    }
```


Log4j Tutorial - Writing different log levels in different log files


In the previous post of the Log4j tutorial series, I wrote about the very basics of [adding Log4j logging to your project][1]. In this post, I'll explain how to create a File Appender to log messages into a file, instead of console.

[1]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "how to incorporate the Log4j logging support to your project, in a step by step manner."

### Log4j File Appenders - example for Logging messages to a file:

In most cases, either _Rolling File Appender_ or _Daily Rolling File Appender_ classes are used in production scenarios for logging messages into a file. A _[Rolling File Appender][2]_ will send all the log messages to the configured file, until the file reaches a certain size. Once the log file reaches a maximum size, the current file will be backed up and a new log file will be created (thus the name Rolling File Appender). The _[Daily Rolling File Appender][3]_ is also similar to _Rolling File Appender_ except that the rolling happens at given frequency. Below is an example for using RollingFileAppender

[2]: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/RollingFileAppender.html "RollingFileAppender extends FileAppender to backup the log files when they reach a certain size."
[3]: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/DailyRollingFileAppender.html "DailyRollingFileAppender extends FileAppender so that the underlying file is rolled over at a user chosen frequency."

1.  Add Log4j logging support to your project. Read [this article ][1] for how to do it.
2.  In your log4j.properties file, add below lines.

```java
        log4j.appender.rollingFile=org.apache.log4j.RollingFileAppender
        log4j.appender.rollingFile.File=D:/myapp/mylog.log
        log4j.appender.rollingFile.MaxFileSize=2MB
        log4j.appender.rollingFile.MaxBackupIndex=2
        log4j.appender.rollingFile.layout = org.apache.log4j.PatternLayout
        log4j.appender.rollingFile.layout.ConversionPattern=%p %t %c - %m%n

```

3.  As you can see from the above log4j  configuration, we are creating a new log4j appender in the name of *rollingFile* and setting it's options. I guess most of the options are self explanatory. The *MaxBackupIndex* tells the log4j to keep a maximum of 2 backup files for the log mylog.log. If the log file is exceeding the *MaximumFileSize*, then the contents will be copied to a backup file and the logging will be added to a new empty mylog.log file. From the above configuration, there can be a maximum of 2 backup files can be created.
4.  Next we need to direct our logs to go into this log4j appender.

```java
        log4j.rootLogger = INFO, rollingFile
```

5.  That's it. From now on, when you log something from your Java class, the log message will go into the mylog.log file.

Next: [How to send log messages to different log files?][4]

 [4]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-log-messages-to-different-log-files "How to send log messages to different log files?"

Previous: [Adding Log4j logging to your project.][5]

 [5]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "Log4j Tutorial : Adding Log4j logging to your project"


#appender (2)