Itse debuggeri luokka apureineen

/*
Copyright (c) 2005, Petri Airio
All rights reserved.
*/

package com.freakz.kuha.logger;

import java.util.logging.*;
import java.util.Date;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.CharArrayWriter;
import java.text.SimpleDateFormat;

/**
 * DebugLogger can used to easily print debug messages. Messages are printed to console and/or to file.
 * The behaviour can be changed easily.
 */

public class DebugLogger {

  private static DebugFilter _toConsoleFilter = new DebugFilter();
  private static DebugFilter _toFileFilter = new DebugFilter();

  public static void initLogger(String name) {

    Logger log = Logger.getLogger(name);
    log.setUseParentHandlers(false);

// Setup the file logger

    FileLogHandler file = new FileLogHandler();
    file.setLevel(Level.ALL);

    FileLogFormatter fileFormatter = new FileLogFormatter();
    file.setFormatter(fileFormatter);

    file.setFilter(_toFileFilter);
    log.addHandler(file);

// Setup the console logger

    ConsoleHandler console = new ConsoleHandler();
    console.setLevel(Level.ALL);

    Formatter formatter = new ConsoleLogFormatter();
    console.setFormatter(formatter);

    console.setFilter(_toConsoleFilter);
    log.addHandler(console);

  }

  /**
   * This is the main control method of whole DebugLogger system.
   *
   * @param logToFile    do we write LogRecords to the file ?
   * @param logToConsole do we write LogRecords to console ?
   */
  public static void setLoggers(boolean logToFile, boolean logToConsole) {
    _toFileFilter.setFilter(logToFile);
    _toConsoleFilter.setFilter(logToConsole);
  }

/*------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------*/


  /**
   * This class is used to filter the log messages
   */
  protected static class DebugFilter implements Filter {

    private boolean _doLog;

    /**
     * @param doLog logging on/off
     */
    public void setFilter(boolean doLog) {
      _doLog = doLog;
    }

    /**
     * If the LogRecord has Exception within it, it's always logged. Otherwise it's logged
     * according the status of this filter.
     *
     * @param record the logrecord to be filtered
     * @return the boolean presenting do we want to log this message or not
     */
    public boolean isLoggable(LogRecord record) {
      if (record.getThrown() != null) {
        return true;
      }
      return _doLog;
    }
  } // DebugFilter

/*-------------------------------------------*/

  /**
   * Log handler, that directs log messages to files according to day e.g. LogMessages published on
   * 24.12.2005 will be written to file logs/debug/24-12-2005.log
   */
  protected static class FileLogHandler extends Handler {

    private final static SimpleDateFormat _sdf = new SimpleDateFormat("dd-MM-yyyy");

    private static FileHandler _fileHandler;
    private static String _currentLogFileName;
    private static Filter _filter;


    public void setFilter(Filter filter) {
      _filter = filter;
    }

    /**
     * Sets the FileHandler for this logger.
     */
    private void setHandler() {

      String newLogFileName = _sdf.format(new Date());
      if (_fileHandler != null) {
        if (!newLogFileName.equals(_currentLogFileName)) {
          _fileHandler.close();
          _fileHandler = null;
        }
      }

      if (_fileHandler == null) {

        String logDir = "logs/debug";
        File f = new File(logDir);
        f.mkdirs();

        String fName = logDir + File.separator + newLogFileName + ".log";
        _currentLogFileName = newLogFileName;

        try {
          _fileHandler = new FileHandler(fName, true);
          _fileHandler.setFilter(_filter);
          _fileHandler.setFormatter(new FileLogFormatter());

        } catch (IOException ex) {
          //LOG.log(Level.SEVERE, "Exception", ex);
          ex.printStackTrace();
        }
      }
    }

    /**
     * @param record the LogRecord to be published
     */
    public synchronized void publish(LogRecord record) {
      setHandler();
      _fileHandler.publish(record);
    }

