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  */
  40 public class Logging {
  41
  42         /** The log handler. */
  43         private static final LogHandler logHandler = new LogHandler();
  44
  45         static {
  46                 logHandler.setLevel(Level.ALL);
  47         }
  48
  49         /** The root name of the hierarchy. */
  50         private static String hierarchyRootName;
  51
  52         /**
  53          * Adds a listener to the log handler.
  54          *
  55          * @param loggingListener
  56          *            The listener to add
  57          */
  58         public static void addLoggingListener(LoggingListener loggingListener) {
  59                 logHandler.addLoggingListener(loggingListener);
  60         }
  61
  62         /**
  63          * Removes a listener from the log handler.
  64          *
  65          * @param loggingListener
  66          *            The listener to remove
  67          */
  68         public static void removeLoggingListener(LoggingListener loggingListener) {
  69                 logHandler.removeLoggingListener(loggingListener);
  70         }
  71
  72         /**
  73          * Sets up logging and installs the log handler.
  74          *
  75          * @param hierarchyName
  76          *            The name of the hierarchy root logger
  77          */
  78         public static void setup(String hierarchyName) {
  79                 hierarchyRootName = hierarchyName;
  80                 Logger rootLogger = Logger.getLogger(hierarchyName);
  81                 rootLogger.addHandler(logHandler);
  82                 Handler consoleHandler = new ConsoleHandler();
  83                 consoleHandler.setLevel(Level.ALL);
  84                 consoleHandler.setFormatter(new Formatter() {
  85
  86                         private StringBuffer recordBuffer = new StringBuffer();
  87                         private DateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS Z");
  88
  89                         /**
  90                          * {@inheritDoc}
  91                          */
  92                         @Override
  93                         public synchronized String format(LogRecord record) {
  94                                 recordBuffer.setLength(0);
  95                                 String linePrefix = dateFormatter.format(new Date(record.getMillis())) + " [" + record.getLevel() + "] [" + Thread.currentThread().getName() + "] [" + record.getSourceClassName() + "." + record.getSourceMethodName() + "] ";
  96                                 recordBuffer.append(linePrefix).append(record.getMessage()).append('\n');
  97                                 if (record.getThrown() != null) {
  98                                         Throwable throwable = record.getThrown();
  99                                         boolean causedBy = false;
 100                                         while (throwable != null) {
 101                                                 recordBuffer.append(linePrefix);
 102                                                 if (causedBy) {
 103                                                         recordBuffer.append("caused by: ");
 104                                                 }
 105                                                 recordBuffer.append(throwable.getClass().getName());
 106                                                 if (throwable.getMessage() != null) {
 107                                                         recordBuffer.append(": ").append(throwable.getMessage());
 108                                                 }
 109                                                 recordBuffer.append("\n");
 110                                                 StackTraceElement[] stackTraceElements = throwable.getStackTrace();
 111                                                 for (StackTraceElement stackTraceElement: stackTraceElements) {
 112                                                         recordBuffer.append(linePrefix).append("  at ").append(stackTraceElement.getClassName()).append('.').append(stackTraceElement.getMethodName()).append("(").append(stackTraceElement.getFileName()).append(':').append(stackTraceElement.getLineNumber()).append(')').append("\n");
 113                                                 }
 114                                                 throwable = throwable.getCause();
 115                                                 causedBy = true;
 116                                         }
 117                                 }
 118                                 return recordBuffer.toString();
 119                         }
 120                 });
 121                 rootLogger.addHandler(consoleHandler);
 122                 rootLogger.setUseParentHandlers(false);
 123                 rootLogger.setLevel(Level.ALL);
 124         }
 125
 126         /**
 127          * Returns a named logger from the jSite hierarchy.
 128          *
 129          * @param name
 130          *            The name of the logger
 131          * @return The logger
 132          */
 133         public static Logger getLogger(String name) {
 134                 Logger logger = Logger.getLogger(hierarchyRootName + "." + name);
 135                 return logger;
 136         }
 137
 138         /**
 139          * The log handler simply forwards every log message it receives to all
 140          * registered listeners.
 141          *
 142          * @see LoggingListener
 143          * @author David ‘Bombe’ Roden &lt;bombe@freenetproject.org&gt;
 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 }