1 /*
2 * Copyright (c) 2004-2008 QOS.ch
3 * All rights reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be
14 * included in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 package org.slf4j.impl;
27
28 import java.io.Serializable;
29
30 import org.apache.log4j.Level;
31 import org.slf4j.Logger;
32 import org.slf4j.Marker;
33 import org.slf4j.helpers.MarkerIgnoringBase;
34 import org.slf4j.helpers.MessageFormatter;
35 import org.slf4j.spi.LocationAwareLogger;
36
37 /**
38 * A wrapper over {@link org.apache.log4j.Logger org.apache.log4j.Logger} in
39 * conforming to the {@link Logger} interface.
40 *
41 * <p>Note that the logging levels mentioned in this class refer to those defined in the <a
42 * href="http://logging.apache.org/log4j/docs/api/org/apache/log4j/Level.html"><code>org.apache.log4j.Level</code></a>
43 * class.
44 *
45 * <p>
46 * The TRACE level was introduced in log4j version 1.2.12. In order to avoid
47 * crashing the host application, in the case the log4j version in use predates
48 * 1.2.12, the TRACE level will be mapped as DEBUG. See also <a
49 * href="http://bugzilla.slf4j.org/show_bug.cgi?id=68">bug 68</a>.
50 *
51 * @author Ceki Gülcü
52 */
53 public final class Log4jLoggerAdapter extends MarkerIgnoringBase implements
54 LocationAwareLogger, Serializable {
55
56 private static final long serialVersionUID = 6182834493563598289L;
57
58 final transient org.apache.log4j.Logger logger;
59
60 /**
61 * Following the pattern discussed in pages 162 through 168 of "The complete
62 * log4j manual".
63 */
64 final static String FQCN = Log4jLoggerAdapter.class.getName();
65
66 // Does the log4j version in use recognize the TRACE level?
67 // The trace level was introduced in log4j 1.2.12.
68 final boolean traceCapable;
69
70 // WARN: Log4jLoggerAdapter constructor should have only package access so
71 // that
72 // only Log4jLoggerFactory be able to create one.
73 Log4jLoggerAdapter(org.apache.log4j.Logger logger) {
74 this.logger = logger;
75 this.name = logger.getName();
76 traceCapable = isTraceCapable();
77 }
78
79 private boolean isTraceCapable() {
80 try {
81 logger.isTraceEnabled();
82 return true;
83 } catch (NoSuchMethodError e) {
84 return false;
85 }
86 }
87
88 /**
89 * Is this logger instance enabled for the TRACE level?
90 *
91 * @return True if this Logger is enabled for level TRACE, false otherwise.
92 */
93 public boolean isTraceEnabled() {
94 if (traceCapable) {
95 return logger.isTraceEnabled();
96 } else {
97 return logger.isDebugEnabled();
98 }
99 }
100
101 /**
102 * Log a message object at level TRACE.
103 *
104 * @param msg -
105 * the message object to be logged
106 */
107 public void trace(String msg) {
108 logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msg, null);
109 }
110
111 /**
112 * Log a message at level TRACE according to the specified format and
113 * argument.
114 *
115 * <p>
116 * This form avoids superfluous object creation when the logger is disabled
117 * for level TRACE.
118 * </p>
119 *
120 * @param format
121 * the format string
122 * @param arg
123 * the argument
124 */
125 public void trace(String format, Object arg) {
126 if (isTraceEnabled()) {
127 String msgStr = MessageFormatter.format(format, arg);
128 logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msgStr, null);
129 }
130 }
131
132 /**
133 * Log a message at level TRACE according to the specified format and
134 * arguments.
135 *
136 * <p>
137 * This form avoids superfluous object creation when the logger is disabled
138 * for the TRACE level.
139 * </p>
140 *
141 * @param format
142 * the format string
143 * @param arg1
144 * the first argument
145 * @param arg2
146 * the second argument
147 */
148 public void trace(String format, Object arg1, Object arg2) {
149 if (isTraceEnabled()) {
150 String msgStr = MessageFormatter.format(format, arg1, arg2);
151 logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msgStr, null);
152 }
153 }
154
155 /**
156 * Log a message at level TRACE according to the specified format and
157 * arguments.
158 *
159 * <p>
160 * This form avoids superfluous object creation when the logger is disabled
161 * for the TRACE level.
162 * </p>
163 *
164 * @param format
165 * the format string
166 * @param argArray
167 * an array of arguments
168 */
169 public void trace(String format, Object[] argArray) {
170 if (isTraceEnabled()) {
171 String msgStr = MessageFormatter.arrayFormat(format, argArray);
172 logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msgStr, null);
173 }
174 }
175
176 /**
177 * Log an exception (throwable) at level TRACE with an accompanying message.
178 *
179 * @param msg
180 * the message accompanying the exception
181 * @param t
182 * the exception (throwable) to log
183 */
184 public void trace(String msg, Throwable t) {
185 logger.log(FQCN, traceCapable ? Level.TRACE : Level.DEBUG, msg, t);
186 }
187
188 /**
189 * Is this logger instance enabled for the DEBUG level?
190 *
191 * @return True if this Logger is enabled for level DEBUG, false otherwise.
192 */
193 public boolean isDebugEnabled() {
194 return logger.isDebugEnabled();
195 }
196
197 /**
198 * Log a message object at level DEBUG.
199 *
200 * @param msg -
201 * the message object to be logged
202 */
203 public void debug(String msg) {
204 logger.log(FQCN, Level.DEBUG, msg, null);
205 }
206
207 /**
208 * Log a message at level DEBUG according to the specified format and
209 * argument.
210 *
211 * <p>
212 * This form avoids superfluous object creation when the logger is disabled
213 * for level DEBUG.
214 * </p>
215 *
216 * @param format
217 * the format string
218 * @param arg
219 * the argument
220 */
221 public void debug(String format, Object arg) {
222 if (logger.isDebugEnabled()) {
223 String msgStr = MessageFormatter.format(format, arg);
224 logger.log(FQCN, Level.DEBUG, msgStr, null);
225 }
226 }
227
228 /**
229 * Log a message at level DEBUG according to the specified format and
230 * arguments.
231 *
232 * <p>
233 * This form avoids superfluous object creation when the logger is disabled
234 * for the DEBUG level.
235 * </p>
236 *
237 * @param format
238 * the format string
239 * @param arg1
240 * the first argument
241 * @param arg2
242 * the second argument
243 */
244 public void debug(String format, Object arg1, Object arg2) {
245 if (logger.isDebugEnabled()) {
246 String msgStr = MessageFormatter.format(format, arg1, arg2);
247 logger.log(FQCN, Level.DEBUG, msgStr, null);
248 }
249 }
250
251 /**
252 * Log a message at level DEBUG according to the specified format and
253 * arguments.
254 *
255 * <p>
256 * This form avoids superfluous object creation when the logger is disabled
257 * for the DEBUG level.
258 * </p>
259 *
260 * @param format
261 * the format string
262 * @param argArray
263 * an array of arguments
264 */
265 public void debug(String format, Object[] argArray) {
266 if (logger.isDebugEnabled()) {
267 String msgStr = MessageFormatter.arrayFormat(format, argArray);
268 logger.log(FQCN, Level.DEBUG, msgStr, null);
269 }
270 }
271
272 /**
273 * Log an exception (throwable) at level DEBUG with an accompanying message.
274 *
275 * @param msg
276 * the message accompanying the exception
277 * @param t
278 * the exception (throwable) to log
279 */
280 public void debug(String msg, Throwable t) {
281 logger.log(FQCN, Level.DEBUG, msg, t);
282 }
283
284 /**
285 * Is this logger instance enabled for the INFO level?
286 *
287 * @return True if this Logger is enabled for the INFO level, false otherwise.
288 */
289 public boolean isInfoEnabled() {
290 return logger.isInfoEnabled();
291 }
292
293 /**
294 * Log a message object at the INFO level.
295 *
296 * @param msg -
297 * the message object to be logged
298 */
299 public void info(String msg) {
300 logger.log(FQCN, Level.INFO, msg, null);
301 }
302
303 /**
304 * Log a message at level INFO according to the specified format and argument.
305 *
306 * <p>
307 * This form avoids superfluous object creation when the logger is disabled
308 * for the INFO level.
309 * </p>
310 *
311 * @param format
312 * the format string
313 * @param arg
314 * the argument
315 */
316 public void info(String format, Object arg) {
317 if (logger.isInfoEnabled()) {
318 String msgStr = MessageFormatter.format(format, arg);
319 logger.log(FQCN, Level.INFO, msgStr, null);
320 }
321 }
322
323 /**
324 * Log a message at the INFO level according to the specified format and
325 * arguments.
326 *
327 * <p>
328 * This form avoids superfluous object creation when the logger is disabled
329 * for the INFO level.
330 * </p>
331 *
332 * @param format
333 * the format string
334 * @param arg1
335 * the first argument
336 * @param arg2
337 * the second argument
338 */
339 public void info(String format, Object arg1, Object arg2) {
340 if (logger.isInfoEnabled()) {
341 String msgStr = MessageFormatter.format(format, arg1, arg2);
342 logger.log(FQCN, Level.INFO, msgStr, null);
343 }
344 }
345
346 /**
347 * Log a message at level INFO according to the specified format and
348 * arguments.
349 *
350 * <p>
351 * This form avoids superfluous object creation when the logger is disabled
352 * for the INFO level.
353 * </p>
354 *
355 * @param format
356 * the format string
357 * @param argArray
358 * an array of arguments
359 */
360 public void info(String format, Object[] argArray) {
361 if (logger.isInfoEnabled()) {
362 String msgStr = MessageFormatter.arrayFormat(format, argArray);
363 logger.log(FQCN, Level.INFO, msgStr, null);
364 }
365 }
366
367 /**
368 * Log an exception (throwable) at the INFO level with an accompanying
369 * message.
370 *
371 * @param msg
372 * the message accompanying the exception
373 * @param t
374 * the exception (throwable) to log
375 */
376 public void info(String msg, Throwable t) {
377 logger.log(FQCN, Level.INFO, msg, t);
378 }
379
380 /**
381 * Is this logger instance enabled for the WARN level?
382 *
383 * @return True if this Logger is enabled for the WARN level, false otherwise.
384 */
385 public boolean isWarnEnabled() {
386 return logger.isEnabledFor(Level.WARN);
387 }
388
389 /**
390 * Log a message object at the WARN level.
391 *
392 * @param msg -
393 * the message object to be logged
394 */
395 public void warn(String msg) {
396 logger.log(FQCN, Level.WARN, msg, null);
397 }
398
399 /**
400 * Log a message at the WARN level according to the specified format and
401 * argument.
402 *
403 * <p>
404 * This form avoids superfluous object creation when the logger is disabled
405 * for the WARN level.
406 * </p>
407 *
408 * @param format
409 * the format string
410 * @param arg
411 * the argument
412 */
413 public void warn(String format, Object arg) {
414 if (logger.isEnabledFor(Level.WARN)) {
415 String msgStr = MessageFormatter.format(format, arg);
416 logger.log(FQCN, Level.WARN, msgStr, null);
417 }
418 }
419
420 /**
421 * Log a message at the WARN level according to the specified format and
422 * arguments.
423 *
424 * <p>
425 * This form avoids superfluous object creation when the logger is disabled
426 * for the WARN level.
427 * </p>
428 *
429 * @param format
430 * the format string
431 * @param arg1
432 * the first argument
433 * @param arg2
434 * the second argument
435 */
436 public void warn(String format, Object arg1, Object arg2) {
437 if (logger.isEnabledFor(Level.WARN)) {
438 String msgStr = MessageFormatter.format(format, arg1, arg2);
439 logger.log(FQCN, Level.WARN, msgStr, null);
440 }
441 }
442
443 /**
444 * Log a message at level WARN according to the specified format and
445 * arguments.
446 *
447 * <p>
448 * This form avoids superfluous object creation when the logger is disabled
449 * for the WARN level.
450 * </p>
451 *
452 * @param format
453 * the format string
454 * @param argArray
455 * an array of arguments
456 */
457 public void warn(String format, Object[] argArray) {
458 if (logger.isEnabledFor(Level.WARN)) {
459 String msgStr = MessageFormatter.arrayFormat(format, argArray);
460 logger.log(FQCN, Level.WARN, msgStr, null);
461 }
462 }
463
464 /**
465 * Log an exception (throwable) at the WARN level with an accompanying
466 * message.
467 *
468 * @param msg
469 * the message accompanying the exception
470 * @param t
471 * the exception (throwable) to log
472 */
473 public void warn(String msg, Throwable t) {
474 logger.log(FQCN, Level.WARN, msg, t);
475 }
476
477 /**
478 * Is this logger instance enabled for level ERROR?
479 *
480 * @return True if this Logger is enabled for level ERROR, false otherwise.
481 */
482 public boolean isErrorEnabled() {
483 return logger.isEnabledFor(Level.ERROR);
484 }
485
486 /**
487 * Log a message object at the ERROR level.
488 *
489 * @param msg -
490 * the message object to be logged
491 */
492 public void error(String msg) {
493 logger.log(FQCN, Level.ERROR, msg, null);
494 }
495
496 /**
497 * Log a message at the ERROR level according to the specified format and
498 * argument.
499 *
500 * <p>
501 * This form avoids superfluous object creation when the logger is disabled
502 * for the ERROR level.
503 * </p>
504 *
505 * @param format
506 * the format string
507 * @param arg
508 * the argument
509 */
510 public void error(String format, Object arg) {
511 if (logger.isEnabledFor(Level.ERROR)) {
512 String msgStr = MessageFormatter.format(format, arg);
513 logger.log(FQCN, Level.ERROR, msgStr, null);
514 }
515 }
516
517 /**
518 * Log a message at the ERROR level according to the specified format and
519 * arguments.
520 *
521 * <p>
522 * This form avoids superfluous object creation when the logger is disabled
523 * for the ERROR level.
524 * </p>
525 *
526 * @param format
527 * the format string
528 * @param arg1
529 * the first argument
530 * @param arg2
531 * the second argument
532 */
533 public void error(String format, Object arg1, Object arg2) {
534 if (logger.isEnabledFor(Level.ERROR)) {
535 String msgStr = MessageFormatter.format(format, arg1, arg2);
536 logger.log(FQCN, Level.ERROR, msgStr, null);
537 }
538 }
539
540 /**
541 * Log a message at level ERROR according to the specified format and
542 * arguments.
543 *
544 * <p>
545 * This form avoids superfluous object creation when the logger is disabled
546 * for the ERROR level.
547 * </p>
548 *
549 * @param format
550 * the format string
551 * @param argArray
552 * an array of arguments
553 */
554 public void error(String format, Object[] argArray) {
555 if (logger.isEnabledFor(Level.ERROR)) {
556 String msgStr = MessageFormatter.arrayFormat(format, argArray);
557 logger.log(FQCN, Level.ERROR, msgStr, null);
558 }
559 }
560
561 /**
562 * Log an exception (throwable) at the ERROR level with an accompanying
563 * message.
564 *
565 * @param msg
566 * the message accompanying the exception
567 * @param t
568 * the exception (throwable) to log
569 */
570 public void error(String msg, Throwable t) {
571 logger.log(FQCN, Level.ERROR, msg, t);
572 }
573
574 public void log(Marker marker, String callerFQCN, int level, String msg,
575 Throwable t) {
576 Level log4jLevel;
577 switch (level) {
578 case LocationAwareLogger.TRACE_INT:
579 log4jLevel = traceCapable ? Level.TRACE : Level.DEBUG;
580 break;
581 case LocationAwareLogger.DEBUG_INT:
582 log4jLevel = Level.DEBUG;
583 break;
584 case LocationAwareLogger.INFO_INT:
585 log4jLevel = Level.INFO;
586 break;
587 case LocationAwareLogger.WARN_INT:
588 log4jLevel = Level.WARN;
589 break;
590 case LocationAwareLogger.ERROR_INT:
591 log4jLevel = Level.ERROR;
592 break;
593 default:
594 throw new IllegalStateException("Level number " + level
595 + " is not recognized.");
596 }
597 logger.log(callerFQCN, log4jLevel, msg, t);
598 }
599
600 }