How do I create a rolling log files?

In this example we create a rolling or a sequenced of log files. Instead of just limiting the file size (see. How do I limit the size of log file) we can also make the log file to roll. This will prevent a lost to an important log message if we use a single log file.

When using more that one file the log file name will have a sequence number in it starting from 0 to N-1. If we set the count to 5 then we’ll have log files such as myapp.log.0, myapp.log.1 up to myapp.log.5.

If the first log file (myapp.log.0) is about to full, it will be renamed to (myapp.log.1) before the log is written to the first log file. The log is always written to the first file (myapp.log.0).

To read the log messages in sequence you need to start from the highest to the lowest sequence number.

package org.kodejava.example.logging;

import java.util.logging.Logger;
import java.util.logging.FileHandler;
import java.util.logging.SimpleFormatter;
import java.io.IOException;

public class RollingLogFile {
    //
    // Set a small log file size to demonstrate the rolling log files.
    //
    public static final int FILE_SIZE = 1024;

    public static void main(String[] args) {
        Logger logger = Logger.getLogger(RollingLogFile.class.getName());

        try {
            //
            // Creating an instance of FileHandler with 5 logging files
            // sequences.
            //
            FileHandler handler = new FileHandler("myapp.log", FILE_SIZE, 5, true);
            handler.setFormatter(new SimpleFormatter());
            logger.addHandler(handler);
            logger.setUseParentHandlers(false);
        } catch (IOException e) {
            logger.warning("Failed to initialize logger handler.");
        }

        logger.info("Logging information message.");
        logger.warning("Logging warning message.");
    }
}

By running this program multiple times you’ll see the creation of the log file one by one.

How do I limit the size of log file?

In this example you learn how to limit the size of a log file when using a
FileHandler handler. Limiting the log file will prevent the log
file to grow wildly without limit.

package org.kodejava.example.util.logging;

import java.util.logging.Logger;
import java.util.logging.FileHandler;
import java.io.IOException;

public class LogFileLimit {
    //
    // The log file size is set to 1MB.
    //
    public static final int FILE_SIZE = 1024 * 1024;

    public static void main(String[] args) {
        Logger logger = Logger.getLogger(LogFileLimit.class.getName());

        try {
            //
            // Create a FileHandler with 1MB file size and a single log file. We
			// also tell the handler to append the log message.
            //
            FileHandler handler = new FileHandler("myapp.log", FILE_SIZE, 1, true);
            logger.addHandler(handler);
        } catch (IOException e) {
            logger.warning("Failed to initialize logger handler.");
        }

        logger.info("Test info");
        logger.warning("Test warning");
        logger.severe("Test severe");
    }
}

How do I create a custom logger Formatter?

To create a custom Formatter we need to extends the Formatter abstract class and implements the format(LogRecord) method. In the method then we can format the log message stored in the LogRecord to match our need.

The Formatter class also have the getHead(Handler) and getTail(Handler) which can be overridden to add a head and a tail to our log message.

package org.kodejava.example.util.logging;

import java.util.logging.*;
import java.util.Locale;
import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class LogCustomFormatter {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(LogCustomFormatter.class.getName());
        logger.setUseParentHandlers(false);

        MyFormatter formatter = new MyFormatter();
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(formatter);

        logger.addHandler(handler);
        logger.info("Example of creating custom formatter.");
        logger.warning("A warning message.");
        logger.severe("A severe message.");
    }
}

class MyFormatter extends Formatter {
    //
    // Create a DateFormat to format the logger timestamp.
    //
    private static final DateFormat df = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss.SSS");

    public String format(LogRecord record) {
        StringBuilder builder = new StringBuilder(1000);
        builder.append(df.format(new Date(record.getMillis()))).append(" - ");
        builder.append("[").append(record.getSourceClassName()).append(".");
        builder.append(record.getSourceMethodName()).append("] - ");
        builder.append("[").append(record.getLevel()).append("] - ");
        builder.append(formatMessage(record));
        builder.append("\n");
        return builder.toString();
    }

    public String getHead(Handler h) {
        return super.getHead(h);
    }

    public String getTail(Handler h) {
        return super.getTail(h);
    }
}

Below is an output produced by the custom formatter above.

