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