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.commons.logging.Log;
43
44 /**
45 * <a href="http://commons.apache.org/logging/">Apache Commons Logging</a>
46 * logger.
47 *
48 * @deprecated Please use {@link Log4J2Logger} or {@link Log4JLogger} or
49 * {@link Slf4JLogger}.
50 */
51 @Deprecated
52 class CommonsLogger extends AbstractInternalLogger {
53
54 private static final long serialVersionUID = 8647838678388394885L;
55
56 private final transient Log logger;
57
58 CommonsLogger(Log logger, String name) {
59 super(name);
60 if (logger == null) {
61 throw new NullPointerException("logger");
62 }
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 }