    public void flush() {
      if (_fileHandler != null) {
        _fileHandler.flush();
      }
    }

    public synchronized void close() throws SecurityException {
      if (_fileHandler != null) {
        _fileHandler.close();
        _fileHandler = null;
      }
    }
  } // FileLogHandler

/*-------------------------------------------*/

  /**
   * Log formatter used to log messages to the files
   */
  protected static class FileLogFormatter extends SimpleFormatter {

    private final static SimpleDateFormat _formatter = new SimpleDateFormat("HH:mm");
    private final static Date _date = new Date();

    public synchronized String format(LogRecord logRecord) {

      _date.setTime(logRecord.getMillis());

      StringBuffer sb = new StringBuffer();

      sb.append("[");
      sb.append(_formatter.format(_date));
      sb.append("] ");
      if (!logRecord.getLevel().getLocalizedName().equals("INFO")) {
        sb.append("<<");
        sb.append(logRecord.getLevel().getLocalizedName());
        sb.append(">> ");
      }
      sb.append(logRecord.getMessage());

      if (logRecord.getThrown() != null) {
        sb.append(" STACK DUMP\n");
        CharArrayWriter caw = new CharArrayWriter();
        PrintWriter pw = new PrintWriter(caw);

        logRecord.getThrown().printStackTrace(pw);

        sb.append(caw.toString());
        pw.close();
        sb.append("STACK DUMP END\n");
      }
      sb.append("\n");
      return sb.toString();
    }

  } // FileLogFormatter

/*-------------------------------------------*/

  /**
   * Log formatter used to log messages to the console
   */
  protected static class ConsoleLogFormatter extends SimpleFormatter {

    private final static Date _date = new Date();
    private final static SimpleDateFormat _formatter = new SimpleDateFormat("HH:mm:ss");

    public synchronized String format(LogRecord logRecord) {

      _date.setTime(logRecord.getMillis());

      StringBuffer sb = new StringBuffer();
      sb.append(_formatter.format(_date));
      if (!logRecord.getLevel().getLocalizedName().equals("INFO")) {
        sb.append(" <<");
        sb.append(logRecord.getLevel().getLocalizedName());
        sb.append(">>");
      }
      sb.append(" ");
      sb.append(logRecord.getSourceClassName());
      sb.append(".");
      sb.append(logRecord.getSourceMethodName());
      sb.append("(): '");
      sb.append(logRecord.getMessage());

      if (logRecord.getThrown() != null) {
        sb.append("' STACK DUMP\n");
        CharArrayWriter caw = new CharArrayWriter();
        PrintWriter pw = new PrintWriter(caw);

        logRecord.getThrown().printStackTrace(pw);

        sb.append(caw.toString());
        pw.close();

        sb.append("\n");

      } else {
        sb.append("'\n");
      }
      return sb.toString();
    }

  } // ConsoleLogFormatter

}




Testeri ohjelma

package com.freakz.kuha.logger;

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

/**
 * Example how to use the DebugLogger
 */
public class LogTester {

  private final static String MY_LOGGER = "example.logger";

  public static void main(String args[]) {

    // init MY_LOGGER to use our handlers & filters
    DebugLogger.initLogger(MY_LOGGER);
    Logger log = Logger.getLogger(MY_LOGGER);

    DebugLogger.setLoggers(true, true);

    log.info("Testing: this should go to console and file!");

    DebugLogger.setLoggers(false, true);

    log.warning("Testing: this should go to the console only!");

    DebugLogger.setLoggers(true, false);

    log.severe("Testing: this should go to the file only!");

    DebugLogger.setLoggers(false, false);

    log.severe("If you see this, there's something some serious BUG around!");

    DebugLogger.setLoggers(true, true);

    String[] foo = null;
    try {
      String bar = foo[0];
    } catch (Exception ex) {
      log.log(Level.SEVERE, "We got exception!!", ex);
    }

  }

}