src/net/argius/stew/Logger.java

   1 package net.argius.stew;
   2
   3 import java.util.logging.*;
   4
   5 /**
   6  * The Logger which has Apache Logging style interface.
   7  *
   8  * <p>The log levels map to core API's log level as below.</p><ul>
   9  * <li> fatal: Level.SEVERE (and "fatal" message)
  10  * <li> error: Level.SEVERE
  11  * <li> warn: Level.WARNING
  12  * <li> info: Level.INFO
  13  * <li> debug: Level.FINE
  14  * <li> trace: Level.FINER
  15  * </ul>
  16  * Level.CONFIG is not used.
  17  */
  18 public final class Logger {
  19
  20     private final java.util.logging.Logger log;
  21
  22     private String enteredMethodName;
  23
  24     Logger(String name) {
  25         this.log = java.util.logging.Logger.getLogger(name);
  26         removeRootLoggerHandlers();
  27     }
  28
  29     Logger(Class<?> c) {
  30         this(c.getName());
  31     }
  32
  33     static void removeRootLoggerHandlers() {
  34         java.util.logging.Logger rootLogger = LogManager.getLogManager().getLogger("");
  35         for (Handler handler : rootLogger.getHandlers()) {
  36             rootLogger.removeHandler(handler);
  37         }
  38     }
  39
  40     public static Logger getLogger(Object o) {
  41         final String name;
  42         if (o instanceof Class) {
  43             Class<?> c = (Class<?>)o;
  44             name = c.getName();
  45         } else if (o instanceof String) {
  46             name = (String)o;
  47         } else {
  48             name = String.valueOf(o);
  49         }
  50         return new Logger(name);
  51     }
  52
  53     /**
  54      * The INFO level maps to logging.Level.INFO .
  55      * @return info level is enabled
  56      */
  57     public boolean isInfoEnabled() {
  58         return log.isLoggable(Level.INFO);
  59     }
  60
  61     /**
  62      * The DEBUG level maps to logging.Level.FINE .
  63      * @return debug level is enabled
  64      */
  65     public boolean isDebugEnabled() {
  66         return log.isLoggable(Level.FINE);
  67     }
  68
  69     /**
  70      * The TRACE level maps to logging.Level.FINER .
  71      * @return debug level is enabled
  72      */
  73     public boolean isTraceEnabled() {
  74         return log.isLoggable(Level.FINER);
  75     }
  76
  77     public String getEnteredMethodName() {
  78         return (enteredMethodName == null) ? "" : enteredMethodName;
  79     }
  80
  81     public void setEnteredMethodName(String methodName) {
  82         enteredMethodName = (methodName == null) ? "" : methodName;
  83     }
  84
  85     public void log(Level level, Throwable th, String format, Object... args) {
  86         if (log.isLoggable(level)) {
  87             final String cn = log.getName();
  88             final String mn = (enteredMethodName == null) ? "(unknown method)" : enteredMethodName;
  89             final String msg = (args.length == 0) ? format : String.format(format, args);
  90             if (th == null) {
  91                 log.logp(level, cn, mn, msg);
  92             } else {
  93                 log.logp(level, cn, mn, msg, th);
  94             }
  95         }
  96     }
  97
  98     public void fatal(Throwable th) {
  99         if (log.isLoggable(Level.SEVERE)) {
 100             log(Level.SEVERE, th, "*FATAL*");
 101         }
 102     }
 103
 104     public void fatal(Throwable th, String format, Object... args) {
 105         if (log.isLoggable(Level.SEVERE)) {
 106             log(Level.SEVERE, th, "*FATAL* " + String.format(format, args));
 107         }
 108     }
 109
 110     public void error(Throwable th) {
 111         if (log.isLoggable(Level.SEVERE)) {
 112             log(Level.SEVERE, th, "");
 113         }
 114     }
 115
 116     public void error(Throwable th, Object o) {
 117         if (log.isLoggable(Level.SEVERE)) {
 118             log(Level.SEVERE, th, String.valueOf(o));
 119         }
 120     }
 121
 122     public void error(Throwable th, String format, Object arg) {
 123         if (log.isLoggable(Level.SEVERE)) {
 124             log(Level.SEVERE, th, format, arg);
 125         }
 126     }
 127
 128     public void warn(Throwable th) {
 129         if (log.isLoggable(Level.WARNING)) {
 130             log(Level.WARNING, th, "");
 131         }
 132     }
 133
 134     public void warn(Throwable th, Object o) {
 135         if (log.isLoggable(Level.WARNING)) {
 136             log(Level.WARNING, th, String.valueOf(o));
 137         }
 138     }
 139
 140     public void warn(String format, Object... args) {
 141         if (log.isLoggable(Level.WARNING)) {
 142             log(Level.WARNING, null, format, args);
 143         }
 144     }
 145
 146     public void info(Object o) {
 147         if (isInfoEnabled()) {
 148             log(Level.INFO, null, String.valueOf(o));
 149         }
 150     }
 151
 152     public void info(String format, Object arg) {
 153         if (isInfoEnabled()) {
 154             log(Level.INFO, null, format, arg);
 155         }
 156     }
 157
 158     public void info(String format, Object arg1, Object arg2) {
 159         if (isInfoEnabled()) {
 160             log(Level.INFO, null, format, arg1, arg2);
 161         }
 162     }
 163
 164     public void info(String format, Object... args) {
 165         if (isInfoEnabled()) {
 166             log(Level.INFO, null, format, args);
 167         }
 168     }
 169
 170     public void debug(Object o) {
 171         if (isDebugEnabled()) {
 172             log(Level.FINE, null, String.valueOf(o));
 173         }
 174     }
 175
 176     public void debug(String format, Object arg) {
 177         if (isDebugEnabled()) {
 178             log(Level.FINE, null, format, arg);
 179         }
 180     }
 181
 182     public void debug(String format, Object arg1, Object arg2) {
 183         if (isDebugEnabled()) {
 184             log(Level.FINE, null, format, arg1, arg2);
 185         }
 186     }
 187
 188     public void debug(String format, Object... args) {
 189         if (isDebugEnabled()) {
 190             log(Level.FINE, null, format, args);
 191         }
 192     }
 193
 194     public void trace(Throwable th) {
 195         if (isTraceEnabled()) {
 196             log(Level.FINER, th, "");
 197         }
 198     }
 199
 200     public void trace(Object o) {
 201         if (isTraceEnabled()) {
 202             log(Level.FINER, null, String.valueOf(o));
 203         }
 204     }
 205
 206     public void trace(String format, Object arg) {
 207         if (isTraceEnabled()) {
 208             log(Level.FINER, null, format, arg);
 209         }
 210     }
 211
 212     public void trace(String format, Object... args) {
 213         if (isTraceEnabled()) {
 214             log(Level.FINER, null, format, args);
 215         }
 216     }
 217
 218     public void atEnter(String method, Object... args) {
 219         // trace("entering method [%s]", method);
 220         setEnteredMethodName(method);
 221         log.entering(log.getName(), method, args);
 222     }
 223
 224     public void atExit(String method) {
 225         // trace("exiting method [%s] with return value [%s]", method, returnValue);
 226         log.exiting(log.getName(), method);
 227         setEnteredMethodName("");
 228     }
 229
 230     public <T> T atExit(String method, T returnValue) {
 231         // trace("exiting method [%s] with return value [%s]", method, returnValue);
 232         log.exiting(log.getName(), method, returnValue);
 233         setEnteredMethodName("");
 234         return returnValue;
 235     }
 236
 237 }