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    *   https://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.netty5.util.internal.logging;
41  
42  import org.apache.commons.logging.Log;
43  
44  import static java.util.Objects.requireNonNull;
45  
46  /**
47   * <a href="https://commons.apache.org/logging/">Apache Commons Logging</a>
48   * logger.
49   *
50   * @deprecated Please use {@link Log4J2Logger} or {@link Log4JLogger} or
51   * {@link Slf4JLogger}.
52   */
53  @Deprecated
54  class CommonsLogger extends AbstractInternalLogger {
55  
56      private static final long serialVersionUID = 8647838678388394885L;
57  
58      private final transient Log logger;
59  
60      CommonsLogger(Log logger, String name) {
61          super(name);
62          requireNonNull(logger, "logger");
63          this.logger = logger;
64      }
65  
66      /**
67       * Delegates to the {@link Log#isTraceEnabled} method of the underlying
68       * {@link Log} instance.
69       */
70      @Override
71      public boolean isTraceEnabled() {
72          return logger.isTraceEnabled();
73      }
74  
75      /**
76       * Delegates to the {@link Log#trace(Object)} method of the underlying
77       * {@link Log} instance.
78       *
79       * @param msg - the message object to be logged
80       */
81      @Override
82      public void trace(String msg) {
83          logger.trace(msg);
84      }
85  
86      /**
87       * Delegates to the {@link Log#trace(Object)} method of the underlying
88       * {@link Log} instance.
89       *
90       * <p>
91       * However, this form avoids superfluous object creation when the logger is disabled
92       * for level TRACE.
93       * </p>
94       *
95       * @param format
96       *          the format string
97       * @param arg
98       *          the argument
99       */
100     @Override
101     public void trace(String format, Object arg) {
102         if (logger.isTraceEnabled()) {
103             FormattingTuple ft = MessageFormatter.format(format, arg);
104             logger.trace(ft.getMessage(), ft.getThrowable());
105         }
106     }
107 
108     /**
109      * Delegates to the {@link Log#trace(Object)} method of the underlying
110      * {@link Log} instance.
111      *
112      * <p>
113      * However, this form avoids superfluous object creation when the logger is disabled
114      * for level TRACE.
115      * </p>
116      *
117      * @param format
118      *          the format string
119      * @param argA
120      *          the first argument
121      * @param argB
122      *          the second argument
123      */
124     @Override
125     public void trace(String format, Object argA, Object argB) {
126         if (logger.isTraceEnabled()) {
127             FormattingTuple ft = MessageFormatter.format(format, argA, argB);
128             logger.trace(ft.getMessage(), ft.getThrowable());
129         }
130     }
131 
132     /**
133      * Delegates to the {@link Log#trace(Object)} method of the underlying
134      * {@link Log} instance.
135      *
136      * <p>
137      * However, this form avoids superfluous object creation when the logger is disabled
138      * for level TRACE.
139      * </p>
140      *
141      * @param format the format string
142      * @param arguments a list of 3 or more arguments
143      */
144     @Override
145     public void trace(String format, Object... arguments) {
146         if (logger.isTraceEnabled()) {
147             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
148             logger.trace(ft.getMessage(), ft.getThrowable());
149         }
150     }
151 
152     /**
153      * Delegates to the {@link Log#trace(Object, Throwable)} method of
154      * the underlying {@link Log} instance.
155      *
156      * @param msg
157      *          the message accompanying the exception
158      * @param t
159      *          the exception (throwable) to log
160      */
161     @Override
162     public void trace(String msg, Throwable t) {
163         logger.trace(msg, t);
164     }
165 
166     /**
167      * Delegates to the {@link Log#isDebugEnabled} method of the underlying
168      * {@link Log} instance.
169      */
170     @Override
171     public boolean isDebugEnabled() {
172         return logger.isDebugEnabled();
173     }
174 
175     //
176 
177     /**
178      * Delegates to the {@link Log#debug(Object)} method of the underlying
179      * {@link Log} instance.
180      *
181      * @param msg - the message object to be logged
182      */
183     @Override
184     public void debug(String msg) {
185         logger.debug(msg);
186     }
187 
188     /**
189      * Delegates to the {@link Log#debug(Object)} method of the underlying
190      * {@link Log} instance.
191      *
192      * <p>
193      * However, this form avoids superfluous object creation when the logger is disabled
194      * for level DEBUG.
195      * </p>
196      *
197      * @param format
198      *          the format string
199      * @param arg
200      *          the argument
201      */
202     @Override
203     public void debug(String format, Object arg) {
204         if (logger.isDebugEnabled()) {
205             FormattingTuple ft = MessageFormatter.format(format, arg);
206             logger.debug(ft.getMessage(), ft.getThrowable());
207         }
208     }
209 
210     /**
211      * Delegates to the {@link Log#debug(Object)} method of the underlying
212      * {@link Log} instance.
213      *
214      * <p>
215      * However, 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 argA
222      *          the first argument
223      * @param argB
224      *          the second argument
225      */
226     @Override
227     public void debug(String format, Object argA, Object argB) {
228         if (logger.isDebugEnabled()) {
229             FormattingTuple ft = MessageFormatter.format(format, argA, argB);
230             logger.debug(ft.getMessage(), ft.getThrowable());
231         }
232     }
233 
234     /**
235      * Delegates to the {@link Log#debug(Object)} method of the underlying
236      * {@link Log} instance.
237      *
238      * <p>
239      * However, this form avoids superfluous object creation when the logger is disabled
240      * for level DEBUG.
241      * </p>
242      *
243      * @param format the format string
244      * @param arguments a list of 3 or more arguments
245      */
246     @Override
247     public void debug(String format, Object... arguments) {
248         if (logger.isDebugEnabled()) {
249             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
250             logger.debug(ft.getMessage(), ft.getThrowable());
251         }
252     }
253 
254     /**
255      * Delegates to the {@link Log#debug(Object, Throwable)} method of
256      * the underlying {@link Log} instance.
257      *
258      * @param msg
259      *          the message accompanying the exception
260      * @param t
261      *          the exception (throwable) to log
262      */
263     @Override
264     public void debug(String msg, Throwable t) {
265         logger.debug(msg, t);
266     }
267 
268     /**
269      * Delegates to the {@link Log#isInfoEnabled} method of the underlying
270      * {@link Log} instance.
271      */
272     @Override
273     public boolean isInfoEnabled() {
274         return logger.isInfoEnabled();
275     }
276 
277     /**
278      * Delegates to the {@link Log#debug(Object)} method of the underlying
279      * {@link Log} instance.
280      *
281      * @param msg - the message object to be logged
282      */
283     @Override
284     public void info(String msg) {
285         logger.info(msg);
286     }
287 
288     /**
289      * Delegates to the {@link Log#info(Object)} method of the underlying
290      * {@link Log} instance.
291      *
292      * <p>
293      * However, this form avoids superfluous object creation when the logger is disabled
294      * for level INFO.
295      * </p>
296      *
297      * @param format
298      *          the format string
299      * @param arg
300      *          the argument
301      */
302 
303     @Override
304     public void info(String format, Object arg) {
305         if (logger.isInfoEnabled()) {
306             FormattingTuple ft = MessageFormatter.format(format, arg);
307             logger.info(ft.getMessage(), ft.getThrowable());
308         }
309     }
310     /**
311      * Delegates to the {@link Log#info(Object)} method of the underlying
312      * {@link Log} instance.
313      *
314      * <p>
315      * However, this form avoids superfluous object creation when the logger is disabled
316      * for level INFO.
317      * </p>
318      *
319      * @param format
320      *          the format string
321      * @param argA
322      *          the first argument
323      * @param argB
324      *          the second argument
325      */
326     @Override
327     public void info(String format, Object argA, Object argB) {
328         if (logger.isInfoEnabled()) {
329             FormattingTuple ft = MessageFormatter.format(format, argA, argB);
330             logger.info(ft.getMessage(), ft.getThrowable());
331         }
332     }
333 
334     /**
335      * Delegates to the {@link Log#info(Object)} method of the underlying
336      * {@link Log} instance.
337      *
338      * <p>
339      * However, this form avoids superfluous object creation when the logger is disabled
340      * for level INFO.
341      * </p>
342      *
343      * @param format the format string
344      * @param arguments a list of 3 or more arguments
345      */
346     @Override
347     public void info(String format, Object... arguments) {
348         if (logger.isInfoEnabled()) {
349             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
350             logger.info(ft.getMessage(), ft.getThrowable());
351         }
352     }
353 
354     /**
355      * Delegates to the {@link Log#info(Object, Throwable)} method of
356      * the underlying {@link Log} instance.
357      *
358      * @param msg
359      *          the message accompanying the exception
360      * @param t
361      *          the exception (throwable) to log
362      */
363     @Override
364     public void info(String msg, Throwable t) {
365         logger.info(msg, t);
366     }
367 
368     /**
369      * Delegates to the {@link Log#isWarnEnabled} method of the underlying
370      * {@link Log} instance.
371      */
372     @Override
373     public boolean isWarnEnabled() {
374         return logger.isWarnEnabled();
375     }
376 
377     /**
378      * Delegates to the {@link Log#warn(Object)} method of the underlying
379      * {@link Log} instance.
380      *
381      * @param msg - the message object to be logged
382      */
383     @Override
384     public void warn(String msg) {
385         logger.warn(msg);
386     }
387 
388     /**
389      * Delegates to the {@link Log#warn(Object)} method of the underlying
390      * {@link Log} instance.
391      *
392      * <p>
393      * However, this form avoids superfluous object creation when the logger is disabled
394      * for level WARN.
395      * </p>
396      *
397      * @param format
398      *          the format string
399      * @param arg
400      *          the argument
401      */
402     @Override
403     public void warn(String format, Object arg) {
404         if (logger.isWarnEnabled()) {
405             FormattingTuple ft = MessageFormatter.format(format, arg);
406             logger.warn(ft.getMessage(), ft.getThrowable());
407         }
408     }
409 
410     /**
411      * Delegates to the {@link Log#warn(Object)} method of the underlying
412      * {@link Log} instance.
413      *
414      * <p>
415      * However, this form avoids superfluous object creation when the logger is disabled
416      * for level WARN.
417      * </p>
418      *
419      * @param format
420      *          the format string
421      * @param argA
422      *          the first argument
423      * @param argB
424      *          the second argument
425      */
426     @Override
427     public void warn(String format, Object argA, Object argB) {
428         if (logger.isWarnEnabled()) {
429             FormattingTuple ft = MessageFormatter.format(format, argA, argB);
430             logger.warn(ft.getMessage(), ft.getThrowable());
431         }
432     }
433 
434     /**
435      * Delegates to the {@link Log#warn(Object)} method of the underlying
436      * {@link Log} instance.
437      *
438      * <p>
439      * However, this form avoids superfluous object creation when the logger is disabled
440      * for level WARN.
441      * </p>
442      *
443      * @param format the format string
444      * @param arguments a list of 3 or more arguments
445      */
446     @Override
447     public void warn(String format, Object... arguments) {
448         if (logger.isWarnEnabled()) {
449             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
450             logger.warn(ft.getMessage(), ft.getThrowable());
451         }
452     }
453 
454     /**
455      * Delegates to the {@link Log#warn(Object, Throwable)} method of
456      * the underlying {@link Log} instance.
457      *
458      * @param msg
459      *          the message accompanying the exception
460      * @param t
461      *          the exception (throwable) to log
462      */
463 
464     @Override
465     public void warn(String msg, Throwable t) {
466         logger.warn(msg, t);
467     }
468 
469     /**
470      * Delegates to the {@link Log#isErrorEnabled} method of the underlying
471      * {@link Log} instance.
472      */
473     @Override
474     public boolean isErrorEnabled() {
475         return logger.isErrorEnabled();
476     }
477 
478     /**
479      * Delegates to the {@link Log#error(Object)} method of the underlying
480      * {@link Log} instance.
481      *
482      * @param msg - the message object to be logged
483      */
484     @Override
485     public void error(String msg) {
486         logger.error(msg);
487     }
488 
489     /**
490      * Delegates to the {@link Log#error(Object)} method of the underlying
491      * {@link Log} instance.
492      *
493      * <p>
494      * However, this form avoids superfluous object creation when the logger is disabled
495      * for level ERROR.
496      * </p>
497      *
498      * @param format
499      *          the format string
500      * @param arg
501      *          the argument
502      */
503     @Override
504     public void error(String format, Object arg) {
505         if (logger.isErrorEnabled()) {
506             FormattingTuple ft = MessageFormatter.format(format, arg);
507             logger.error(ft.getMessage(), ft.getThrowable());
508         }
509     }
510 
511     /**
512      * Delegates to the {@link Log#error(Object)} method of the underlying
513      * {@link Log} instance.
514      *
515      * <p>
516      * However, this form avoids superfluous object creation when the logger is disabled
517      * for level ERROR.
518      * </p>
519      *
520      * @param format
521      *          the format string
522      * @param argA
523      *          the first argument
524      * @param argB
525      *          the second argument
526      */
527     @Override
528     public void error(String format, Object argA, Object argB) {
529         if (logger.isErrorEnabled()) {
530             FormattingTuple ft = MessageFormatter.format(format, argA, argB);
531             logger.error(ft.getMessage(), ft.getThrowable());
532         }
533     }
534 
535     /**
536      * Delegates to the {@link Log#error(Object)} method of the underlying
537      * {@link Log} instance.
538      *
539      * <p>
540      * However, this form avoids superfluous object creation when the logger is disabled
541      * for level ERROR.
542      * </p>
543      *
544      * @param format the format string
545      * @param arguments a list of 3 or more arguments
546      */
547     @Override
548     public void error(String format, Object... arguments) {
549         if (logger.isErrorEnabled()) {
550             FormattingTuple ft = MessageFormatter.arrayFormat(format, arguments);
551             logger.error(ft.getMessage(), ft.getThrowable());
552         }
553     }
554 
555     /**
556      * Delegates to the {@link Log#error(Object, Throwable)} method of
557      * the underlying {@link Log} instance.
558      *
559      * @param msg
560      *          the message accompanying the exception
561      * @param t
562      *          the exception (throwable) to log
563      */
564     @Override
565     public void error(String msg, Throwable t) {
566         logger.error(msg, t);
567     }
568 }