Logging - Java

Logging
java.util.logging -> Used to create Log records -> plain text or XML-formatted -> Java program to log the error and messages into the log file

Why?

Facilitate software servicing and maintenance at customer sites by producing log reports suitable for analysis by end users, system administrators, field service engineers, and software development teams
> Capture information such as security failures, configuration errors, performance bottlenecks, and/or bugs in the application or platform


Logger and Handler
• Applications make logging calls on Logger objects.
• The Logger objects allocate LogRecord objects which are passed to Handler objects for publication.


Filter and Formatter
• Both Loggers and Handlers may use (optionally) Filters to decide if they are interested in a particular LogRecord
• When it is necessary to publish a LogRecord externally, a Handler can (optionally) use a
Formatter to localize and format the message before publishing it to an I/O stream

Two Standard Formaters
• SimpleFormatter > Writes brief "human-readable" summaries of log records.
• XMLFormatter > Writes detailed XML-structured information.
Handlers
• StreamHandler > A simple handler for writing formatted records to an OutputStream.
• ConsoleHandler > A simple handler for writing formatted records to System.err
• FileHandler > A handler that writes formatted log records either to a single file, or
to a set of rotating log files.
• SocketHandler > A handler that writes formatted log records to remote TCP ports.
• MemoryHandler > A handler that buffers log records in memory.

Logging Levels

• The Logging level gives a rough guide to the importance and urgency of a log message
 Log level objects encapsulate an integer value, with higher values indicating higher priorities
SEVERE (highest), WARNING, INFO, CONFIG, FINE, FINER, FINEST
• The Level class defines seven standard log levels
> FINEST (lowest priority)
> SEVERE (highest priority)
 ALL - ALL indicates that all messages should be logged.
 OFF - OFF is a special level that can be used to turn off logging
Logger
• When client code sends log requests to Logger objects, each logger keeps track of a log level that it is interested in, and discards log requests that are below this level.

Logging Methods
• The Logger class provides a large set of convenience methods for generating log messages
• Two different styles of logging methods
> void warning(String sourceClass, String sourceMethod, String msg);
> void warning(String msg);

To create java logging program you need a
 Create a Logger object.
 The Logger object contains log messages.
 Logger has one or more handler that performs log records.

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

public class MyLogger {
  public static void main(String[] args) {
    Logger logger = Logger.getLogger("MyLog");
    FileHandler fh;
    try {
      // This block configure the logger with handler and formatter
      fh = new FileHandler("c:\\MyLogFile.log", true);
      logger.addHandler(fh);
      logger.setLevel(Level.ALL);
      SimpleFormatter formatter = new SimpleFormatter();
      fh.setFormatter(formatter);
      // the following statement is used to log any messages  
      logger.log(Level.WARNING,"My first log");
    } catch (SecurityException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

log
public void log(Priority priority,
                Object message,
                Throwable t)
This generic form is intended to be used by wrappers.
________________________________________
log
public void log(Priority priority,
                Object message)
This generic form is intended to be used by wrappers.

FileHandler(String file_name):
This is the constructor of FileHandler class. FileHandler class extends the StreamHandler. This is the class of java.uti.logging package. The above constructor constructs the FileHandler with given string as file name.
Logger:
This is the constructor of Logger class. The logger class extends the Object. IThis is the class of  java.util.logging package. Logger constructor used for constructing a logger. A logger object contains a log message to the system or application component. The logger object called by the getLogger method and returns a suitable maintain logger.
getLogger(String log_name):
You can find or construct a logger with the help of above method. It takes string types value that can be used for a named subsystem.
addHandler:
It can be used for adding a log handler to get logging message which is maintaining in the warning, info and severe.
warning(String war_message):
This method used for showing the log WARNING message. The given message shows to all output handler objects when the logger is enabled at the time of warning message level. It takes string type value for the warning message.
info(String info_message):
It works same as warning method but it shows log INFO message.
servere(String ser_message):
It also works same as like: warning and info method but it shows log SERVERE message.

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

public class QuintLog{
  public static void main(String[] args) {
  try{
  FileHandler hand = new FileHandler("vk.log");
  Logger log = Logger.getLogger("log_file");
  log.addHandler(hand);
  log.warning("Doing carefully!");
  log.info("Doing something ...");
  log.severe("Doing strictly ");
 
  }
  catch(IOException e){}
  }
}
import java.io.*;
import java.util.logging.*;

public class QuintLog{
  public static void main(String[] args) {
  try{
  FileHandler hand = new FileHandler("vk.log");
  Logger log = Logger.getLogger("log_file");
  log.addHandler(hand);
      SimpleFormatter formatter = new SimpleFormatter();
      hand.setFormatter(formatter);

  log.warning("Doing carefully!");
  log.info("Doing something ...");
  log.severe("Doing strictly ");
  }
  catch(IOException e){}
  }
}


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

public class QuintLog{
  public static void main(String[] args) {
  try{
  FileHandler hand = new FileHandler("vk.log");
  Logger log = Logger.getLogger("log_file");
  log.addHandler(hand);
      SimpleFormatter formatter = new SimpleFormatter();
      hand.setFormatter(formatter);

log.setLevel(Level.INFO);
log.severe("This message will be logged.");
log.setLevel(Level.SEVERE);
log.warning("This message won't be logged.");
log.setLevel(Level.OFF);
log.info("All log is turned off.");
log.setLevel(Level.ALL);
log.info("Information message.");
log.warning("Warning message.");
log.severe("Severe message.");
  }
  catch(IOException e){}
  }
}
import java.io.*;
import java.util.logging.*;

public class QuintLog{
  public static void main(String[] args) {
  try{
  Logger log = Logger.getLogger("log_file");

log.setLevel(Level.INFO);
log.severe("This message will be logged.");
log.setLevel(Level.SEVERE);
log.warning("This message won't be logged.");
log.setLevel(Level.OFF);
log.info("All log is turned off.");
log.setLevel(Level.ALL);
log.info("Information message.");
log.warning("Warning message.");
log.severe("Severe message.");
  }
  catch(IOException e){}
  }
}
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.

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

public class LogException{
  public static void main(String[] args) {
  LogException l = new LogException();
  }
  public void DivByZero() {
  System.out.println(1/0);
  }
  int arr[];
  public void ArrayBound() {
  System.out.println(arr[0]);
  }
  public LogException(){
  Logger log = Logger.getLogger("");
  try{
  DivByZero();
  }
  catch (Exception e){
  log.log(Level.WARNING, "Can not divide by zero", e.getMessage());
  }
  try{
  ArrayBound();
  }
  catch(Exception ex){
  log.log(Level.INFO, "Array is blank", ex.getMessage());
  }
  }
}
Download this example.

 Logger log = Logger.getLogger("com.library.Books");
   
            // In case an exception is encounted
            try {
                // Test with an exception
                throw new IOException();
            } catch (Throwable e){
                // Log the exception
                log.log(Level.SEVERE, "Uncaught exception", e);