
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-tutorial (4)