Write custom appenders for log4j

Extend log4j to support lightweight over-the-network logging

Logging is the simple process of printing messages of various types to known places. Logging messages can go to a console, to a file, to a remote monitor, or anywhere else that you find convenient. Think of logging as a sophisticated sibling of:

 if( debug )
    System.out.println("Debugging diagnostic");

Logging has several advantages over simple


statements, however. The logging system can add contextual information—filename, line number, and date, for example—to the message automatically. You can redirect the messages to different destinations, or change the formatting, without recompiling your program. (In log4j, you just modify a simple properties file.) You can easily turn categories of messages on and off so you can see debug messages when you're debugging, but easily turn them off when you're not, for example.

Logging is central to all of my programs. I use it to monitor my program's progress as it works. I use it to log error messages from library methods that might be used in a server-side context (where there's no console on which to print a stack trace). Most importantly, logging is one of my main debugging tools. Though visual debuggers are handy on occasion, I've noticed that I can find more bugs faster by combining a careful reading of the code with a few well-placed logging messages. (I'm not quite sure why reading/logging seems more effective than visual debugging, but my current theory is that a visual debugger narrows your focus to a single thread of control through the program, so you tend to miss bugs that aren't on that thread.)

Logging is essential in server-side debugging, where, typically, no console exists, so System.out proves useless. For example, Tomcat sends System.out to its own log file, so you never see messages that are sent there unless you have access to that log file. More to the point, you probably want to monitor a server's performance from somewhere other than the server itself. Checking server logs is nice, but I'd much rather see the logs on my workstation.

One of the better logging systems around is the Apache Software Foundation's log4j project. It's more flexible and easier to use than Java's built-in APIs. It's also a trivial install—you just put a jar file and a simple configuration file on your CLASSPATH. (Resources includes a good introduction article to log4j.) Log4j is a free download. The stripped-down but adequate-for-the-end-user documentation is also free. But you have to pay 0 for the complete documentation, which I recommend.

This article will look at how to extend log4j by adding a new appender—the part of the system responsible for actually sending the log messages somewhere. The appender I discuss is a lightweight version of the socket-based appender that comes with log4j, but you can easily add your own appenders to put log messages into a database or LDAP (lightweight directory access protocol) directory, wrap them in proprietary protocols, route them to specific directories, and so forth.

Using log4J

Listing 1 demonstrates how to use log4j. You create a


object associated with the current class. (The string argument to


is actually arbitrary, but the class name is by far the most useful name for the logger.)

Then, when you want to log a message, you just send it to the logger. Logged messages typically fall into one of five categories: debug, info, warn, error, or fatal, and methods named




, and so on, handle each of these. When you're done logging, it's good style to shut down the logging subsystem with a call to


(at the bottom of


). This call is particularly important for the example I'm about to cover because


indirectly causes socket connections to remote clients to shut down in an orderly way.

Listing 1. Test.java: Using the log4j classes

  1  import org.apache.log4j.Logger;
   2  import org.apache.log4j.LogManager;
   4  public class Test
   5  {
   6      private static final Logger log = Logger.getLogger( "com.holub.log4j.Test");
   8      public static void main(String[] args) throws Exception
   9      {
  10          // For testing, give the client that will display the
  11          // logged messages a moment to connect.
  12          // (It's in a 50-ms wait loop, so pausing for
  13          // 100 ms should do it).
  14          Thread.currentThread().sleep( 100 );
  16          log.debug("Debug   Message");
  17          log.warn ("Warning Message");
  18          log.error("Error   Message");
  20          Thread.currentThread().sleep( 100 );
  21          LogManager.shutdown();
  22      }
  23  }

The only other piece of the puzzle is a simple configuration file, which (thankfully) is not in XML format. It's a simple properties file, like the one in Listing 2.

To understand the file, you need to know a little about the logger architecture. Loggers form a runtime hierarchy of objects, organized by name. The "root" logger is at the root of the hierarchy, and the loggers you create are beneath the root (and each other), depending on their names. For example, a logger named a.b is beneath the logger named a, which is beneath the root.

Loggers write strings using two main helper classes called appenders and layouts. An appender object does the actual writing, and a layout object formats the message. Appenders are bound to a logger at runtime using information in the configuration file—this way, you can change them without recompiling. A particular logger can use several appenders, in which case, each appender sends the message somewhere, thus duplicating messages in several places. Log4j comes with several appenders that do things like console and file output and send logging messages using email or JMS (Java Message Service). Log4j also includes a socket-based appender similar to the one I illustrate in this article.

Layout objects, which control message formatting, are bound to appenders at runtime in a manner similar to loggers and appenders. Log4J comes with several layout classes, which format in XML, HTML, and by means of a printf-like format string. I've found these to be adequate for most of my needs.

Finally, loggers also have filtering. The idea is to filter out, or discard, all categories of messages below a certain priority. The categories I mentioned earlier (debug, info, warn, error, or fatal) are in priority order. (Debug is the lowest and fatal, the highest.) You can filter all messages at or below a specified level simply by telling the logger to do so—either in your code or in the configuration file.

