
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


![How do you use logging in your application?][1]This time, I feel like conducting a poll and hear from you, instead of writing lengthy content. Similar to my other post, [What does it take to make a 'Ëœgood' developer resume?][2], this is also going to be a discussion post. Feel free to cast your vote and leave your comment at the end of this post.

[1]: http://i187.photobucket.com/albums/x201/talktoveera/2999130055_8697986e51.jpg "How do you use logging in your application?"
[2]: https://veerasundar.com/blog/what-does-it-take-to-make-a-good-developer-resume "How to create a good developer resume"

I don't think there is a need to emphasize on the importance of logging in software. Logging helps to maintain a track record of what happened in the application. A good logging framework helps the developer to use logging effectively without affecting the application's performance. For Java applications, [Log4j][3] is always considered as one of the popular logging framework.

[3]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "Log4j tutorial"

That said about logging, here is the poll for you to vote.

## Logging Framework or No Logging at all?

[poll id="3"]


How do you use logging in your application?


As a continuation of my previous post about [Log4j MDC (Mapped Diagnostic Context)][1], here's a fully working code sample explaining the concept. This is a simple example where we have a one servlet and one filter. The filter intercepts each and every request and put the user name in the MDC.

[1]: https://veerasundar.com/blog/log4j-mdc-mapped-diagnostic-context-what-and-why "Log4j MDC (Mapped Diagnostic Context) : What and Why"

## The Servlet Class:

```java
package com.veerasundar.code.log4jmdc;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

/**
 * A good-for-nothing servlet which is just writing few messages to the logger
 * object. Since we've configured in the log4j.properties file to include the
 * userName, taken from MDC, every message will be appended with the user name
 * that is set from the AuthenticationFilter
 *
 */
public class Log4jMdcDemo extends HttpServlet {

	private static Logger logger = Logger.getLogger(Log4jMdcDemo.class);

	public Log4jMdcDemo() {
	}

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doService(request, response);
	}

	protected void doPost(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {
		doService(request, response);
	}

	protected void doService(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		logger.info("This is  demo for the Log4j MDC concept");
		logger.info("From Veerasundar.com/blog");
		logger.debug("Just some sample messages");
	}
}
```

## A Filter to put the user name in MDC for every request call

```java

package com.veerasundar.code.log4jmdc;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.apache.log4j.MDC;

/**
 * An example authentication filter which is used to intercept all the requests
 * for fetching the user name from it and put the user name to the Log4j Mapped
 * Diagnostic Context (MDC), so that the user name could be used for
 * differentiating log messages.
 *
 * @author veerasundar.com/blog
 *
 */
public class AuthenticationFilter implements Filter {

	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {

		try {
			/*
			 * This code puts the value "userName" to the Mapped Diagnostic
			 * context. Since MDc is a static class, we can directly access it
			 * with out creating a new object from it. Here, instead of hard
			 * coding the user name, the value can be retrieved from a HTTP
			 * Request object.
			 */
			MDC.put("userName", "veera");

			chain.doFilter(request, response);

		} finally {
			MDC.remove("userName");
		}

	}

}
```

## Web.xml file to glue together Servlet and Filter

```xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"   xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <servlet>
        <description/>
        <display-name>Log4jMdcDemo</display-name>
        <servlet-name>Log4jMdcDemo</servlet-name>
        <servlet-class>com.veerasundar.code.log4jmdc.Log4jMdcDemo</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>Log4jMdcDemo</servlet-name>
        <url-pattern>/Log4jMdcDemo</url-pattern>
    </servlet-mapping>
    <filter>
        <filter-name>AuthFilter</filter-name>
        <filter-class>com.veerasundar.code.log4jmdc.AuthenticationFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>AuthFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>
```

## Log4j.properties file which uses the data present in MDC

