1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18
19 package org.apache.commons.logging.impl;
20
21
22 import java.io.Serializable;
23 import java.util.logging.Level;
24 import java.util.logging.Logger;
25
26 import org.apache.commons.logging.Log;
27
28
29 /**
30 * <p>Implementation of the <code>org.apache.commons.logging.Log</code>
31 * interface that wraps the standard JDK logging mechanisms that were
32 * introduced in the Merlin release (JDK 1.4).</p>
33 *
34 * @author <a href="mailto:sanders@apache.org">Scott Sanders</a>
35 * @author <a href="mailto:bloritsch@apache.org">Berin Loritsch</a>
36 * @author <a href="mailto:donaldp@apache.org">Peter Donald</a>
37 * @version $Revision: 424107 $ $Date: 2006-07-21 01:15:42 +0200 (fr, 21 jul 2006) $
38 */
39
40 public class Jdk14Logger implements Log, Serializable {
41
42 /**
43 * This member variable simply ensures that any attempt to initialise
44 * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
45 * It must not be private, as an optimising compiler could detect that it
46 * is not used and optimise it away.
47 */
48 protected static final Level dummyLevel = Level.FINE;
49
50 // ----------------------------------------------------------- Constructors
51
52
53 /**
54 * Construct a named instance of this Logger.
55 *
56 * @param name Name of the logger to be constructed
57 */
58 public Jdk14Logger(String name) {
59
60 this.name = name;
61 logger = getLogger();
62
63 }
64
65
66 // ----------------------------------------------------- Instance Variables
67
68
69 /**
70 * The underlying Logger implementation we are using.
71 */
72 protected transient Logger logger = null;
73
74
75 /**
76 * The name of the logger we are wrapping.
77 */
78 protected String name = null;
79
80
81 // --------------------------------------------------------- Public Methods
82
83 private void log( Level level, String msg, Throwable ex ) {
84
85 Logger logger = getLogger();
86 if (logger.isLoggable(level)) {
87 // Hack (?) to get the stack trace.
88 Throwable dummyException=new Throwable();
89 StackTraceElement locations[]=dummyException.getStackTrace();
90 // Caller will be the third element
91 String cname="unknown";
92 String method="unknown";
93 if( locations!=null && locations.length >2 ) {
94 StackTraceElement caller=locations[2];
95 cname=caller.getClassName();
96 method=caller.getMethodName();
97 }
98 if( ex==null ) {
99 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 }
Save This Page