
Sometimes, I'm just lazy to type 'Ëœ*console.log*'Ëœ to print some data on the Firebug console. I often wanted to have a simple *echo() *function that spits whatever it gets to the console.

So, in every single JavaScript project I work on, I used to have this utility method:

```javascript
    function echo(obj){
      console.log(obj);
    }
    ...
    echo('Hello World');
```

It worked well. But there was a problem. The printed message on the console will always show the line number of *console.log  *as the source line number instead of showing the where exactly the *echo() *function is invoked.

There's another way to solve this. Instead of creating a new *echo() *method, I just need to bind it to the existing *console.log() *to a variable and the logging works like a charm. Like this,

```javascript
    window.echo = console.log.bind(console);
    window.oops = console.error.bind(console);
    ...
    echo('hello world');
    ...
    oops('I did it again');
```

The methods became shorter and the correct line numbers printed on the console!


Shortcut to console.log


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?


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


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?


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"


#logging (7)