```java

    # sample log4j.properties file, explaining log4j MDC concept
    # author: veerasundar.com/blog

    log4j.appender.consoleAppender = org.apache.log4j.ConsoleAppender
    log4j.appender.consoleAppender.layout = org.apache.log4j.PatternLayout

    #note the %X{userName} - this is how you fetch data from Mapped Diagnostic Context (MDC)
    log4j.appender.consoleAppender.layout.ConversionPattern = %-4r [%t] %5p %c %x - %m - %X{userName}%n

    log4j.rootLogger = DEBUG, consoleAppender

```

I hope that code explains the concept of MDC. Do let me know if you have any questions/suggestions in the comments.

## Output from the log file:

```java

    0    [http-8084-2]  INFO Log4jMDCDemo  - This is  demo for the Log4j MDC concept - veera
    0    [http-8084-2]  INFO Log4jMDCDemo  - From Veerasundar.com/blog - veera
    0    [http-8084-2] DEBUG Log4jMDCDemo  - Just some sample messages - veera
```

Log4j MDC (Mapped Diagnostic Context) : Example code


I hope that Log4j does not need any introduction and I assume that you already have basic understanding of Log4j. If not, I'll recommend you to first read this [Log4j Tutorial][1], to get started.

[1]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "Log4j Tutorial"

That said, now I'll start with MDC or **Mapped Diagnostic Context**. Don't get scared with this name! MDC is not that tough. It's a simple yet useful concept. Before I explain what is MDC, lets assume that we are going to develop a simple web application with one servlet `MyServlet` that serves requests from multiple clients. And, this servlet uses log4j framework for logging. A file appender has been defined for this servlet, so all the log messages will be logged into a text file.

With the above said configuration, all the log messages from `MyServlet` will go into a single log file. And when this servlet is serving more than one clients at the same time, the log statements will be mixed and there's  no way to differentiate which log statement is belongs to which client's processing. This'll make it difficult to trace and debug if any processing error occured in `MyServlet` life cycle.

## How to differentiate log statements with respective to each clients?

To avoid the log statements mix-in, we could add a _user name_ (or some other data which will be unique to each client) to our log statements. To do this, we have to make sure that we pass this _user name_ data explicitley to each and every log statements, which is a tedious and repetitive work. But, no need to worry! Log4j has an excellent way to overcome this. It's called as **MDC or Mapped Diagnostic Context.**

## So, What is Log4j MDC (Mapped Diagnostic Context)

To put it simple, the MDC is a map which stores the context data of the particular thread where the context is running. To explain it, come back to our simple application - every client request will be served by different thread of the `MyServlet`. So, if you use log4j for logging, then each thread can have it's own MDC which is  global to the entire thread. Any code which is part of that thread can easily access the values that are present in thread's MDC.

So, how do we make MDC to differentiate logging statements from multiple clients? Simple : Before starting any business process in your code, get the user name (for our Servlet, we can get it from `request` object) and put that into MDC. Now the _user name_ will be available to the further processing. In your **log4j.properties** while defining the `conversionPattern`, add a pattern `%X{key}` to retrievce the values that are present in the MDC. The key will be _userName_ in our example. It's like getting a value from a Session object.

In [my next post][2], I'll give the source code for the same example that I used in this post. So, [keep Watching!][3]

[2]: https://veerasundar.com/blog/log4j-mdc-mapped-diagnostic-context-example-code "Log4j MDC example code"
[3]: https://veerasundar.com/blog/feed "Subscriibe to this blog feed"


Log4j MDC (Mapped Diagnostic Context) : What and Why


Recently I got a question from my blog reader _Kuruba_, regarding log4j logging. Kuruba is having a batch program with Log4j logging and he wants to send the log messages to a **new log file each time his batch runs**. This can be achieved by extending Log4j's FileAppender, which is used for [logging to a file][1], and adding our own customization to the file appender. Below I'm explaining how to do it.

[1]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file

## Extending FileAppender to create a new log file for each application run:

Here's the pseudo code for the logic we are going to implement.

1.  Create a new Class _NewLogForEachRunFileAppender_ (or any name as you wish), and extend it from the class _[org.apache.log4j.FileAppender][2]._
2.  Override the _[activateOptions][3]()_ function for setting the new log file name every time the logger is instantiated.
3.  For simplicity, we will append the _current timestamp_ to each log file name. So, each time when you run the application, you will get a fresh log file.