01/05/2009 06:22:09.372 - [org.kodejava.example.util.logging.LogCustomFormatter.main] - [INFO] - Example of creating custom formatter.
01/05/2009 06:22:09.374 - [org.kodejava.example.util.logging.LogCustomFormatter.main] - [WARNING] - A warning message.
01/05/2009 06:22:09.374 - [org.kodejava.example.util.logging.LogCustomFormatter.main] - [SEVERE] - A severe message.

How do I prevent the logger send log messages to its parent logger?

To prevent log records being forwarded to the logger’s parent handlers we can
set false the useParentHandlers field using the
Logger.setUserParentHandlers(boolean useParentHandlers) method.

package org.kodejava.example.util.logging;

import java.util.logging.Logger;
import java.util.logging.ConsoleHandler;

public class NoParentLogger {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(NoParentLogger.class.getName());

        //
        // Do not forward any log messages the the logger parent handlers.
        //
        logger.setUseParentHandlers(false);

        //
        // Specify a ConsoleHanlder for this logger instance.
        //
        logger.addHandler(new ConsoleHandler());
        logger.info("Logging an information message.");
    }
}

How do I set the formatter of logger handlers?

In this example we’ll see how to set the formatter for the logger handlers.
We set the formatter by calling the Handler.setFormatter() method.
In the code below we set a SimpleFormatter for our FileHandler
handler and XMLFormatter for the ConsoleHandler
handler.

This SimpleFormatter format the log in a plain text information
while on the other side the XMLFormatter format the log record in
XML format.

package org.kodejava.example.util.logging;

import java.util.logging.*;
import java.io.IOException;

public class LogFormatter {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(LogFormatter.class.getName());

        try {
            //
            // Create a FileHanlder that will log to mylog.txt with a
            // SimpleFormatter.
            //
            FileHandler simpleHandler = new FileHandler("mylog.txt", true);
            simpleHandler.setFormatter(new SimpleFormatter());
            logger.addHandler(simpleHandler);

            //
            // Create a ConsoleHanlder that will log to the console with
            // an XMLFormatter.
            //
            ConsoleHandler consoleHandler = new ConsoleHandler();
            consoleHandler.setFormatter(new XMLFormatter());
            logger.addHandler(consoleHandler);

            //
            // Do not sent the message to parent handlers. 
            //
            logger.setUseParentHandlers(false);
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Fail to create logger file handler.", e);
        }

        logger.info("Logging application information message.");
        logger.warning("Logging application warning message.");
    }
}

How do I compare Logger Level severity?

In this example we see how we can compare the Level severity
between two levels. The Level class has an intValue()
method that return the integer value of Level‘s severity.

package org.kodejava.example.util.logging;

import java.util.logging.Level;

public class LogLevelSeverityCompare {
    public static void main(String[] args) {
        Level info = Level.INFO;
        Level warning = Level.WARNING;
        Level finest = Level.FINEST;

        //
        // To compare the Level severity we compare the intValue of the Level.
        // Each level is assigned a unique integer value as the severity
        // weight of the level.
        //
        if (info.intValue() < warning.intValue()) {
            System.out.println(info + "(" + info.intValue() + ") is less severe than " +
                    warning + "(" + warning.intValue() + ")");
        }

        if (finest.intValue() < info.intValue()) {
            System.out.println(finest + "(" + finest.intValue() + ") is less severe than " +
                    info + "(" + info.intValue()+ ")");
        }
    }
}

When we run the program above will see the following result:

INFO(800) is less severe than WARNING(900)
FINEST(300) is less severe than INFO(800)

How do I get the current Level of a Logger?

Here we demonstrate how to obtain the current level of the Logger
instance. When the level is not set explicitly the level will be inherited from
the parent logger.

package org.kodejava.example.util.logging;

import java.util.logging.Logger;
import java.util.logging.Level;

public class LoggerGetLevel {
    private static Logger logger = Logger.getLogger(LoggerGetLevel.class.getName());

    public static void main(String[] args) {
        LoggerGetLevel demo = new LoggerGetLevel();
        System.out.println("demo.getLevel(logger) = " + demo.getLevel(logger));

        logger.setLevel(Level.WARNING);
        System.out.println("demo.getLevel(logger) = " + demo.getLevel(logger));
    }

    public Level getLevel(Logger logger) {
        Level level = logger.getLevel();
        if (level == null && logger.getParent() != null) {
            level = logger.getParent().getLevel();
        }
        return level;
    }
}

How do I set the Logger log level?

