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.util.ArrayList;
  23 import java.util.Collections;
  24 import java.util.Date;
  25 import java.util.List;
  26 import java.util.logging.ConsoleHandler;
  27 import java.util.logging.Formatter;
  28 import java.util.logging.Handler;
  29 import java.util.logging.Level;
  30 import java.util.logging.LogRecord;
  31 import java.util.logging.Logger;
  32
  33 /**
  34  * Sets up logging.
  35  *
  36  * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
  37  * @version $Id$
  38  */
  39 public class Logging {
  40
  41         /** The log handler. */
  42         private static final LogHandler logHandler = new LogHandler();
  43
  44         static {
  45                 logHandler.setLevel(Level.ALL);
  46         }
  47
  48         /** The root name of the hierarchy. */
  49         private static String hierarchyRootName;
  50
  51         /**
  52          * Adds a listener to the log handler.
  53          *
  54          * @param loggingListener
  55          *            The listener to add
  56          */
  57         public static void addLoggingListener(LoggingListener loggingListener) {
  58                 logHandler.addLoggingListener(loggingListener);
  59         }
  60
  61         /**
  62          * Removes a listener from the log handler.
  63          *
  64          * @param loggingListener
  65          *            The listener to remove
  66          */
  67         public static void removeLoggingListener(LoggingListener loggingListener) {
  68                 logHandler.removeLoggingListener(loggingListener);
  69         }
  70
  71         /**
  72          * Sets up logging and installs the log handler.
  73          *
  74          * @param hierarchyName
  75          *            The name of the hierarchy root logger
  76          */
  77         public static void setup(String hierarchyName) {
  78                 hierarchyRootName = hierarchyName;
  79                 Logger rootLogger = Logger.getLogger(hierarchyName);
  80                 rootLogger.addHandler(logHandler);
  81                 Handler consoleHandler = new ConsoleHandler();
  82                 consoleHandler.setLevel(Level.ALL);
  83                 consoleHandler.setFormatter(new Formatter() {
  84                         private StringBuffer recordBuffer = new StringBuffer();
  85                         /**
  86                          * {@inheritDoc}
  87                          */
  88                         @Override
  89                         public synchronized String format(LogRecord record) {
  90                                 recordBuffer.setLength(0);
  91                                 recordBuffer.append(new Date(record.getMillis())).append(' ').append(record.getLevel().getName()).append(' ');
  92                                 recordBuffer.append(record.getSourceClassName()).append('.').append(record.getSourceMethodName()).append(' ');
  93                                 recordBuffer.append(record.getMessage());
  94                                 recordBuffer.append("\r\n");
  95                                 return recordBuffer.toString();
  96                         }
  97                 });
  98                 rootLogger.addHandler(consoleHandler);
  99                 rootLogger.setUseParentHandlers(false);
 100                 rootLogger.setLevel(Level.ALL);
 101         }
 102
 103         /**
 104          * Returns a named logger from the jSite hierarchy.
 105          *
 106          * @param name
 107          *            The name of the logger
 108          * @return The logger
 109          */
 110         public static Logger getLogger(String name) {
 111                 Logger logger = Logger.getLogger(hierarchyRootName + "." + name);
 112                 return logger;
 113         }
 114
 115         /**
 116          * The log handler simply forwards every log message it receives to all
 117          * registered listeners.
 118          *
 119          * @see LoggingListener
 120          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 121          * @version $Id$
 122          */
 123         private static class LogHandler extends Handler {
 124
 125                 /**
 126                  * Package-private constructor.
 127                  */
 128                 LogHandler() {
 129                         /* do nothing. */
 130                 }
 131
 132                 /** The list of the listeners. */
 133                 private final List<LoggingListener> loggingListeners = Collections.synchronizedList(new ArrayList<LoggingListener>());
 134
 135                 //
 136                 // EVENT MANAGEMENT
 137                 //
 138
 139                 /**
 140                  * Adds a listener to the log handler.
 141                  *
 142                  * @param loggingListener
 143                  *            The listener to add
 144                  */
 145                 public void addLoggingListener(LoggingListener loggingListener) {
 146                         loggingListeners.add(loggingListener);
 147                 }
 148
 149                 /**
 150                  * Removes a listener from the log handler.
 151                  *
 152                  * @param loggingListener
 153                  *            The listener to remove
 154                  */
 155                 public void removeLoggingListener(LoggingListener loggingListener) {
 156                         loggingListeners.remove(loggingListener);
 157                 }
 158
 159                 /**
 160                  * Notifies all listeners that a log record was received.
 161                  *
 162                  * @param logRecord
 163                  *            The received log record
 164                  */
 165                 private void fireLogged(LogRecord logRecord) {
 166                         for (LoggingListener loggingListener: loggingListeners) {
 167                                 loggingListener.logged(logRecord);
 168                         }
 169                 }
 170
 171                 //
 172                 // INTERFACE Handler
 173                 //
 174
 175                 /**
 176                  * {@inheritDoc}
 177                  */
 178                 @Override
 179                 public void close() throws SecurityException {
 180                         /* do nothing. */
 181                 }
 182
 183                 /**
 184                  * {@inheritDoc}
 185                  */
 186                 @Override
 187                 public void flush() {
 188                         /* do nothing. */
 189                 }
 190
 191                 /**
 192                  * {@inheritDoc}
 193                  */
 194                 @Override
 195                 public void publish(LogRecord logRecord) {
 196                         fireLogged(logRecord);
 197                 }
 198
 199         }
 200
 201 }