/interpreter/tags/at2dist170907/src/edu/vub/at/util/logging/Logger.java
Java | 220 lines | 84 code | 22 blank | 114 comment | 15 complexity | 6482a8213e2a398e2671ab496ed5f5e2 MD5 | raw file
1/** 2 * AmbientTalk/2 Project 3 * Logger.java created on 5-apr-2007 at 10:50:03 4 * (c) Programming Technology Lab, 2006 - 2007 5 * Authors: Tom Van Cutsem & Stijn Mostinckx 6 * 7 * Permission is hereby granted, free of charge, to any person 8 * obtaining a copy of this software and associated documentation 9 * files (the "Software"), to deal in the Software without 10 * restriction, including without limitation the rights to use, 11 * copy, modify, merge, publish, distribute, sublicense, and/or 12 * sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following 14 * conditions: 15 * 16 * The above copyright notice and this permission notice shall be 17 * included in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 21 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 22 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 23 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 24 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 26 * OTHER DEALINGS IN THE SOFTWARE. 27 */ 28package edu.vub.at.util.logging; 29 30import java.util.Date; 31import java.util.HashMap; 32 33/** 34 * A logger object modelled after the interface of the Log4J framework. 35 * 36 * @author tvcutsem 37 */ 38public class Logger { 39 40 /** 41 * A map for pooling all of the loggers. 42 */ 43 private static final HashMap _LOGS = new HashMap(); 44 45 private final String name_; 46 47 /** 48 * Logs with a priority less than this will not get logged. 49 */ 50 private int leastPriority_; 51 52 private String textPriority_; 53 54 /** 55 * Access to the map should actually be synchronized, but this 56 * adds overhead to accessing the loggers. 57 * 58 * Without synchronization, the possibility exists that same logger 59 * is added twice. On the other hand, as loggers are stateless, this is not 60 * really a problem (the new one will replace the old one without any harm) 61 */ 62 public static Logger getInstance(String name) { 63 Logger logger = (Logger) _LOGS.get(name); 64 if (logger == null) { 65 logger = new Logger(name); 66 _LOGS.put(name, logger); 67 } 68 return logger; 69 } 70 71 /** When loggers are initialised with this setting, all messages (including debug info) are being logged. */ 72 public static final int _DEBUG_LEVEL_ = 1; 73 /** When loggers are initialised with this setting, all messages except for debug info are being logged. */ 74 public static final int _WARN_LEVEL_ = 2; 75 /** When loggers are initialised with this setting, errors as well as info (e.g. regarding connection status) is being logged. */ 76 public static final int _INFO_LEVEL_ = 3; 77 /** When loggers are initialised with this setting, all errors (including tolerable ones) are reported. */ 78 public static final int _ERROR_LEVEL_ = 4; 79 /** When loggers are initialised with this setting, only fatal errors are reported. */ 80 public static final int _FATAL_LEVEL_ = 5; 81 82 private Logger(String nam) { 83 name_ = nam; 84 leastPriority_ = _DEBUG_LEVEL_; 85 textPriority_ = "DEBUG"; 86 } 87 88 /** 89 * Set the priority of the logger. 90 * @param priority - one of 'DEBUG', 'WARN', 'INFO', 'ERROR' or 'FATAL' 91 * @throws IllegalArgumentException if the given argument is not one of the above logging levels. 92 */ 93 public void setPriority(String priority) throws IllegalArgumentException { 94 leastPriority_ = textToLevel(priority); 95 textPriority_ = priority; 96 } 97 98 /** 99 * Reports debugging information to be logged. Such messages are ignored when the logger has 100 * its priority set to be higher than or equal to WARNING. 101 * @param msg the message to be logged. 102 */ 103 public void debug(String msg) { 104 log(_DEBUG_LEVEL_, msg, null); 105 } 106 107 /** 108 * Reports debugging information to be logged. Such messages are ignored when the logger has 109 * its priority set to be higher than or equal to WARNING. 110 * @param msg the message to be logged. 111 * @param exc the underlying exception that triggered the log request. 112 */ 113 public void debug(String msg, Throwable exc) { 114 log(_DEBUG_LEVEL_, msg, exc); 115 } 116 117 /** 118 * Reports a warning (i.e a suspected inconsistency in the interpreter) to be logged. Such 119 * messages are ignored when the logger has its priority set to be higher than or equal to 120 * INFO. 121 * @param msg the message to be logged. 122 */ 123 public void warn(String msg) { 124 log(_WARN_LEVEL_, msg, null); 125 } 126 127 /** 128 * Reports a warning (i.e a suspected inconsistency in the interpreter) to be logged. Such 129 * messages are ignored when the logger has its priority set to be higher than or equal to 130 * INFO. 131 * @param msg the message to be logged. 132 * @param exc the underlying exception that triggered the log request. 133 */ 134 public void warn(String msg, Throwable exc) { 135 log(_WARN_LEVEL_, msg, exc); 136 } 137 138 /** 139 * Reports useful information on the interpreter's functioning (e.g. changes in connection 140 * state) to be logged. Such messages are ignored when the logger has its priority set to be 141 * higher than or equal to ERROR. 142 * @param msg the message to be logged. 143 */ 144 public void info(String msg) { 145 log(_INFO_LEVEL_, msg, null); 146 } 147 148 /** 149 * Reports useful information on the interpreter's functioning (e.g. changes in connection 150 * state) to be logged. Such messages are ignored when the logger has its priority set to be 151 * higher than or equal to ERROR. 152 * @param msg the message to be logged. 153 * @param exc the underlying exception that triggered the log request. 154 */ 155 public void info(String msg, Throwable exc) { 156 log(_INFO_LEVEL_, msg, exc); 157 } 158 159 /** 160 * Reports a tolerable error which occurred in the interpreter. Such messages are logged unless 161 * the logger set to FATAL. 162 * @param msg the message to be logged. 163 */ 164 public void error(String msg) { 165 log(_ERROR_LEVEL_, msg, null); 166 } 167 168 /** 169 * Reports a tolerable error which occurred in the interpreter. Such messages are logged unless 170 * the logger set to FATAL. 171 * @param msg the message to be logged. 172 * @param exc the underlying exception that triggered the log request. 173 */ 174 public void error(String msg, Throwable exc) { 175 log(_ERROR_LEVEL_, msg, exc); 176 } 177 178 /** 179 * Reports a fatal error in the interpreter. Such messages are always logged. 180 * @param msg the message to be logged. 181 */ 182 public void fatal(String msg) { 183 log(_FATAL_LEVEL_, msg, null); 184 } 185 186 /** 187 * Reports a fatal error in the interpreter. Such messages are always logged. 188 * @param msg the message to be logged. 189 * @param exc the underlying exception that triggered the log request. 190 */ 191 public void fatal(String msg, Throwable exc) { 192 log(_FATAL_LEVEL_, msg, exc); 193 } 194 195 private void log(int priority, String msg, Throwable exc) { 196 if (priority >= leastPriority_) { 197 // format: date priority logname - message 198 System.err.println(new Date().toString() + " " + textPriority_ + " "+ name_ + " - " + msg); 199 if (exc != null) { 200 exc.printStackTrace(System.err); 201 } 202 } 203 } 204 205 private int textToLevel(String priority) throws IllegalArgumentException { 206 if (priority.equalsIgnoreCase("DEBUG")) { 207 return _DEBUG_LEVEL_; 208 } else if (priority.equalsIgnoreCase("WARN")) { 209 return _WARN_LEVEL_; 210 } else if (priority.equalsIgnoreCase("INFO")) { 211 return _INFO_LEVEL_; 212 } else if (priority.equalsIgnoreCase("ERROR")) { 213 return _ERROR_LEVEL_; 214 } else if (priority.equalsIgnoreCase("FATAL")) { 215 return _FATAL_LEVEL_; 216 } else { 217 throw new IllegalArgumentException("Illegal priority value: " + priority); 218 } 219 } 220}