/interpreter/tags/at2dist170907/src/edu/vub/at/util/logging/Logger.java

  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}