Turning to Listing 2, the first line specifies the filter level (


) and the appenders (




, and


) attached to the root logger. All loggers beneath the root in the runtime hierarchy inherit this filter level and these appenders, so this line effectively controls logging for the whole program (unless you use a more complex configuration file to specify something different).

The remainder of the configuration file specifies properties for the appenders. For example, Listing 2's second line says that the file appender named


is an instance of the


class. Subsequent lines initialize this appender object when it's created—in this case, passing it the name of the file in which it will put the log messages, the layout object to use, and a format string for that layout object.

The rest of the configuration file does the same for the other appenders. The


appender sends messages to the console, and the


appender sends messages down a socket. (We'll look at the source code for the


appender shortly.)

At runtime, log4j creates all the required classes for you, hooks them up as necessary, and passes the arguments you specify in the configuration file to the newly created objects using JavaBean-style "setter" methods.

Listing 2. log4j.properties: A log4j configuration file

 log4j.rootLogger=DEBUG, FILE, CONSOLE, REMOTE
log4j.appender.FILE.layout.ConversionPattern=[%d{MMM dd HH:mm:ss}] %-5p (%F:%L) - %m%n
log4j.appender.CONSOLE.layout.ConversionPattern=[%d{MMM dd HH:mm:ss}] %-5p (%F:%L) - %m%n
log4j.appender.REMOTE.layout.ConversionPattern=[%d{MMM dd HH:mm:ss}] %-5p (%F:%L) - %m%n

Using a remote appender

One of log4j's major strengths is that the tool is easy to extend. My


extension provides a way to log messages across the network to a simple socket-based client application. Log4J actually comes with a means of doing remote logging (an appender called


), but this default mechanism is too heavyweight for my needs. It requires you to have the log4j packages on the remote client, for example.

Log4j also comes with an elaborate standalone GUI called Chainsaw that you can use to view messages from a


. But Chainsaw is also way more than I need and really badly documented to boot. (I've never have had the time or patience to figure out how to use Chainsaw.) In any event, I just wanted to watch debugging diagnostics scroll by on a console window as I tested. Chainsaw was way too much for this simple need.

Listing 3 shows a simple viewer application for my


. It's just a simple socket-based client application that waits in a loop until it can open a socket to the server application that logs the messages. (See


for a discussion of sockets and Java's socket APIs). The port number, which is hard-coded into this simple example (as


) is passed to the server via the configuration file in Listing 2. Here's the relevant line:


The client application waits in a loop until it can connect to the server, and then it just reads messages from the server and prints them to the console. Nothing earth shattering. The client knows nothing about log4j—it just reads strings and prints them—so the coupling to the log4j systems is nonexistent. Launch the client with

java Client

and terminate it with a Ctrl-C.

Listing 3. Client.java: A client for viewing logging messages

  1  import java.net.*;
   2  import java.io.*;
   4  public class Client
   5  {
   6      public static void main(String[] args) throws Exception
   7      {
   8          Socket s;
   9          while( true )
  10          {   try
  11              {
  12                  s = new Socket( "localhost", 1234 );
  13                  break;
  14              }
  15              catch( java.net.ConnectException e )
  16              {   // Assume that the host isn't available yet, wait
  17                  // a moment, then try again.
  18                  Thread.currentThread().sleep(50);
  19              }
  20          }
  22          BufferedReader in = new BufferedReader(
  23                                  new InputStreamReader( s.getInputStream() ) );
  25          String line;
  26          while( (line = in.readLine()) != null )
  27              System.err.println( line );
  28      }
  29  }

Note, by the way, that the client in Listing 3 is a great example of when not to use Java's NIO (new input/output) classes. There's no need for asynchronous reading here, and NIO would complicate the application considerably.

The remote appender

All that's left is the appender itself, which manages the server-side socket and writes the output to the clients that connect to it. (Several clients can receive logging messages from the same appender simultaneously.) The code is in Listing 4.

Starting with the basic structure, the


extends log4j's


class, which does all of the boilerplate work of creating an appender for you. You must do two things to make an appender: First, if your appender needs to be passed arguments from the configuration file (like the port number), you need to provide a getter/setter function with the names




for a property named


. I've done that for the


property on line 41 of Listing 4.

Note that both the getter and setter methods are


. They're provided strictly for use by the log4j system when it creates and initializes this appender, and no other object in my program has any business accessing them. Making




guarantees that normal code can't access the methods. Since log4j accesses these methods via the introspection APIs, it can ignore the


attribute. Unfortunately, I've noticed that private getters and setters work only in some systems. I have to redefine these fields as public to get the appender to work correctly under Linux, for example.

The second order of business is to override a few methods from the AppenderSkeleton superclass.

After log4j has parsed the configuration file and called any associated setters, the


method (Listing 4, line 49) is called. You can use


to validate property values, but here I'm using it to actually open up a server-side socket at the specified port number.

1 2 Page 1
Page 1 of 2
How to choose a low-code development platform