src/net/pterodactylus/util/logging/Logging.java

   1 /*
   2  * jFCPlib-high-level-client - Logging.java -
   3  * Copyright © 2008 David Roden
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 package net.pterodactylus.util.logging;
  21
  22 import java.text.DateFormat;
  23 import java.text.SimpleDateFormat;
  24 import java.util.ArrayList;
  25 import java.util.Collections;
  26 import java.util.Date;
  27 import java.util.List;
  28 import java.util.logging.ConsoleHandler;
  29 import java.util.logging.Formatter;
  30 import java.util.logging.Handler;
  31 import java.util.logging.Level;
  32 import java.util.logging.LogRecord;
  33 import java.util.logging.Logger;
  34
  35 /**
  36  * Sets up logging.
  37  *
  38  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  39  * @version $Id$
  40  */
  41 public class Logging {
  42
  43         /** The log handler. */
  44         private static final LogHandler logHandler = new LogHandler();
  45
  46         static {
  47                 logHandler.setLevel(Level.ALL);
  48         }
  49
  50         /** The root name of the hierarchy. */
  51         private static String hierarchyRootName;
  52
  53         /**
  54          * Adds a listener to the log handler.
  55          *
  56          * @param loggingListener
  57          *            The listener to add
  58          */
  59         public static void addLoggingListener(LoggingListener loggingListener) {
  60                 logHandler.addLoggingListener(loggingListener);
  61         }
  62
  63         /**
  64          * Removes a listener from the log handler.
  65          *
  66          * @param loggingListener
  67          *            The listener to remove
  68          */
  69         public static void removeLoggingListener(LoggingListener loggingListener) {
  70                 logHandler.removeLoggingListener(loggingListener);
  71         }
  72
  73         /**
  74          * Sets up logging and installs the log handler.
  75          *
  76          * @param hierarchyName
  77          *            The name of the hierarchy root logger
  78          */
  79         public static void setup(String hierarchyName) {
  80                 hierarchyRootName = hierarchyName;
  81                 Logger rootLogger = Logger.getLogger(hierarchyName);
  82                 rootLogger.addHandler(logHandler);
  83                 Handler consoleHandler = new ConsoleHandler();
  84                 consoleHandler.setLevel(Level.ALL);
  85                 consoleHandler.setFormatter(new Formatter() {
  86                         private StringBuffer recordBuffer = new StringBuffer();
  87                         private DateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS Z");
  88                         /**
  89                          * {@inheritDoc}
  90                          */
  91                         @Override
  92                         public synchronized String format(LogRecord record) {
  93                                 recordBuffer.setLength(0);
  94                                 recordBuffer.append(dateFormatter.format(new Date(record.getMillis()))).append(' ').append(record.getLevel().getName()).append(' ');
  95                                 recordBuffer.append(record.getSourceClassName()).append('.').append(record.getSourceMethodName()).append(' ');
  96                                 recordBuffer.append(record.getMessage());
  97                                 recordBuffer.append("\r\n");
  98                                 return recordBuffer.toString();
  99                         }
 100                 });
 101                 rootLogger.addHandler(consoleHandler);
 102                 rootLogger.setUseParentHandlers(false);
 103                 rootLogger.setLevel(Level.ALL);
 104         }
 105
 106         /**
 107          * Returns a named logger from the jSite hierarchy.
 108          *
 109          * @param name
 110          *            The name of the logger
 111          * @return The logger
 112          */
 113         public static Logger getLogger(String name) {
 114                 Logger logger = Logger.getLogger(hierarchyRootName + "." + name);
 115                 return logger;
 116         }
 117
 118         /**
 119          * The log handler simply forwards every log message it receives to all
 120          * registered listeners.
 121          *
 122          * @see LoggingListener
 123          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 124          * @version $Id$
 125          */
 126         private static class LogHandler extends Handler {
 127
 128                 /**
 129                  * Package-private constructor.
 130                  */
 131                 LogHandler() {
 132                         /* do nothing. */
 133                 }
 134
 135                 /** The list of the listeners. */
 136                 private final List<LoggingListener> loggingListeners = Collections.synchronizedList(new ArrayList<LoggingListener>());
 137
 138                 //
 139                 // EVENT MANAGEMENT
 140                 //
 141
 142                 /**
 143                  * Adds a listener to the log handler.
 144                  *
 145                  * @param loggingListener
 146                  *            The listener to add
 147                  */
 148                 public void addLoggingListener(LoggingListener loggingListener) {
 149                         loggingListeners.add(loggingListener);
 150                 }
 151
 152                 /**
 153                  * Removes a listener from the log handler.
 154                  *
 155                  * @param loggingListener
 156                  *            The listener to remove
 157                  */
 158                 public void removeLoggingListener(LoggingListener loggingListener) {
 159                         loggingListeners.remove(loggingListener);
 160                 }
 161
 162                 /**
 163                  * Notifies all listeners that a log record was received.
 164                  *
 165                  * @param logRecord
 166                  *            The received log record
 167                  */
 168                 private void fireLogged(LogRecord logRecord) {
 169                         for (LoggingListener loggingListener: loggingListeners) {
 170                                 loggingListener.logged(logRecord);
 171                         }
 172                 }
 173
 174                 //
 175                 // INTERFACE Handler
 176                 //
 177
 178                 /**
 179                  * {@inheritDoc}
 180                  */
 181                 @Override
 182                 public void close() throws SecurityException {
 183                         /* do nothing. */
 184                 }
 185
 186                 /**
 187                  * {@inheritDoc}
 188                  */
 189                 @Override
 190                 public void flush() {
 191                         /* do nothing. */
 192                 }
 193
 194                 /**
 195                  * {@inheritDoc}
 196                  */
 197                 @Override
 198                 public void publish(LogRecord logRecord) {
 199                         fireLogged(logRecord);
 200                 }
 201
 202         }
 203
 204 }