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 package org.apache.commons.logging.impl;
19
20 import java.io.Serializable;
21 import java.util.logging.Level;
22 import java.util.logging.Logger;
23
24 import org.apache.commons.logging.Log;
25
26 /**
27 * Implementation of the {@code org.apache.commons.logging.Log}
28 * interface that wraps the standard JDK logging mechanisms that were
29 * introduced in the Merlin release (JDK 1.4).
30 */
31 public class Jdk14Logger implements Log, Serializable {
32
33 /** Serializable version identifier. */
34 private static final long serialVersionUID = 4784713551416303804L;
35
36 /**
37 * This member variable simply ensures that any attempt to initialize
38 * this class in a pre-1.4 JVM will result in an ExceptionInInitializerError.
39 * It must not be private, as an optimizing compiler could detect that it
40 * is not used and optimize it away.
41 */
42 protected static final Level dummyLevel = Level.FINE;
43
44 /**
45 * The underlying Logger implementation we are using.
46 */
47 protected transient Logger logger;
48
49 /**
50 * The name of the logger we are wrapping.
51 */
52 protected String name;
53
54 /**
55 * Constructs a named instance of this Logger.
56 *
57 * @param name Name of the logger to be constructed
58 */
59 public Jdk14Logger(final String name) {
60 this.name = name;
61 logger = getLogger();
62 }
63
64 /**
65 * Logs a message with {@link java.util.logging.Level#FINE}.
66 *
67 * @param message to log
68 * @see org.apache.commons.logging.Log#debug(Object)
69 */
70 @Override
71 public void debug(final Object message) {
72 log(Level.FINE, String.valueOf(message), null);
73 }
74
75 /**
76 * Logs a message with {@link java.util.logging.Level#FINE}.
77 *
78 * @param message to log
79 * @param exception log this cause
80 * @see org.apache.commons.logging.Log#debug(Object, Throwable)
81 */
82 @Override
83 public void debug(final Object message, final Throwable exception) {
84 log(Level.FINE, String.valueOf(message), exception);
85 }
86
87 /**
88 * Logs a message with {@link java.util.logging.Level#SEVERE}.
89 *
90 * @param message to log
91 * @see org.apache.commons.logging.Log#error(Object)
92 */
93 @Override
94 public void error(final Object message) {
95 log(Level.SEVERE, String.valueOf(message), null);
96 }
97
98 /**
99 * Logs a message with {@link java.util.logging.Level#SEVERE}.
100 *
101 * @param message to log
102 * @param exception log this cause
103 * @see org.apache.commons.logging.Log#error(Object, Throwable)
104 */
105 @Override
106 public void error(final Object message, final Throwable exception) {
107 log(Level.SEVERE, String.valueOf(message), exception);
108 }
109
110 /**
111 * Logs a message with {@link java.util.logging.Level#SEVERE}.
112 *
113 * @param message to log
114 * @see org.apache.commons.logging.Log#fatal(Object)
115 */
116 @Override
117 public void fatal(final Object message) {
118 log(Level.SEVERE, String.valueOf(message), null);
119 }
120
121 /**
122 * Logs a message with {@link java.util.logging.Level#SEVERE}.
123 *
124 * @param message to log
125 * @param exception log this cause
126 * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
127 */
128 @Override
129 public void fatal(final Object message, final Throwable exception) {
130 log(Level.SEVERE, String.valueOf(message), exception);
131 }
132
133 /**
134 * Gets the native Logger instance we are using.
135 *
136 * @return the native Logger instance we are using.
137 */
138 public Logger getLogger() {
139 if (logger == null) {
140 logger = Logger.getLogger(name);
141 }
142 return logger;
143 }
144
145 /**
146 * Logs a message with {@link java.util.logging.Level#INFO}.
147 *
148 * @param message to log
149 * @see org.apache.commons.logging.Log#info(Object)
150 */
151 @Override
152 public void info(final Object message) {
153 log(Level.INFO, String.valueOf(message), null);
154 }
155
156 /**
157 * Logs a message with {@link java.util.logging.Level#INFO}.
158 *
159 * @param message to log
160 * @param exception log this cause
161 * @see org.apache.commons.logging.Log#info(Object, Throwable)
162 */
163 @Override
164 public void info(final Object message, final Throwable exception) {
165 log(Level.INFO, String.valueOf(message), exception);
166 }
167
168 /**
169 * Is debug logging currently enabled?
170 */
171 @Override
172 public boolean isDebugEnabled() {
173 return getLogger().isLoggable(Level.FINE);
174 }
175
176 /**
177 * Is error logging currently enabled?
178 */
179 @Override
180 public boolean isErrorEnabled() {
181 return getLogger().isLoggable(Level.SEVERE);
182 }
183
184 /**
185 * Is fatal logging currently enabled?
186 */
187 @Override
188 public boolean isFatalEnabled() {
189 return getLogger().isLoggable(Level.SEVERE);
190 }
191
192 /**
193 * Is info logging currently enabled?
194 */
195 @Override
196 public boolean isInfoEnabled() {
197 return getLogger().isLoggable(Level.INFO);
198 }
199
200 /**
201 * Is trace logging currently enabled?
202 */
203 @Override
204 public boolean isTraceEnabled() {
205 return getLogger().isLoggable(Level.FINEST);
206 }
207
208 /**
209 * Is warn logging currently enabled?
210 */
211 @Override
212 public boolean isWarnEnabled() {
213 return getLogger().isLoggable(Level.WARNING);
214 }
215
216 /**
217 * Logs a message at the given level.
218 * @param level The level.
219 * @param msg The message.
220 * @param ex The exception.
221 */
222 protected void log(final Level level, final String msg, final Throwable ex) {
223 final Logger logger = getLogger();
224 if (logger.isLoggable(level)) {
225 // Hack (?) to get the stack trace.
226 final Throwable dummyException = new Throwable();
227 final StackTraceElement[] locations = dummyException.getStackTrace();
228 // LOGGING-132: use the provided logger name instead of the class name
229 final String cname = name;
230 String method = "unknown";
231 // Caller will be the third element
232 if (locations != null && locations.length > 2) {
233 final StackTraceElement caller = locations[2];
234 method = caller.getMethodName();
235 }
236 if (ex == null) {
237 logger.logp(level, cname, method, msg);
238 } else {
239 logger.logp(level, cname, method, msg, ex);
240 }
241 }
242 }
243
244 /**
245 * Logs a message with {@link java.util.logging.Level#FINEST}.
246 *
247 * @param message to log
248 * @see org.apache.commons.logging.Log#trace(Object)
249 */
250 @Override
251 public void trace(final Object message) {
252 log(Level.FINEST, String.valueOf(message), null);
253 }
254
255 /**
256 * Logs a message with {@link java.util.logging.Level#FINEST}.
257 *
258 * @param message to log
259 * @param exception log this cause
260 * @see org.apache.commons.logging.Log#trace(Object, Throwable)
261 */
262 @Override
263 public void trace(final Object message, final Throwable exception) {
264 log(Level.FINEST, String.valueOf(message), exception);
265 }
266
267 /**
268 * Logs a message with {@link java.util.logging.Level#WARNING}.
269 *
270 * @param message to log
271 * @see org.apache.commons.logging.Log#warn(Object)
272 */
273 @Override
274 public void warn(final Object message) {
275 log(Level.WARNING, String.valueOf(message), null);
276 }
277
278 /**
279 * Logs a message with {@link java.util.logging.Level#WARNING}.
280 *
281 * @param message to log
282 * @param exception log this cause
283 * @see org.apache.commons.logging.Log#warn(Object, Throwable)
284 */
285 @Override
286 public void warn(final Object message, final Throwable exception) {
287 log(Level.WARNING, String.valueOf(message), exception);
288 }
289 }