In this example you see how we can change or set the Logger log
level. The log level will tell the Logger which particular log message
will be logged.

Logger will only record the log message if the level is equal or
higher than the Logger level. For instance when the level set to
Level.SEVERE, no message other than message logged with Logger.severe(String message)
of Logger.log(Level level, String message) will be logged.

package org.kodejava.example.util.logging;

import java.util.logging.Logger;
import java.util.logging.Level;

public class LogLevelSetting {
    //
    // Obtains a Logger instance, it will create one if it is not already exist.
    //
    private static Logger logger = Logger.getLogger(LogLevelSetting.class.getName());

    public static void main(String[] args) {
        //
        // Set the log level to Level.INFO, the severe message will be logged.
        //
        logger.setLevel(Level.INFO);
        logger.severe("This message will be logged.");

        //
        // Set the log level to Level.SEVERE, the warning message will not be
        // logged as Level.WARNING is smaller than Level.SEVERE
        //
        logger.setLevel(Level.SEVERE);
        logger.warning("This message won't be logged.");

        //
        // Turn of the log, no message will be logged.
        //
        logger.setLevel(Level.OFF);
        logger.info("All log is turned off.");

        //
        // Turn the logger back on, this will result all the corresponding
        // logger message below will be logged.
        //
        logger.setLevel(Level.ALL);
        logger.info("Information message.");
        logger.warning("Warning message.");
        logger.severe("Severe message.");
    }
}

If we run the program above will see the following result displayed:

29 Apr 09 10:06:50 org.kodejava.example.util.logging.LogLevelSetting main
SEVERE: This message will be logged.
29 Apr 09 10:06:50 org.kodejava.example.util.logging.LogLevelSetting main
INFO: Information message.
29 Apr 09 10:06:50 org.kodejava.example.util.logging.LogLevelSetting main
WARNING: Warning message.
29 Apr 09 10:06:50 org.kodejava.example.util.logging.LogLevelSetting main
SEVERE: Severe message.

In the result above we see that the "This message won't be logged."
is not displayed.

How do I set a filter on a logger handler?

This example give you an example on how to set the Filter of a
logger handler. In the code below we implements the Filter on the
FileHandler to log only a Level.SEVERE message. Other
level log will not recorded to the file.

package org.kodejava.example.util.logging;

import java.util.logging.*;
import java.io.IOException;

public class LoggerFilter {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(LoggerFilter.class.getName());

        FileHandler handler = null;
        try {
            handler = new FileHandler("myapp.log");
            handler.setFilter(new Filter() {
                public boolean isLoggable(LogRecord record) {
                    //
                    // When the LogRecord level is equals to Level.SEVERE the 
                    // message is recorded to the file.
                    //
                    return record.getLevel().equals(Level.SEVERE);
                }
            });
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Fail to create logger handler", e);
        }

        logger.addHandler(handler);

        logger.info("Information message");
        logger.warning("Warning message");
        logger.severe("Severe message");
    }
}

How do I use Logger’s MemoryHandler class?

In this example we demo the use of Logger‘s MemoryHandler
to log only when some conditions happen in our application, for example when a
Level.SEVERE message is logged.

We create an instance of MemoryHandler that will delegate the log to
FileHandler class and it logs the last 100 record until a Level.SEVERE
message is logged.

package org.kodejava.example.util.logging;

import java.util.logging.Logger;
import java.util.logging.FileHandler;
import java.util.logging.MemoryHandler;
import java.util.logging.Level;

public class MemoryHandlerDemo {
    public static void main(String[] args) {
        MemoryHandlerDemo demo = new MemoryHandlerDemo();
        try {
            demo.testMethod();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void testMethod() throws Exception {
        Logger logger = Logger.getLogger(MemoryHandlerDemo.class.getName());
        FileHandler fileHandler = new FileHandler("myapp.log");

        //
        // Create a MemoryHandler that will dump the log messages for the 
        // latest 100 records when a Level.SEVERE log is logged to by the
        // Logger class.
        //
        MemoryHandler memoryHandler = new MemoryHandler(fileHandler, 100, Level.SEVERE);
        logger.addHandler(memoryHandler);

        //
        // Write some messages to the log
        //
        logger.info("Information message");
        logger.warning("Warning message");
		
		//
		// This causes the log messages dump to the file log.
		//
        logger.severe("Severe message");
    }
}

To check if the message is logged you can open the myapp.log file
created by this small program.