[2]: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/FileAppender.html
[3]: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/FileAppender.html#activateOptions()

## Customized FileAppender: NewLogForEachRunFileAppender:

Here is the code for the customize FileAppender, which will create a new log file, appender with the current timestamp, for each run of the application. Please note that this code is tested in Windows environment. So, please be cautious and do a testing when running this code in Unix or other environment.

```java

    package com.veerasundar.dynamiclogger;

    import java.io.File;
    import java.io.IOException;

    import org.apache.log4j.FileAppender;
    import org.apache.log4j.Layout;
    import org.apache.log4j.spi.ErrorCode;

    /**
    * This is a customized log4j appender, which will create a new file for every
    * run of the application.
    *
    * @author veera | https://veerasundar.com
    *
    */
    public class NewLogForEachRunFileAppender extends FileAppender {

    public NewLogForEachRunFileAppender() {
    }

    public NewLogForEachRunFileAppender(Layout layout, String filename,
    		boolean append, boolean bufferedIO, int bufferSize)
    		throws IOException {
    	super(layout, filename, append, bufferedIO, bufferSize);
    }

    public NewLogForEachRunFileAppender(Layout layout, String filename,
    		boolean append) throws IOException {
    	super(layout, filename, append);
    }

    public NewLogForEachRunFileAppender(Layout layout, String filename)
    		throws IOException {
    	super(layout, filename);
    }

    public void activateOptions() {
    if (fileName != null) {
    	try {
    		fileName = getNewLogFileName();
    		setFile(fileName, fileAppend, bufferedIO, bufferSize);
    	} catch (Exception e) {
    		errorHandler.error("Error while activating log options", e,
    				ErrorCode.FILE_OPEN_FAILURE);
    	}
    }
    }

    private String getNewLogFileName() {
    if (fileName != null) {
    	final String DOT = ".";
    	final String HIPHEN = "-";
    	final File logFile = new File(fileName);
    	final String fileName = logFile.getName();
    	String newFileName = "";

    	final int dotIndex = fileName.indexOf(DOT);
    	if (dotIndex != -1) {
    		// the file name has an extension. so, insert the time stamp
    		// between the file name and the extension
    		newFileName = fileName.substring(0, dotIndex)   HIPHEN
    				   System.currentTimeMillis()   DOT
    				  fileName.substring(dotIndex   1);
    	} else {
    		// the file name has no extension. So, just append the timestamp
    		// at the end.
    		newFileName = fileName   HIPHEN   System.currentTimeMillis();
    	}
    	return logFile.getParent()   File.separator   newFileName;
    }
    return null;
    }
    }

```

## log4j.properties file

Since we created a custom file appender, we need to tell the Log4j to use our custom file appender. For demo purpose, I configured this custom FileAppender as a rootLogger. So, all log messages will go to our file appender. Below is the sample log4j.properties file.

```java

    log4j.rootLogger = DEBUG, fileout
    log4j.appender.fileout = com.veerasundar.dynamiclogger.NewLogForEachRunFileAppender
    log4j.appender.fileout.layout.ConversionPattern = %d{ABSOLUTE} %5p %c - %m%n
    log4j.appender.fileout.layout = org.apache.log4j.PatternLayout
    log4j.appender.fileout.File = D:/temp/dynamiclogger/logs.log

```

If you look at the property *log4j.appender.fileout*, our customized file appender is associated with this appender. We have also given a log file name 'log.log' in the above configuration file. So, with the above configuration, when you run your application, the log files will be generated in this fashion: logs-1250696128437.log, logs-1250696142828.log.


How to create a new log file for each time the application runs?


In my last post about [how to send log messages to different log files][1], I'd promised to write about _additivity_. And, here is a post for keeping my promise. I hope that after reading my previous article, now you know how to [configure Log4j][2] for logging into multiple files using file appenders. But, there is a catch in that technique. To explain this clearly, consider this scenario:

