001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 018 019 package org.apache.commons.logging.impl; 020 021 022 import java.io.Serializable; 023 import java.util.logging.Level; 024 import java.util.logging.Logger; 025 026 import org.apache.commons.logging.Log; 027 028 029 /** 030 * <p>Implementation of the <code>org.apache.commons.logging.Log</code> 031 * interface that wraps the standard JDK logging mechanisms that were 032 * introduced in the Merlin release (JDK 1.4).</p> 033 * 034 * @author <a href="mailto:sanders@apache.org">Scott Sanders</a> 035 * @author <a href="mailto:bloritsch@apache.org">Berin Loritsch</a> 036 * @author <a href="mailto:donaldp@apache.org">Peter Donald</a> 037 * @version $Revision: 424107 $ $Date: 2006-07-21 01:15:42 +0200 (fr, 21 jul 2006) $ 038 */ 039 040 public class Jdk14Logger implements Log, Serializable { 041 042 /** 043 * This member variable simply ensures that any attempt to initialise 044 * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError. 045 * It must not be private, as an optimising compiler could detect that it 046 * is not used and optimise it away. 047 */ 048 protected static final Level dummyLevel = Level.FINE; 049 050 // ----------------------------------------------------------- Constructors 051 052 053 /** 054 * Construct a named instance of this Logger. 055 * 056 * @param name Name of the logger to be constructed 057 */ 058 public Jdk14Logger(String name) { 059 060 this.name = name; 061 logger = getLogger(); 062 063 } 064 065 066 // ----------------------------------------------------- Instance Variables 067 068 069 /** 070 * The underlying Logger implementation we are using. 071 */ 072 protected transient Logger logger = null; 073 074 075 /** 076 * The name of the logger we are wrapping. 077 */ 078 protected String name = null; 079 080 081 // --------------------------------------------------------- Public Methods 082 083 private void log( Level level, String msg, Throwable ex ) { 084 085 Logger logger = getLogger(); 086 if (logger.isLoggable(level)) { 087 // Hack (?) to get the stack trace. 088 Throwable dummyException=new Throwable(); 089 StackTraceElement locations[]=dummyException.getStackTrace(); 090 // Caller will be the third element 091 String cname="unknown"; 092 String method="unknown"; 093 if( locations!=null && locations.length >2 ) { 094 StackTraceElement caller=locations[2]; 095 cname=caller.getClassName(); 096 method=caller.getMethodName(); 097 } 098 if( ex==null ) { 099 logger.logp( level, cname, method, msg ); 100 } else { 101 logger.logp( level, cname, method, msg, ex ); 102 } 103 } 104 105 } 106 107 /** 108 * Logs a message with <code>java.util.logging.Level.FINE</code>. 109 * 110 * @param message to log 111 * @see org.apache.commons.logging.Log#debug(Object) 112 */ 113 public void debug(Object message) { 114 log(Level.FINE, String.valueOf(message), null); 115 } 116 117 118 /** 119 * Logs a message with <code>java.util.logging.Level.FINE</code>. 120 * 121 * @param message to log 122 * @param exception log this cause 123 * @see org.apache.commons.logging.Log#debug(Object, Throwable) 124 */ 125 public void debug(Object message, Throwable exception) { 126 log(Level.FINE, String.valueOf(message), exception); 127 } 128 129 130 /** 131 * Logs a message with <code>java.util.logging.Level.SEVERE</code>. 132 * 133 * @param message to log 134 * @see org.apache.commons.logging.Log#error(Object) 135 */ 136 public void error(Object message) { 137 log(Level.SEVERE, String.valueOf(message), null); 138 } 139 140 141 /** 142 * Logs a message with <code>java.util.logging.Level.SEVERE</code>. 143 * 144 * @param message to log 145 * @param exception log this cause 146 * @see org.apache.commons.logging.Log#error(Object, Throwable) 147 */ 148 public void error(Object message, Throwable exception) { 149 log(Level.SEVERE, String.valueOf(message), exception); 150 } 151 152 153 /** 154 * Logs a message with <code>java.util.logging.Level.SEVERE</code>. 155 * 156 * @param message to log 157 * @see org.apache.commons.logging.Log#fatal(Object) 158 */ 159 public void fatal(Object message) { 160 log(Level.SEVERE, String.valueOf(message), null); 161 } 162 163 164 /** 165 * Logs a message with <code>java.util.logging.Level.SEVERE</code>. 166 * 167 * @param message to log 168 * @param exception log this cause 169 * @see org.apache.commons.logging.Log#fatal(Object, Throwable) 170 */ 171 public void fatal(Object message, Throwable exception) { 172 log(Level.SEVERE, String.valueOf(message), exception); 173 } 174 175 176 /** 177 * Return the native Logger instance we are using. 178 */ 179 public Logger getLogger() { 180 if (logger == null) { 181 logger = Logger.getLogger(name); 182 } 183 return (logger); 184 } 185 186 187 /** 188 * Logs a message with <code>java.util.logging.Level.INFO</code>. 189 * 190 * @param message to log 191 * @see org.apache.commons.logging.Log#info(Object) 192 */ 193 public void info(Object message) { 194 log(Level.INFO, String.valueOf(message), null); 195 } 196 197 198 /** 199 * Logs a message with <code>java.util.logging.Level.INFO</code>. 200 * 201 * @param message to log 202 * @param exception log this cause 203 * @see org.apache.commons.logging.Log#info(Object, Throwable) 204 */ 205 public void info(Object message, Throwable exception) { 206 log(Level.INFO, String.valueOf(message), exception); 207 } 208 209 210 /** 211 * Is debug logging currently enabled? 212 */ 213 public boolean isDebugEnabled() { 214 return (getLogger().isLoggable(Level.FINE)); 215 } 216 217 218 /** 219 * Is error logging currently enabled? 220 */ 221 public boolean isErrorEnabled() { 222 return (getLogger().isLoggable(Level.SEVERE)); 223 } 224 225 226 /** 227 * Is fatal logging currently enabled? 228 */ 229 public boolean isFatalEnabled() { 230 return (getLogger().isLoggable(Level.SEVERE)); 231 } 232 233 234 /** 235 * Is info logging currently enabled? 236 */ 237 public boolean isInfoEnabled() { 238 return (getLogger().isLoggable(Level.INFO)); 239 } 240 241 242 /** 243 * Is trace logging currently enabled? 244 */ 245 public boolean isTraceEnabled() { 246 return (getLogger().isLoggable(Level.FINEST)); 247 } 248 249 250 /** 251 * Is warn logging currently enabled? 252 */ 253 public boolean isWarnEnabled() { 254 return (getLogger().isLoggable(Level.WARNING)); 255 } 256 257 258 /** 259 * Logs a message with <code>java.util.logging.Level.FINEST</code>. 260 * 261 * @param message to log 262 * @see org.apache.commons.logging.Log#trace(Object) 263 */ 264 public void trace(Object message) { 265 log(Level.FINEST, String.valueOf(message), null); 266 } 267 268 269 /** 270 * Logs a message with <code>java.util.logging.Level.FINEST</code>. 271 * 272 * @param message to log 273 * @param exception log this cause 274 * @see org.apache.commons.logging.Log#trace(Object, Throwable) 275 */ 276 public void trace(Object message, Throwable exception) { 277 log(Level.FINEST, String.valueOf(message), exception); 278 } 279 280 281 /** 282 * Logs a message with <code>java.util.logging.Level.WARNING</code>. 283 * 284 * @param message to log 285 * @see org.apache.commons.logging.Log#warn(Object) 286 */ 287 public void warn(Object message) { 288 log(Level.WARNING, String.valueOf(message), null); 289 } 290 291 292 /** 293 * Logs a message with <code>java.util.logging.Level.WARNING</code>. 294 * 295 * @param message to log 296 * @param exception log this cause 297 * @see org.apache.commons.logging.Log#warn(Object, Throwable) 298 */ 299 public void warn(Object message, Throwable exception) { 300 log(Level.WARNING, String.valueOf(message), exception); 301 } 302 303 304 }