Support free tutorials:











vogella training Training Books



Java Logging API - Tutorial

Lars Vogel

Version 1.5

30.08.2013

Revision History
Revision 0.1 01.07.2007 Lars
Vogel
Created
Revision 0.2 - 1.5 09.07.2007 - 30.08.2013 Lars
Vogel
Bug fixes and Enhancements

Java Logging

This article describes how to use the Logging API in Java programs. It includes an example for creating an HTML logger.


Table of Contents

1. Overview
1.1. Logging
1.2. Logging in Java
1.3. Create a logger
1.4. Level
1.5. Handler
1.6. Formatter
1.7. Log Manager
1.8. Best Practices
2. Example
2.1. Create the logger
2.2. Use the logger
3. Support free vogella tutorials
3.1. Thank you
3.2. Questions and Discussion
4. Links and Literature

1. Overview

1.1. Logging

Logging is the process of writing log messages during the execution of a program to a central place. This logging allows you to report and persists error and warning messages as well as info messages (e.g. runtime statistics) so that the messages can later be retrieved and analyzed.

A Logger is typically called the object which performs the logging.

1.2. Logging in Java

Java contains the Java Logging API. This logging API allows you to configure which message types are written. Individual classes can use this logger to write messages to the configured log files.

The java.util.logging package provides the logging capabilities via the Logger class.

1.3. Create a logger

To create a logger in your Java code you can use the following snippet.

import java.util.logging.Logger;

// assumes the current class is called logger
private final static Logger LOGGER = Logger.getLogger(MyClass.class .getName()); 

The Logger you create a actually a hierarchy of Loggers, and a . (dot) in the hierarchy indicates a level in the hierarchy. So if you get a Logger for the com.example key this Logger is a child of the com Logger and the com Logger is child of the Logger for the empty String. You can configure the main logger and this affects all its children.

1.4. Level

The log levels define the severity of a message. The Level class is used to define which messages should be written to the log.

The following lists the Log Levels in descending order:

  • SEVERE (highest)

  • WARNING

  • INFO

  • CONFIG

  • FINE

  • FINER

  • FINEST

In addition to that you have also the levels OFF and ALL to turn the logging of or to log everything.

For example the following example code sets the logger to the info level, which means all messages with severe, warning and info will be logged.

LOGGER.setLevel(Level.INFO); 

1.5. Handler

Each logger can have access to several handler.

The handler receives the log message from the logger and exports it to a certain target

A handler can be turn off with the setLevel(Level.OFF) method and turned on with setLevel() method.

You have several standard handler, the following list gives some examples.

  • ConsoleHandler: Write the log message to console

  • FileHandler: Writes the log message to file

Log Levels INFO and higher will be automatically written to the console.

1.6. Formatter

Each handlers output can be configured with a formatter

Available formatter

  • SimpleFormatter Generate all messages as text

  • XMLFormatter Generates XML output for the log messages

You can also build your own formatter. The following is an example of a formatter which will use create HTML output.

package com.vogella.logger;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;

//This custom formatter formats parts of a log record to a single line
class MyHtmlFormatter extends Formatter {
  // This method is called for every log records
  public String format(LogRecord rec) {
    StringBuffer buf = new StringBuffer(1000);
    // Bold any levels >= WARNING
    buf.append("<tr>");
    buf.append("<td>");

    if (rec.getLevel().intValue() >= Level.WARNING.intValue()) {
      buf.append("<b>");
      buf.append(rec.getLevel());
      buf.append("</b>");
    } else {
      buf.append(rec.getLevel());
    }
    buf.append("</td>");
    buf.append("<td>");
    buf.append(calcDate(rec.getMillis()));
    buf.append(' ');
    buf.append(formatMessage(rec));
    buf.append('\n');
    buf.append("<td>");
    buf.append("</tr>\n");
    return buf.toString();
  }

  private String calcDate(long millisecs) {
    SimpleDateFormat date_format = new SimpleDateFormat("MMM dd,yyyy HH:mm");
    Date resultdate = new Date(millisecs);
    return date_format.format(resultdate);
  }

  // This method is called just after the handler using this
  // formatter is created
  public String getHead(Handler h) {
    return "<HTML>\n<HEAD>\n" + (new Date()) 
        + "\n</HEAD>\n<BODY>\n<PRE>\n"
        + "<table width=\"100%\" border>\n  "
        + "<tr><th>Level</th>" +
        "<th>Time</th>" +
        "<th>Log Message</th>" +
        "</tr>\n";
  }

  // This method is called just after the handler using this
  // formatter is closed
  public String getTail(Handler h) {
    return "</table>\n  </PRE></BODY>\n</HTML>\n";
  }
} 

1.7. Log Manager

The log manager is responsible for creating and managing the logger and the maintenance of the configuration.

We could set the logging level for a package, or even a set of packages, by calling the LogManager.setLevel(String name, Level level) method. So, for example, we could set the logging level of all loggers "logging" to Level.FINE by making this call:

LogManager.getLogManager().getLogger(Logger.GLOBAL_LOGGER_NAME).setLevel(Level.FINE); 

1.8. Best Practices

It is common practice to use the fully qualified name of each class whose activity is being logged as a message category because this allows developers to fine-tune log settings for each class.