[1]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-log-messages-to-different-log-files
[2]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-log-messages-to-different-log-files "configure log4j"

You've configured a total of _three appenders_ in your application. One for the package _com.demo.moduleone_ and one for _com.demo.moduletwo_ and one root logger for _com.demo_. The log4j configuration will look something like this (showing only the appender configuration, excluding other details)

```java
    log4j.category.com.demo.moduleone = INFO, moduleOneFileAppender
    log4j.category.com.demo.moduletwo = INFO, moduleTwoFileAppender
    log4j.rootLogger = INFO, rootFileAppender
```

The Log4j loggers are following hierarchies. ie, A log4j logger is said to be an _ancestor_ of another logger if its name followed by a dot is a prefix of the _descendant_ logger name. A log4j logger is said to be a _parent_ of a _child_ logger if there are no ancestors between itself and the descendant logger.

So, as per the hierarchy, our rootFileAppender is the _parent_ appender for both moduleOneFileAppender and moduleTwoAppender. So, all the log messages that are coming to the child appenders will be propagated to the parent appenders too. So, in our scenario, the log messages from the package _com.demo.moduleone_ will be sent to the _moduleOneFileAppender_ plus the *rootFileAppender*. The same applies to the _com.demo.moduletwo_ also. This leads to write the same log message in two different location.

## How to avoid this redundancy?

In order to avoid this redundancy, we can use **Log4j additivity**. Just set the _additivity_ property of an Log4j logger to **false** and then the log messages which are coming to that logger will **not** be propagated to it's parent loggers. So, our new Log4j configuration file would be:

```java
    log4j.category.com.demo.moduleone = INFO, moduleOneFileAppender
    log4j.additivity.com.demo.moduleone = false
    log4j.category.com.demo.moduletwo = INFO, moduleTwoFileAppender
    log4j.additivity.com.demo.moduletwo = false
    log4j.rootLogger = INFO, rootFileAppender

```

With the above configuration, the log messages from the _com.demo.moduleone_ will go to the moduleOneAppender only and the rest of the log messages will go to the rootFileAppender.

Previous: [How to send log messages to different log files?][3]

[3]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-log-messages-to-different-log-files


Log4j Tutorial: Additivity - what and why?


One of the common requirement in Java projects, that are [using Log4j logging][1], is to have different log files for each module (or layer) in the project. For example, if you have a web application, you may want to log the debug/info messages from the service layer to a _service.log_ file and the log messages from the presentation layer to the _web-app.log_ file and so on. This is very simple to achieve in Log4j.

[1]: https://veerasundar.com/blog/log4j-tutorial-adding-log4j-logging-to-your-project "How to add Log4j support to your project?  Follow these steps if you want to add Log4j logging support to your Java project."

Log4j has a concept called **Category** using which you can classify a package as a category and assign a appender to that category alone. To make this point clear, consider that we have the below Java classes in our project:

```java
    com.someapp.service.myservice.SomeServiceClass.java

    com.someapp.dao.SomeDaoClass.java
```


Now, if we want to send the log messages from SomeServiceClass.java to service.log and SomeDaoClass.java to dao.log files respectively, then the log4j configuration would be something like this:

```java
    log4j.category.com.someapp.service = INFO, serviceFileAppender
    log4j.category.com.someapp.dao = INFO, daoFileAppender
    log4j.rootLogger = INFO, defaultAppender
```

As you can see in above snippet, we are defining two categories for the *service* and *dao* packages and associating them with the appenders serviceFileAppender and daoFileAppender respectively. These two appender are just any file appenders configured somewhere in the same log4j.properties file. (Have a look at this article: [How to configure the File Appenders in Log4j][2]). So, all the log messages that coming from the classes which resides under the *com.someapp.service* package will go to the serviceFileAppender, which in turn will go to service.log. The same logic applies to dao.log also.

 [2]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file "how to create a FileAppender to log messages into a file, instead of console."

