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

http://ambienttalk.googlecode.com/ · Java · 216 lines · 81 code · 21 blank · 114 comment · 15 complexity · bde524f02e5cae5d990a7471036239c1 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. */
  28. package edu.vub.at.util.logging;
  29. import java.util.Date;
  30. import java.util.HashMap;
  31. /**
  32. * A logger object modelled after the interface of the Log4J framework.
  33. *
  34. * @author tvcutsem
  35. */
  36. public class Logger {
  37. /**
  38. * A map for pooling all of the loggers.
  39. */
  40. private static final HashMap _LOGS = new HashMap();
  41. private final String name_;
  42. /**
  43. * Logs with a priority less than this will not get logged.
  44. */
  45. private int leastPriority_;
  46. /**
  47. * Access to the map should actually be synchronized, but this
  48. * adds overhead to accessing the loggers.
  49. *
  50. * Without synchronization, the possibility exists that same logger
  51. * is added twice. On the other hand, as loggers are stateless, this is not
  52. * really a problem (the new one will replace the old one without any harm)
  53. */
  54. public static Logger getInstance(String name) {
  55. Logger logger = (Logger) _LOGS.get(name);
  56. if (logger == null) {
  57. logger = new Logger(name);
  58. _LOGS.put(name, logger);
  59. }
  60. return logger;
  61. }
  62. /** When loggers are initialised with this setting, all messages (including debug info) are being logged. */
  63. public static final int _DEBUG_LEVEL_ = 1;
  64. /** When loggers are initialised with this setting, all messages except for debug info are being logged. */
  65. public static final int _WARN_LEVEL_ = 2;
  66. /** When loggers are initialised with this setting, errors as well as info (e.g. regarding connection status) is being logged. */
  67. public static final int _INFO_LEVEL_ = 3;
  68. /** When loggers are initialised with this setting, all errors (including tolerable ones) are reported. */
  69. public static final int _ERROR_LEVEL_ = 4;
  70. /** When loggers are initialised with this setting, only fatal errors are reported. */
  71. public static final int _FATAL_LEVEL_ = 5;
  72. private Logger(String nam) {
  73. name_ = nam;
  74. leastPriority_ = _DEBUG_LEVEL_;
  75. }
  76. /**
  77. * Set the priority of the logger.
  78. * @param priority - one of 'DEBUG', 'WARN', 'INFO', 'ERROR' or 'FATAL'
  79. * @throws IllegalArgumentException if the given argument is not one of the above logging levels.
  80. */
  81. public void setPriority(String priority) throws IllegalArgumentException {
  82. leastPriority_ = textToLevel(priority);
  83. }
  84. /**
  85. * Reports debugging information to be logged. Such messages are ignored when the logger has
  86. * its priority set to be higher than or equal to WARNING.
  87. * @param msg the message to be logged.
  88. */
  89. public void debug(String msg) {
  90. log(_DEBUG_LEVEL_, "DEBUG", msg, null);
  91. }
  92. /**
  93. * Reports debugging information to be logged. Such messages are ignored when the logger has
  94. * its priority set to be higher than or equal to WARNING.
  95. * @param msg the message to be logged.
  96. * @param exc the underlying exception that triggered the log request.
  97. */
  98. public void debug(String msg, Throwable exc) {
  99. log(_DEBUG_LEVEL_, "DEBUG", msg, exc);
  100. }
  101. /**
  102. * Reports a warning (i.e a suspected inconsistency in the interpreter) to be logged. Such
  103. * messages are ignored when the logger has its priority set to be higher than or equal to
  104. * INFO.
  105. * @param msg the message to be logged.
  106. */
  107. public void warn(String msg) {
  108. log(_WARN_LEVEL_, "WARN", msg, null);
  109. }
  110. /**
  111. * Reports a warning (i.e a suspected inconsistency in the interpreter) to be logged. Such
  112. * messages are ignored when the logger has its priority set to be higher than or equal to
  113. * INFO.
  114. * @param msg the message to be logged.
  115. * @param exc the underlying exception that triggered the log request.
  116. */
  117. public void warn(String msg, Throwable exc) {
  118. log(_WARN_LEVEL_, "WARN", msg, exc);
  119. }
  120. /**
  121. * Reports useful information on the interpreter's functioning (e.g. changes in connection
  122. * state) to be logged. Such messages are ignored when the logger has its priority set to be
  123. * higher than or equal to ERROR.
  124. * @param msg the message to be logged.
  125. */
  126. public void info(String msg) {
  127. log(_INFO_LEVEL_, "INFO", msg, null);
  128. }
  129. /**
  130. * Reports useful information on the interpreter's functioning (e.g. changes in connection
  131. * state) to be logged. Such messages are ignored when the logger has its priority set to be
  132. * higher than or equal to ERROR.
  133. * @param msg the message to be logged.
  134. * @param exc the underlying exception that triggered the log request.
  135. */
  136. public void info(String msg, Throwable exc) {
  137. log(_INFO_LEVEL_, "INFO", msg, exc);
  138. }
  139. /**
  140. * Reports a tolerable error which occurred in the interpreter. Such messages are logged unless
  141. * the logger set to FATAL.
  142. * @param msg the message to be logged.
  143. */
  144. public void error(String msg) {
  145. log(_ERROR_LEVEL_, "ERROR", msg, null);
  146. }
  147. /**
  148. * Reports a tolerable error which occurred in the interpreter. Such messages are logged unless
  149. * the logger set to FATAL.
  150. * @param msg the message to be logged.
  151. * @param exc the underlying exception that triggered the log request.
  152. */
  153. public void error(String msg, Throwable exc) {
  154. log(_ERROR_LEVEL_, "ERROR", msg, exc);
  155. }
  156. /**
  157. * Reports a fatal error in the interpreter. Such messages are always logged.
  158. * @param msg the message to be logged.
  159. */
  160. public void fatal(String msg) {
  161. log(_FATAL_LEVEL_, "FATAL", msg, null);
  162. }
  163. /**
  164. * Reports a fatal error in the interpreter. Such messages are always logged.
  165. * @param msg the message to be logged.
  166. * @param exc the underlying exception that triggered the log request.
  167. */
  168. public void fatal(String msg, Throwable exc) {
  169. log(_FATAL_LEVEL_, "FATAL", msg, exc);
  170. }
  171. private void log(int priority, String textPriority, String msg, Throwable exc) {
  172. if (priority >= leastPriority_) {
  173. // format: date priority logname - message
  174. System.err.println(new Date().toString() + " " + textPriority + " "+ name_ + " - " + msg);
  175. if (exc != null) {
  176. exc.printStackTrace(System.err);
  177. }
  178. }
  179. }
  180. private int textToLevel(String priority) throws IllegalArgumentException {
  181. if (priority.equalsIgnoreCase("DEBUG")) {
  182. return _DEBUG_LEVEL_;
  183. } else if (priority.equalsIgnoreCase("WARN")) {
  184. return _WARN_LEVEL_;
  185. } else if (priority.equalsIgnoreCase("INFO")) {
  186. return _INFO_LEVEL_;
  187. } else if (priority.equalsIgnoreCase("ERROR")) {
  188. return _ERROR_LEVEL_;
  189. } else if (priority.equalsIgnoreCase("FATAL")) {
  190. return _FATAL_LEVEL_;
  191. } else {
  192. throw new IllegalArgumentException("Illegal priority value: " + priority);
  193. }
  194. }
  195. }