Using the fully qualified class name of your class as the name of your Logger is the approach recommended by the Logging API documentation.

2. Example

2.1. Create the logger

This example is stored in the project called com.vogella.logger.

Create your own formatter class.

package com.vogella.logger;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogRecord;

//This custom formatter formats parts of a log record to a single line
class MyHtmlFormatter extends Formatter {
  // This method is called for every log records
  public String format(LogRecord rec) {
    StringBuffer buf = new StringBuffer(1000);
    // Bold any levels >= WARNING
    buf.append("<tr>");
    buf.append("<td>");

    if (rec.getLevel().intValue() >= Level.WARNING.intValue()) {
      buf.append("<b>");
      buf.append(rec.getLevel());
      buf.append("</b>");
    } else {
      buf.append(rec.getLevel());
    }
    buf.append("</td>");
    buf.append("<td>");
    buf.append(calcDate(rec.getMillis()));
    buf.append(' ');
    buf.append(formatMessage(rec));
    buf.append('\n');
    buf.append("<td>");
    buf.append("</tr>\n");
    return buf.toString();
  }

  private String calcDate(long millisecs) {
    SimpleDateFormat date_format = new SimpleDateFormat("MMM dd,yyyy HH:mm");
    Date resultdate = new Date(millisecs);
    return date_format.format(resultdate);
  }

  // This method is called just after the handler using this
  // formatter is created
  public String getHead(Handler h) {
    return "<HTML>\n<HEAD>\n" + (new Date()) 
        + "\n</HEAD>\n<BODY>\n<PRE>\n"
        + "<table width=\"100%\" border>\n  "
        + "<tr><th>Level</th>" +
        "<th>Time</th>" +
        "<th>Log Message</th>" +
        "</tr>\n";
  }

  // This method is called just after the handler using this
  // formatter is closed
  public String getTail(Handler h) {
    return "</table>\n  </PRE></BODY>\n</HTML>\n";
  }
} 

Initialize the logger via the following code. This Logger class uses the new HTML formatter you created.

package com.vogella.logger;

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

public class MyLogger {
  static private FileHandler fileTxt;
  static private SimpleFormatter formatterTxt;

  static private FileHandler fileHTML;
  static private Formatter formatterHTML;

  static public void setup() throws IOException {

    // Get the global logger to configure it
    Logger logger = Logger.getLogger(Logger.GLOBAL_LOGGER_NAME);

    logger.setLevel(Level.INFO);
    fileTxt = new FileHandler("Logging.txt");
    fileHTML = new FileHandler("Logging.html");

    // create txt Formatter
    formatterTxt = new SimpleFormatter();
    fileTxt.setFormatter(formatterTxt);
    logger.addHandler(fileTxt);

    // create HTML Formatter
    formatterHTML = new MyHtmlFormatter();
    fileHTML.setFormatter(formatterHTML);
    logger.addHandler(fileHTML);
  }
}
 

2.2. Use the logger

The following example class demonstrates how you can use your MyLogger class to create log messages.

package com.vogella.logger.test;

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

import com.vogella.logger.MyLogger;

public class UseLogger {
  // use the classname for the logger, this way you can refactor
  private final static Logger LOGGER = Logger.getLogger(UseLogger.class
      .getName());

  public void doSomeThingAndLog() {
    // ... more code

    // now we demo the logging

    // set the LogLevel to Severe, only severe Messages will be written
    LOGGER.setLevel(Level.SEVERE);
    LOGGER.severe("Info Log");
    LOGGER.warning("Info Log");
    LOGGER.info("Info Log");
    LOGGER.finest("Really not important");

    // set the LogLevel to Info, severe, warning and info will be written
    // finest is still not written
    LOGGER.setLevel(Level.INFO);
    LOGGER.severe("Info Log");
    LOGGER.warning("Info Log");
    LOGGER.info("Info Log");
    LOGGER.finest("Really not important");
  }

  public static void main(String[] args) {
    UseLogger tester = new UseLogger();
    try {
      MyLogger.setup();
    } catch (IOException e) {
      e.printStackTrace();
      throw new RuntimeException("Problems with creating the log files");
    }
    tester.doSomeThingAndLog();
  }
}
 

Tip

After you ran your program you need to Refresh your project in Eclipse (or check the file system directly) to see the files in the Package Explorer view.

3. Support free vogella tutorials

Maintaining high quality free online tutorials is a lot of work. Please support free tutorials by donating or by reporting typos and factual errors.

3.1. Thank you

Please consider a contribution if this article helped you.

Flattr this

3.2. Questions and Discussion

If you find errors in this tutorial, please notify me (see the top of the page). Please note that due to the high volume of feedback I receive, I cannot answer questions to your implementation. Ensure you have read the vogella FAQ as I don't respond to questions already answered there.

4. Links and Literature

http://www.onjava.com/pub/a/onjava/2002/06/19/log.html

An introduction to the Java Logging API," Brian Gilstrap (OnJava.com, June 2002) talks about the use of the standard logging API.

http://www.fawcette.com/javapro/2002_06/magazine/features/shalloway/

The Java Logging API," Stuart Dabbs Halloway (JavaPro, June 2002) is another good introduction to the API.