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                                 String linePrefix = dateFormatter.format(new Date(record.getMillis())) + " [" + record.getLevel() + "] [" + Thread.currentThread().getName() + "] [" + record.getSourceClassName() + "." + record.getSourceMethodName() + "] ";
  95                                 recordBuffer.append(linePrefix).append(record.getMessage()).append('\n');
  96                                 if (record.getThrown() != null) {
  97                                         Throwable throwable = record.getThrown();
  98                                         boolean causedBy = false;
  99                                         while (throwable != null) {
 100                                                 recordBuffer.append(linePrefix);
 101                                                 if (causedBy) {
 102                                                         recordBuffer.append("caused by: ");
 103                                                 }
 104                                                 recordBuffer.append(throwable.getClass().getName());
 105                                                 if (throwable.getMessage() != null) {
 106                                                         recordBuffer.append(": ").append(throwable.getMessage());
 107                                                 }
 108                                                 recordBuffer.append("\n");
 109                                                 StackTraceElement[] stackTraceElements = throwable.getStackTrace();
 110                                                 for (StackTraceElement stackTraceElement: stackTraceElements) {
 111                                                         recordBuffer.append(linePrefix).append("  at ").append(stackTraceElement.getClassName()).append('.').append(stackTraceElement.getMethodName()).append("(").append(stackTraceElement.getFileName()).append(':').append(stackTraceElement.getLineNumber()).append(')').append("\n");
 112                                                 }
 113                                                 throwable = throwable.getCause();
 114                                                 causedBy = true;
 115                                         }
 116                                 }
 117                                 return recordBuffer.toString();
 118                         }
 119                 });
 120                 rootLogger.addHandler(consoleHandler);
 121                 rootLogger.setUseParentHandlers(false);
 122                 rootLogger.setLevel(Level.ALL);
 123         }
 124
 125         /**
 126          * Returns a named logger from the jSite hierarchy.
 127          *
 128          * @param name
 129          *            The name of the logger
 130          * @return The logger
 131          */
 132         public static Logger getLogger(String name) {
 133                 Logger logger = Logger.getLogger(hierarchyRootName + "." + name);
 134                 return logger;
 135         }
 136
 137         /**
 138          * The log handler simply forwards every log message it receives to all
 139          * registered listeners.
 140          *
 141          * @see LoggingListener
 142          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 143          * @version $Id$
 144          */
 145         private static class LogHandler extends Handler {
 146
 147                 /**
 148                  * Package-private constructor.
 149                  */
 150                 LogHandler() {
 151                         /* do nothing. */
 152                 }
 153
 154                 /** The list of the listeners. */
 155                 private final List<LoggingListener> loggingListeners = Collections.synchronizedList(new ArrayList<LoggingListener>());
 156
 157                 //
 158                 // EVENT MANAGEMENT
 159                 //
 160
 161                 /**
 162                  * Adds a listener to the log handler.
 163                  *
 164                  * @param loggingListener
 165                  *            The listener to add
 166                  */
 167                 public void addLoggingListener(LoggingListener loggingListener) {
 168                         loggingListeners.add(loggingListener);
 169                 }
 170
 171                 /**
 172                  * Removes a listener from the log handler.
 173                  *
 174                  * @param loggingListener
 175                  *            The listener to remove
 176                  */
 177                 public void removeLoggingListener(LoggingListener loggingListener) {
 178                         loggingListeners.remove(loggingListener);
 179                 }
 180
 181                 /**
 182                  * Notifies all listeners that a log record was received.
 183                  *
 184                  * @param logRecord
 185                  *            The received log record
 186                  */
 187                 private void fireLogged(LogRecord logRecord) {
 188                         for (LoggingListener loggingListener: loggingListeners) {
 189                                 loggingListener.logged(logRecord);
 190                         }
 191                 }
 192
 193                 //
 194                 // INTERFACE Handler
 195                 //
 196
 197                 /**
 198                  * {@inheritDoc}
 199                  */
 200                 @Override
 201                 public void close() throws SecurityException {
 202                         /* do nothing. */
 203                 }
 204
 205                 /**
 206                  * {@inheritDoc}
 207                  */
 208                 @Override
 209                 public void flush() {
 210                         /* do nothing. */
 211                 }
 212
 213                 /**
 214                  * {@inheritDoc}
 215                  */
 216                 @Override
 217                 public void publish(LogRecord logRecord) {
 218                         fireLogged(logRecord);
 219                 }
 220
 221         }
 222
 223 }