Apart from these two logs, we also defined the defaultAppender as the root logger. Means, the log messages from all the packages will go to defaultAppender, **including the service and dao log messages**. Yes! with the above configuration, the service and dao log messages will be there in two places. In their respective log appenders the defaultAppender.

But, there's a way to prevent this duplicate logging. Read my next post on **Additivity** to learn how.

Next: [Additivity: What and Why?][3]

 [3]: https://veerasundar.com/blog/log4j-tutorial-additivity-what-and-why "Article explains what is log4j additivity and how to use it."

Previous: [How to send the log messages to a File?][4]

 [4]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file "how to create a FileAppender to log messages into a file, instead of console.  Log4j FileAppender - exampe for Logging messages to a file"


Log4j Tutorial : How to send log messages to 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"


Log4j Tutorial : How to send the log messages to a File using Appender


If you are new to Log4j, here is a short description on what is it and why should we care about it:

> [Log4j][1] is a flexible logging library, an open source project from Apache. Using Log4j, we can replace the debugging print line statements, like _System.out.println('Value is ' someVariable),_ with a configurable logging statement like logger.debug('Value is ' someVariable). The advantage in using Log4j is, if you do not want to print the debugging print lines in production application, you can easily switch them off using Log4j configuration file (which we will see it how, shortly).

[1]: http://logging.apache.org/log4j/index.html "With log4j it is possible to enable logging at runtime without modifying the application binary. The log4j package is designed so that these statements can remain in shipped code without incurring a heavy performance cost. Logging behavior can be controlled by editing a configuration file, without touching the application binary."

### How to add Log4j logger support to your project?

1.  [Download the latest Log4j distribution][2] from Apache website (at the time of this article is written, the latest version of Log4j is 1.2) and put the _log4j-xxx.jar_ in your project class path. For Java web application, you can place the jar file in _WEB-INF/lib_ folder. For Java applications, you can place the jar in any folder, but remember to add the folder to your classpath.
2.  Next we need to configure the Log4j library to our requirements. Log4j reads its configurations from log4j.properties file (or log4j.xml) placed in the CLASSPATH. Every log4j.properties file defines the following three things, mainly:
    - an **Log4j Appender** - this is the class file which does the actual logging. It could be a simple Console appender which writes  the log messages to stdout (screen) or a file appender, which sends the log messages to a log file.
    - a **Layout** - is nothing but how the log message is formatted. This format is very simlar to C languages's _printf_ function formatting.
    - and a **Logger** - a logger ties the appender with the log messages that are coming from the Java application. Basically, a **logger** tells that the log messages from these packages should go to some **appender** which will log the message in the defined **layout.**
3.  Below is a sample log4j.properties for configuring the console appender for your project. In this properties file, we are first defining a Console appender and a layout pattern (refer this [complete documentation][3] to know what's the weired symbols in the conversion patterns means). Then we are mapping all the _DEBUG_ level log messages from the entire application to go into the consoleAppender, since we added the consoleAppender to the rootLogger.

    ```java

        #define the console appender
        log4j.appender.consoleAppender = org.apache.log4j.ConsoleAppender

        # now define the layout for the appender
        log4j.appender.consoleAppender.layout = org.apache.log4j.PatternLayout
        log4j.appender.consoleAppender.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

        # now map our console appender as a root logger, means all log messages will go to this appender
        log4j.rootLogger = DEBUG, consoleAppender

    ```

4.  In any of your Java file, add the below lines, in order to start logging.

    ```java

        private static Logger logger = Logger.getLogger(MyclassName.class);
        logger.debug("this is a sample log message.");
    ```

5.  Now you are done. Run your application and you should be seeing the log messages coming in your console window.

Next: [How to send log messages to a file?][4]

[2]: http://logging.apache.org/log4j/1.2/download.html "Download Apache log4j 1.2.15"
[3]: http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html "Class PatternLayout - A flexible layout configurable with pattern string."
[4]: https://veerasundar.com/blog/log4j-tutorial-how-to-send-the-log-messages-to-a-file "How to send log messages to a file"


#log4j (9)