001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache license, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the license for the specific language governing permissions and 015 * limitations under the license. 016 */ 017 package org.apache.logging.log4j.spi; 018 019 import java.io.Serializable; 020 021 import org.apache.logging.log4j.Level; 022 import org.apache.logging.log4j.Marker; 023 import org.apache.logging.log4j.MarkerManager; 024 import org.apache.logging.log4j.message.Message; 025 import org.apache.logging.log4j.message.MessageFactory; 026 import org.apache.logging.log4j.message.ParameterizedMessageFactory; 027 import org.apache.logging.log4j.message.StringFormattedMessage; 028 import org.apache.logging.log4j.status.StatusLogger; 029 030 /** 031 * Base implementation of a Logger. It is highly recommended that any Logger implementation extend this class. 032 */ 033 public abstract class AbstractLogger implements ExtendedLogger, Serializable { 034 035 private static final long serialVersionUID = 2L; 036 037 /** 038 * Marker for flow tracing. 039 */ 040 public static final Marker FLOW_MARKER = MarkerManager.getMarker("FLOW"); 041 042 /** 043 * Marker for method entry tracing. 044 */ 045 public static final Marker ENTRY_MARKER = MarkerManager.getMarker("ENTRY").setParents(FLOW_MARKER); 046 047 /** 048 * Marker for method exit tracing. 049 */ 050 public static final Marker EXIT_MARKER = MarkerManager.getMarker("EXIT").setParents(FLOW_MARKER); 051 052 /** 053 * Marker for exception tracing. 054 */ 055 public static final Marker EXCEPTION_MARKER = MarkerManager.getMarker("EXCEPTION"); 056 057 /** 058 * Marker for throwing exceptions. 059 */ 060 public static final Marker THROWING_MARKER = MarkerManager.getMarker("THROWING").setParents(EXCEPTION_MARKER); 061 062 /** 063 * Marker for catching exceptions. 064 */ 065 public static final Marker CATCHING_MARKER = MarkerManager.getMarker("CATCHING").setParents(EXCEPTION_MARKER); 066 067 /** 068 * The default MessageFactory class. 069 */ 070 public static final Class<? extends MessageFactory> DEFAULT_MESSAGE_FACTORY_CLASS = ParameterizedMessageFactory.class; 071 072 private static final String FQCN = AbstractLogger.class.getName(); 073 074 private static final String THROWING = "throwing"; 075 076 private static final String CATCHING = "catching"; 077 078 /** 079 * Checks that the message factory a logger was created with is the same as the given messageFactory. If they are 080 * different log a warning to the {@linkplain StatusLogger}. A null MessageFactory translates to the default 081 * MessageFactory {@link #DEFAULT_MESSAGE_FACTORY_CLASS}. 082 * 083 * @param logger The logger to check 084 * @param messageFactory The message factory to check. 085 */ 086 public static void checkMessageFactory(final ExtendedLogger logger, final MessageFactory messageFactory) { 087 final String name = logger.getName(); 088 final MessageFactory loggerMessageFactory = logger.getMessageFactory(); 089 if (messageFactory != null && !loggerMessageFactory.equals(messageFactory)) { 090 StatusLogger.getLogger().warn( 091 "The Logger {} was created with the message factory {} and is now requested with the " 092 + "message factory {}, which may create log events with unexpected formatting.", name, 093 loggerMessageFactory, messageFactory); 094 } else if (messageFactory == null && !loggerMessageFactory.getClass().equals(DEFAULT_MESSAGE_FACTORY_CLASS)) { 095 StatusLogger 096 .getLogger() 097 .warn("The Logger {} was created with the message factory {} and is now requested with a null " 098 + "message factory (defaults to {}), which may create log events with unexpected formatting.", 099 name, loggerMessageFactory, DEFAULT_MESSAGE_FACTORY_CLASS.getName()); 100 } 101 } 102 103 private final String name; 104 105 private final MessageFactory messageFactory; 106 107 /** 108 * Creates a new logger named after the class (or subclass). 109 */ 110 public AbstractLogger() { 111 this.name = getClass().getName(); 112 this.messageFactory = createDefaultMessageFactory(); 113 } 114 115 /** 116 * Creates a new named logger. 117 * 118 * @param name the logger name 119 */ 120 public AbstractLogger(final String name) { 121 this.name = name; 122 this.messageFactory = createDefaultMessageFactory(); 123 } 124 125 /** 126 * Creates a new named logger. 127 * 128 * @param name the logger name 129 * @param messageFactory the message factory, if null then use the default message factory. 130 */ 131 public AbstractLogger(final String name, final MessageFactory messageFactory) { 132 this.name = name; 133 this.messageFactory = messageFactory == null ? createDefaultMessageFactory() : messageFactory; 134 } 135 136 /** 137 * Logs a Throwable that has been caught. 138 * 139 * @param level The logging Level. 140 * @param t The Throwable. 141 */ 142 @Override 143 public void catching(final Level level, final Throwable t) { 144 catching(FQCN, level, t); 145 } 146 147 /** 148 * Logs a Throwable that has been caught with location information. 149 * 150 * @param fqcn The fully qualified class name of the <b>caller</b>. 151 * @param level The logging level. 152 * @param t The Throwable. 153 */ 154 protected void catching(final String fqcn, final Level level, final Throwable t) { 155 if (isEnabled(level, CATCHING_MARKER, (Object) null, null)) { 156 logMessage(fqcn, level, CATCHING_MARKER, catchingMsg(t), t); 157 } 158 } 159 160 /** 161 * Logs a Throwable at the {@link Level#ERROR ERROR} level.. 162 * 163 * @param t The Throwable. 164 */ 165 @Override 166 public void catching(final Throwable t) { 167 if (isEnabled(Level.ERROR, CATCHING_MARKER, (Object) null, null)) { 168 logMessage(FQCN, Level.ERROR, CATCHING_MARKER, catchingMsg(t), t); 169 } 170 } 171 172 protected Message catchingMsg(final Throwable t) { 173 return messageFactory.newMessage(CATCHING); 174 } 175 176 private MessageFactory createDefaultMessageFactory() { 177 try { 178 return DEFAULT_MESSAGE_FACTORY_CLASS.newInstance(); 179 } catch (final InstantiationException e) { 180 throw new IllegalStateException(e); 181 } catch (final IllegalAccessException e) { 182 throw new IllegalStateException(e); 183 } 184 } 185 186 /** 187 * Logs a message with the specific Marker at the DEBUG level. 188 * 189 * @param marker the marker data specific to this log statement 190 * @param msg the message string to be logged 191 */ 192 @Override 193 public void debug(final Marker marker, final Message msg) { 194 logIfEnabled(FQCN, Level.DEBUG, marker, msg, null); 195 } 196 197 /** 198 * Logs a message with the specific Marker at the DEBUG level. 199 * 200 * @param marker the marker data specific to this log statement. 201 * @param msg the message string to be logged 202 * @param t A Throwable or null. 203 */ 204 @Override 205 public void debug(final Marker marker, final Message msg, final Throwable t) { 206 logIfEnabled(FQCN, Level.DEBUG, marker, msg, t); 207 } 208 209 /** 210 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 211 * 212 * @param marker the marker data specific to this log statement. 213 * @param message the message object to log. 214 */ 215 @Override 216 public void debug(final Marker marker, final Object message) { 217 logIfEnabled(FQCN, Level.DEBUG, marker, message, null); 218 } 219 220 /** 221 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 222 * <code>t</code> passed as parameter. 223 * 224 * @param marker the marker data specific to this log statement. 225 * @param message the message to log. 226 * @param t the exception to log, including its stack trace. 227 */ 228 @Override 229 public void debug(final Marker marker, final Object message, final Throwable t) { 230 logIfEnabled(FQCN, Level.DEBUG, marker, message, t); 231 } 232 233 /** 234 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 235 * 236 * @param marker the marker data specific to this log statement. 237 * @param message the message object to log. 238 */ 239 @Override 240 public void debug(final Marker marker, final String message) { 241 logIfEnabled(FQCN, Level.DEBUG, marker, message, (Throwable) null); 242 } 243 244 /** 245 * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level. 246 * 247 * @param marker the marker data specific to this log statement. 248 * @param message the message to log. 249 * @param params parameters to the message. 250 */ 251 @Override 252 public void debug(final Marker marker, final String message, final Object... params) { 253 logIfEnabled(FQCN, Level.DEBUG, marker, message, params); 254 } 255 256 /** 257 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 258 * <code>t</code> passed as parameter. 259 * 260 * @param marker the marker data specific to this log statement. 261 * @param message the message to log. 262 * @param t the exception to log, including its stack trace. 263 */ 264 @Override 265 public void debug(final Marker marker, final String message, final Throwable t) { 266 logIfEnabled(FQCN, Level.DEBUG, marker, message, t); 267 } 268 269 /** 270 * Logs the specified Message at the DEBUG level. 271 * 272 * @param msg the message to be logged 273 */ 274 @Override 275 public void debug(final Message msg) { 276 logIfEnabled(FQCN, Level.DEBUG, null, msg, null); 277 } 278 279 /** 280 * Logs the specified Message at the DEBUG level. 281 * 282 * @param msg the message to be logged 283 * @param t A Throwable or null. 284 */ 285 @Override 286 public void debug(final Message msg, final Throwable t) { 287 logIfEnabled(FQCN, Level.DEBUG, null, msg, t); 288 } 289 290 /** 291 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 292 * 293 * @param message the message object to log. 294 */ 295 @Override 296 public void debug(final Object message) { 297 logIfEnabled(FQCN, Level.DEBUG, null, message, null); 298 } 299 300 /** 301 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 302 * <code>t</code> passed as parameter. 303 * 304 * @param message the message to log. 305 * @param t the exception to log, including its stack trace. 306 */ 307 @Override 308 public void debug(final Object message, final Throwable t) { 309 logIfEnabled(FQCN, Level.DEBUG, null, message, t); 310 } 311 312 /** 313 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 314 * 315 * @param message the message object to log. 316 */ 317 @Override 318 public void debug(final String message) { 319 logIfEnabled(FQCN, Level.DEBUG, null, message, (Throwable) null); 320 } 321 322 /** 323 * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level. 324 * 325 * @param message the message to log. 326 * @param params parameters to the message. 327 */ 328 @Override 329 public void debug(final String message, final Object... params) { 330 logIfEnabled(FQCN, Level.DEBUG, null, message, params); 331 } 332 333 /** 334 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 335 * <code>t</code> passed as parameter. 336 * 337 * @param message the message to log. 338 * @param t the exception to log, including its stack trace. 339 */ 340 @Override 341 public void debug(final String message, final Throwable t) { 342 logIfEnabled(FQCN, Level.DEBUG, null, message, t); 343 } 344 345 /** 346 * Logs entry to a method. 347 */ 348 @Override 349 public void entry() { 350 entry(FQCN); 351 } 352 353 /** 354 * Logs entry to a method. 355 * 356 * @param params The parameters to the method. 357 */ 358 @Override 359 public void entry(final Object... params) { 360 entry(FQCN, params); 361 } 362 363 /** 364 * Logs entry to a method with location information. 365 * 366 * @param fqcn The fully qualified class name of the <b>caller</b>. 367 * @param params The parameters to the method. 368 */ 369 protected void entry(final String fqcn, final Object... params) { 370 if (isEnabled(Level.TRACE, ENTRY_MARKER, (Object) null, null)) { 371 logIfEnabled(fqcn, Level.TRACE, ENTRY_MARKER, entryMsg(params.length, params), null); 372 } 373 } 374 375 protected Message entryMsg(final int count, final Object... params) { 376 if (count == 0) { 377 return messageFactory.newMessage("entry"); 378 } 379 final StringBuilder sb = new StringBuilder("entry params("); 380 int i = 0; 381 for (final Object parm : params) { 382 if (parm != null) { 383 sb.append(parm.toString()); 384 } else { 385 sb.append("null"); 386 } 387 if (++i < params.length) { 388 sb.append(", "); 389 } 390 } 391 sb.append(')'); 392 return messageFactory.newMessage(sb.toString()); 393 } 394 395 /** 396 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 397 * 398 * @param marker the marker data specific to this log statement 399 * @param msg the message string to be logged 400 */ 401 @Override 402 public void error(final Marker marker, final Message msg) { 403 logIfEnabled(FQCN, Level.ERROR, marker, msg, null); 404 } 405 406 /** 407 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 408 * 409 * @param marker the marker data specific to this log statement 410 * @param msg the message string to be logged 411 * @param t A Throwable or null. 412 */ 413 @Override 414 public void error(final Marker marker, final Message msg, final Throwable t) { 415 logIfEnabled(FQCN, Level.ERROR, marker, msg, t); 416 } 417 418 /** 419 * Logs a message object with the {@link Level#ERROR ERROR} level. 420 * 421 * @param marker the marker data specific to this log statement. 422 * @param message the message object to log. 423 */ 424 @Override 425 public void error(final Marker marker, final Object message) { 426 logIfEnabled(FQCN, Level.ERROR, marker, message, null); 427 } 428 429 /** 430 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 431 * <code>t</code> passed as parameter. 432 * 433 * @param marker the marker data specific to this log statement. 434 * @param message the message object to log. 435 * @param t the exception to log, including its stack trace. 436 */ 437 @Override 438 public void error(final Marker marker, final Object message, final Throwable t) { 439 logIfEnabled(FQCN, Level.ERROR, marker, message, t); 440 } 441 442 /** 443 * Logs a message object with the {@link Level#ERROR ERROR} level. 444 * 445 * @param marker the marker data specific to this log statement. 446 * @param message the message object to log. 447 */ 448 @Override 449 public void error(final Marker marker, final String message) { 450 logIfEnabled(FQCN, Level.ERROR, marker, message, (Throwable) null); 451 } 452 453 /** 454 * Logs a message with parameters at the {@link Level#ERROR ERROR} level. 455 * 456 * @param marker the marker data specific to this log statement. 457 * @param message the message to log. 458 * @param params parameters to the message. 459 */ 460 @Override 461 public void error(final Marker marker, final String message, final Object... params) { 462 logIfEnabled(FQCN, Level.ERROR, marker, message, params); 463 } 464 465 /** 466 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 467 * <code>t</code> passed as parameter. 468 * 469 * @param marker the marker data specific to this log statement. 470 * @param message the message object to log. 471 * @param t the exception to log, including its stack trace. 472 */ 473 @Override 474 public void error(final Marker marker, final String message, final Throwable t) { 475 logIfEnabled(FQCN, Level.ERROR, marker, message, t); 476 } 477 478 /** 479 * Logs the specified Message at the {@link Level#ERROR ERROR} level. 480 * 481 * @param msg the message to be logged 482 */ 483 @Override 484 public void error(final Message msg) { 485 logIfEnabled(FQCN, Level.ERROR, null, msg, null); 486 } 487 488 /** 489 * Logs the specified Message at the {@link Level#ERROR ERROR} level. 490 * 491 * @param msg the message to be logged 492 * @param t A Throwable or null. 493 */ 494 @Override 495 public void error(final Message msg, final Throwable t) { 496 logIfEnabled(FQCN, Level.ERROR, null, msg, t); 497 } 498 499 /** 500 * Logs a message object with the {@link Level#ERROR ERROR} level. 501 * 502 * @param message the message object to log. 503 */ 504 @Override 505 public void error(final Object message) { 506 logIfEnabled(FQCN, Level.ERROR, null, message, null); 507 } 508 509 /** 510 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 511 * <code>t</code> passed as parameter. 512 * 513 * @param message the message object to log. 514 * @param t the exception to log, including its stack trace. 515 */ 516 @Override 517 public void error(final Object message, final Throwable t) { 518 logIfEnabled(FQCN, Level.ERROR, null, message, t); 519 } 520 521 /** 522 * Logs a message object with the {@link Level#ERROR ERROR} level. 523 * 524 * @param message the message object to log. 525 */ 526 @Override 527 public void error(final String message) { 528 logIfEnabled(FQCN, Level.ERROR, null, message, (Throwable) null); 529 } 530 531 /** 532 * Logs a message with parameters at the {@link Level#ERROR ERROR} level. 533 * 534 * @param message the message to log. 535 * @param params parameters to the message. 536 */ 537 @Override 538 public void error(final String message, final Object... params) { 539 logIfEnabled(FQCN, Level.ERROR, null, message, params); 540 } 541 542 /** 543 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 544 * <code>t</code> passed as parameter. 545 * 546 * @param message the message object to log. 547 * @param t the exception to log, including its stack trace. 548 */ 549 @Override 550 public void error(final String message, final Throwable t) { 551 logIfEnabled(FQCN, Level.ERROR, null, message, t); 552 } 553 554 /** 555 * Logs exit from a method. 556 */ 557 @Override 558 public void exit() { 559 exit(FQCN, null); 560 } 561 562 /** 563 * Logs exiting from a method with the result. 564 * 565 * @param <R> The type of the parameter and object being returned. 566 * @param result The result being returned from the method call. 567 * @return the Throwable. 568 */ 569 @Override 570 public <R> R exit(final R result) { 571 return exit(FQCN, result); 572 } 573 574 /** 575 * Logs exiting from a method with the result and location information. 576 * 577 * @param fqcn The fully qualified class name of the <b>caller</b>. 578 * @param <R> The type of the parameter and object being returned. 579 * @param result The result being returned from the method call. 580 */ 581 protected <R> R exit(final String fqcn, final R result) { 582 if (isEnabled(Level.TRACE, EXIT_MARKER, (Object) null, null)) { 583 logIfEnabled(fqcn, Level.TRACE, EXIT_MARKER, exitMsg(result), null); 584 } 585 return result; 586 } 587 588 protected Message exitMsg(final Object result) { 589 if (result == null) { 590 return messageFactory.newMessage("exit"); 591 } 592 return messageFactory.newMessage("exit with(" + result + ')'); 593 } 594 595 /** 596 * Logs a message with the specific Marker at the FATAL level. 597 * 598 * @param marker the marker data specific to this log statement 599 * @param msg the message string to be logged 600 */ 601 @Override 602 public void fatal(final Marker marker, final Message msg) { 603 logIfEnabled(FQCN, Level.FATAL, marker, msg, null); 604 } 605 606 /** 607 * Logs a message with the specific Marker at the FATAL level. 608 * 609 * @param marker the marker data specific to this log statement 610 * @param msg the message string to be logged 611 * @param t A Throwable or null. 612 */ 613 @Override 614 public void fatal(final Marker marker, final Message msg, final Throwable t) { 615 logIfEnabled(FQCN, Level.FATAL, marker, msg, t); 616 } 617 618 /** 619 * Logs a message object with the {@link Level#FATAL FATAL} level. 620 * 621 * @param marker the marker data specific to this log statement. 622 * @param message the message object to log. 623 */ 624 @Override 625 public void fatal(final Marker marker, final Object message) { 626 logIfEnabled(FQCN, Level.FATAL, marker, message, null); 627 } 628 629 /** 630 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 631 * <code>t</code> passed as parameter. 632 * 633 * @param marker the marker data specific to this log statement. 634 * @param message the message object to log. 635 * @param t the exception to log, including its stack trace. 636 */ 637 @Override 638 public void fatal(final Marker marker, final Object message, final Throwable t) { 639 logIfEnabled(FQCN, Level.FATAL, marker, message, t); 640 } 641 642 /** 643 * Logs a message object with the {@link Level#FATAL FATAL} level. 644 * 645 * @param marker the marker data specific to this log statement. 646 * @param message the message object to log. 647 */ 648 @Override 649 public void fatal(final Marker marker, final String message) { 650 logIfEnabled(FQCN, Level.FATAL, marker, message, (Throwable) null); 651 } 652 653 /** 654 * Logs a message with parameters at the {@link Level#FATAL FATAL} level. 655 * 656 * @param marker the marker data specific to this log statement. 657 * @param message the message to log. 658 * @param params parameters to the message. 659 */ 660 @Override 661 public void fatal(final Marker marker, final String message, final Object... params) { 662 logIfEnabled(FQCN, Level.FATAL, marker, message, params); 663 } 664 665 /** 666 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 667 * <code>t</code> passed as parameter. 668 * 669 * @param marker the marker data specific to this log statement. 670 * @param message the message object to log. 671 * @param t the exception to log, including its stack trace. 672 */ 673 @Override 674 public void fatal(final Marker marker, final String message, final Throwable t) { 675 logIfEnabled(FQCN, Level.FATAL, marker, message, t); 676 } 677 678 /** 679 * Logs the specified Message at the FATAL level. 680 * 681 * @param msg the message to be logged 682 */ 683 @Override 684 public void fatal(final Message msg) { 685 logIfEnabled(FQCN, Level.FATAL, null, msg, null); 686 } 687 688 /** 689 * Logs the specified Message at the FATAL level. 690 * 691 * @param msg the message to be logged 692 * @param t A Throwable or null. 693 */ 694 @Override 695 public void fatal(final Message msg, final Throwable t) { 696 logIfEnabled(FQCN, Level.FATAL, null, msg, t); 697 } 698 699 /** 700 * Logs a message object with the {@link Level#FATAL FATAL} level. 701 * 702 * @param message the message object to log. 703 */ 704 @Override 705 public void fatal(final Object message) { 706 logIfEnabled(FQCN, Level.FATAL, null, message, null); 707 } 708 709 /** 710 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 711 * <code>t</code> passed as parameter. 712 * 713 * @param message the message object to log. 714 * @param t the exception to log, including its stack trace. 715 */ 716 @Override 717 public void fatal(final Object message, final Throwable t) { 718 logIfEnabled(FQCN, Level.FATAL, null, message, t); 719 } 720 721 /** 722 * Logs a message object with the {@link Level#FATAL FATAL} level. 723 * 724 * @param message the message object to log. 725 */ 726 @Override 727 public void fatal(final String message) { 728 logIfEnabled(FQCN, Level.FATAL, null, message, (Throwable) null); 729 } 730 731 /** 732 * Logs a message with parameters at the {@link Level#FATAL FATAL} level. 733 * 734 * @param message the message to log. 735 * @param params parameters to the message. 736 */ 737 @Override 738 public void fatal(final String message, final Object... params) { 739 logIfEnabled(FQCN, Level.FATAL, null, message, params); 740 } 741 742 /** 743 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 744 * <code>t</code> passed as parameter. 745 * 746 * @param message the message object to log. 747 * @param t the exception to log, including its stack trace. 748 */ 749 @Override 750 public void fatal(final String message, final Throwable t) { 751 logIfEnabled(FQCN, Level.FATAL, null, message, t); 752 } 753 754 /** 755 * Gets the message factory. 756 * 757 * @return the message factory. 758 */ 759 @Override 760 public MessageFactory getMessageFactory() { 761 return messageFactory; 762 } 763 764 /* 765 * (non-Javadoc) 766 * 767 * @see org.apache.logging.log4j.Logger#getName() 768 */ 769 @Override 770 public String getName() { 771 return name; 772 } 773 774 /** 775 * Logs a message with the specific Marker at the INFO level. 776 * 777 * @param marker the marker data specific to this log statement 778 * @param msg the message string to be logged 779 */ 780 @Override 781 public void info(final Marker marker, final Message msg) { 782 logIfEnabled(FQCN, Level.INFO, marker, msg, null); 783 } 784 785 /** 786 * Logs a message with the specific Marker at the INFO level. 787 * 788 * @param marker the marker data specific to this log statement 789 * @param msg the message string to be logged 790 * @param t A Throwable or null. 791 */ 792 @Override 793 public void info(final Marker marker, final Message msg, final Throwable t) { 794 logIfEnabled(FQCN, Level.INFO, marker, msg, t); 795 } 796 797 /** 798 * Logs a message object with the {@link Level#INFO INFO} level. 799 * 800 * @param marker the marker data specific to this log statement. 801 * @param message the message object to log. 802 */ 803 @Override 804 public void info(final Marker marker, final Object message) { 805 logIfEnabled(FQCN, Level.INFO, marker, message, null); 806 } 807 808 /** 809 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 810 * <code>t</code> passed as parameter. 811 * 812 * @param marker the marker data specific to this log statement. 813 * @param message the message object to log. 814 * @param t the exception to log, including its stack trace. 815 */ 816 @Override 817 public void info(final Marker marker, final Object message, final Throwable t) { 818 logIfEnabled(FQCN, Level.INFO, marker, message, t); 819 } 820 821 /** 822 * Logs a message object with the {@link Level#INFO INFO} level. 823 * 824 * @param marker the marker data specific to this log statement. 825 * @param message the message object to log. 826 */ 827 @Override 828 public void info(final Marker marker, final String message) { 829 logIfEnabled(FQCN, Level.INFO, marker, message, (Throwable) null); 830 } 831 832 /** 833 * Logs a message with parameters at the {@link Level#INFO INFO} level. 834 * 835 * @param marker the marker data specific to this log statement. 836 * @param message the message to log. 837 * @param params parameters to the message. 838 */ 839 @Override 840 public void info(final Marker marker, final String message, final Object... params) { 841 logIfEnabled(FQCN, Level.INFO, marker, message, params); 842 } 843 844 /** 845 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 846 * <code>t</code> passed as parameter. 847 * 848 * @param marker the marker data specific to this log statement. 849 * @param message the message object to log. 850 * @param t the exception to log, including its stack trace. 851 */ 852 @Override 853 public void info(final Marker marker, final String message, final Throwable t) { 854 logIfEnabled(FQCN, Level.INFO, marker, message, t); 855 } 856 857 /** 858 * Logs the specified Message at the INFO level. 859 * 860 * @param msg the message to be logged 861 */ 862 @Override 863 public void info(final Message msg) { 864 logIfEnabled(FQCN, Level.INFO, null, msg, null); 865 } 866 867 /** 868 * Logs the specified Message at the INFO level. 869 * 870 * @param msg the message to be logged 871 * @param t A Throwable or null. 872 */ 873 @Override 874 public void info(final Message msg, final Throwable t) { 875 logIfEnabled(FQCN, Level.INFO, null, msg, t); 876 } 877 878 /** 879 * Logs a message object with the {@link Level#INFO INFO} level. 880 * 881 * @param message the message object to log. 882 */ 883 @Override 884 public void info(final Object message) { 885 logIfEnabled(FQCN, Level.INFO, null, message, null); 886 } 887 888 /** 889 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 890 * <code>t</code> passed as parameter. 891 * 892 * @param message the message object to log. 893 * @param t the exception to log, including its stack trace. 894 */ 895 @Override 896 public void info(final Object message, final Throwable t) { 897 logIfEnabled(FQCN, Level.INFO, null, message, t); 898 } 899 900 /** 901 * Logs a message object with the {@link Level#INFO INFO} level. 902 * 903 * @param message the message object to log. 904 */ 905 @Override 906 public void info(final String message) { 907 logIfEnabled(FQCN, Level.INFO, null, message, (Throwable) null); 908 } 909 910 /** 911 * Logs a message with parameters at the {@link Level#INFO INFO} level. 912 * 913 * @param message the message to log. 914 * @param params parameters to the message. 915 */ 916 @Override 917 public void info(final String message, final Object... params) { 918 logIfEnabled(FQCN, Level.INFO, null, message, params); 919 } 920 921 /** 922 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 923 * <code>t</code> passed as parameter. 924 * 925 * @param message the message object to log. 926 * @param t the exception to log, including its stack trace. 927 */ 928 @Override 929 public void info(final String message, final Throwable t) { 930 logIfEnabled(FQCN, Level.INFO, null, message, t); 931 } 932 933 /** 934 * Checks whether this Logger is enabled for the DEBUG Level. 935 * 936 * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise. 937 */ 938 @Override 939 public boolean isDebugEnabled() { 940 return isEnabled(Level.DEBUG, null, null); 941 } 942 943 /** 944 * Checks whether this Logger is enabled for the DEBUG Level. 945 * 946 * @param marker The marker data. 947 * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise. 948 */ 949 @Override 950 public boolean isDebugEnabled(final Marker marker) { 951 return isEnabled(Level.DEBUG, marker, (Object) null, null); 952 } 953 954 /** 955 * Checks whether this Logger is enabled for the the given Level. 956 * <p> 957 * Note that passing in {@link Level#OFF OFF} always returns {@code true}. 958 * </p> 959 * 960 * @param level the level to check 961 * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise. 962 */ 963 @Override 964 public boolean isEnabled(final Level level) { 965 return isEnabled(level, null, (Object) null, null); 966 } 967 968 /** 969 * Checks whether this Logger is enabled for the the given Level. 970 * <p> 971 * Note that passing in {@link Level#OFF OFF} always returns {@code true}. 972 * </p> 973 * 974 * @param level the level to check 975 * @param marker A Marker or null. 976 * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise. 977 */ 978 @Override 979 public boolean isEnabled(final Level level, final Marker marker) { 980 return isEnabled(level, marker, (Object) null, null); 981 } 982 983 /** 984 * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level. 985 * 986 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false} 987 * otherwise. 988 */ 989 @Override 990 public boolean isErrorEnabled() { 991 return isEnabled(Level.ERROR, null, (Object) null, null); 992 } 993 994 /** 995 * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level. 996 * 997 * @param marker The marker data. 998 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false} 999 * otherwise. 1000 */ 1001 @Override 1002 public boolean isErrorEnabled(final Marker marker) { 1003 return isEnabled(Level.ERROR, marker, (Object) null, null); 1004 } 1005 1006 /** 1007 * Checks whether this Logger is enabled for the FATAL Level. 1008 * 1009 * @return boolean - {@code true} if this Logger is enabled for level FATAL, {@code false} otherwise. 1010 */ 1011 @Override 1012 public boolean isFatalEnabled() { 1013 return isEnabled(Level.FATAL, null, (Object) null, null); 1014 } 1015 1016 /** 1017 * Checks whether this Logger is enabled for the FATAL Level. 1018 * 1019 * @param marker The marker data. 1020 * @return boolean - {@code true} if this Logger is enabled for level FATAL, {@code false} otherwise. 1021 */ 1022 @Override 1023 public boolean isFatalEnabled(final Marker marker) { 1024 return isEnabled(Level.FATAL, marker, (Object) null, null); 1025 } 1026 1027 /** 1028 * Checks whether this Logger is enabled for the INFO Level. 1029 * 1030 * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise. 1031 */ 1032 @Override 1033 public boolean isInfoEnabled() { 1034 return isEnabled(Level.INFO, null, (Object) null, null); 1035 } 1036 1037 /** 1038 * Checks whether this Logger is enabled for the INFO Level. 1039 * 1040 * @param marker The marker data. 1041 * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise. 1042 */ 1043 @Override 1044 public boolean isInfoEnabled(final Marker marker) { 1045 return isEnabled(Level.INFO, marker, (Object) null, null); 1046 } 1047 1048 /** 1049 * Checks whether this Logger is enabled for the TRACE Level. 1050 * 1051 * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise. 1052 */ 1053 @Override 1054 public boolean isTraceEnabled() { 1055 return isEnabled(Level.TRACE, null, (Object) null, null); 1056 } 1057 1058 /** 1059 * Checks whether this Logger is enabled for the TRACE Level. 1060 * 1061 * @param marker The marker data. 1062 * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise. 1063 */ 1064 @Override 1065 public boolean isTraceEnabled(final Marker marker) { 1066 return isEnabled(Level.TRACE, marker, (Object) null, null); 1067 } 1068 1069 /** 1070 * Checks whether this Logger is enabled for the WARN Level. 1071 * 1072 * @return boolean - {@code true} if this Logger is enabled for level WARN, {@code false} otherwise. 1073 */ 1074 @Override 1075 public boolean isWarnEnabled() { 1076 return isEnabled(Level.WARN, null, (Object) null, null); 1077 } 1078 1079 /** 1080 * Checks whether this Logger is enabled for the WARN Level. 1081 * 1082 * @param marker The marker data. 1083 * @return boolean - {@code true} if this Logger is enabled for level WARN, {@code false} otherwise. 1084 */ 1085 @Override 1086 public boolean isWarnEnabled(final Marker marker) { 1087 return isEnabled(Level.WARN, marker, (Object) null, null); 1088 } 1089 1090 /** 1091 * Logs a message with the specific Marker at the given level. 1092 * 1093 * @param level the logging level 1094 * @param marker the marker data specific to this log statement 1095 * @param msg the message string to be logged 1096 */ 1097 @Override 1098 public void log(final Level level, final Marker marker, final Message msg) { 1099 logIfEnabled(FQCN, level, marker, msg, (Throwable) null); 1100 } 1101 1102 /** 1103 * Logs a message with the specific Marker at the given level. 1104 * 1105 * @param level the logging level 1106 * @param marker the marker data specific to this log statement. 1107 * @param msg the message string to be logged 1108 * @param t A Throwable or null. 1109 */ 1110 @Override 1111 public void log(final Level level, final Marker marker, final Message msg, final Throwable t) { 1112 logIfEnabled(FQCN, level, marker, msg, t); 1113 } 1114 1115 /** 1116 * Logs a message object with the given level. 1117 * 1118 * @param level the logging level 1119 * @param marker the marker data specific to this log statement. 1120 * @param message the message object to log. 1121 */ 1122 @Override 1123 public void log(final Level level, final Marker marker, final Object message) { 1124 logIfEnabled(FQCN, level, marker, message, (Throwable) null); 1125 } 1126 1127 /** 1128 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 1129 * parameter. 1130 * 1131 * @param level the logging level 1132 * @param marker the marker data specific to this log statement. 1133 * @param message the message to log. 1134 * @param t the exception to log, including its stack trace. 1135 */ 1136 @Override 1137 public void log(final Level level, final Marker marker, final Object message, final Throwable t) { 1138 if (isEnabled(level, marker, message, t)) { 1139 logMessage(FQCN, level, marker, message, t); 1140 } 1141 } 1142 1143 /** 1144 * Logs a message object with the given level. 1145 * 1146 * @param level the logging level 1147 * @param marker the marker data specific to this log statement. 1148 * @param message the message object to log. 1149 */ 1150 @Override 1151 public void log(final Level level, final Marker marker, final String message) { 1152 logIfEnabled(FQCN, level, marker, message, (Throwable) null); 1153 } 1154 1155 /** 1156 * Logs a message with parameters at the given level. 1157 * 1158 * @param level the logging level 1159 * @param marker the marker data specific to this log statement. 1160 * @param message the message to log. 1161 * @param params parameters to the message. 1162 */ 1163 @Override 1164 public void log(final Level level, final Marker marker, final String message, final Object... params) { 1165 logIfEnabled(FQCN, level, marker, message, params); 1166 } 1167 1168 /** 1169 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 1170 * parameter. 1171 * 1172 * @param level the logging level 1173 * @param marker the marker data specific to this log statement. 1174 * @param message the message to log. 1175 * @param t the exception to log, including its stack trace. 1176 */ 1177 @Override 1178 public void log(final Level level, final Marker marker, final String message, final Throwable t) { 1179 logIfEnabled(FQCN, level, marker, message, t); 1180 } 1181 1182 /** 1183 * Logs the specified Message at the given level. 1184 * 1185 * @param level the logging level 1186 * @param msg the message to be logged 1187 */ 1188 @Override 1189 public void log(final Level level, final Message msg) { 1190 logIfEnabled(FQCN, level, null, msg, null); 1191 } 1192 1193 /** 1194 * Logs the specified Message at the given level. 1195 * 1196 * @param level the logging level 1197 * @param msg the message to be logged 1198 * @param t A Throwable or null. 1199 */ 1200 @Override 1201 public void log(final Level level, final Message msg, final Throwable t) { 1202 logIfEnabled(FQCN, level, null, msg, t); 1203 } 1204 1205 /** 1206 * Logs a message object with the given level. 1207 * 1208 * @param level the logging level 1209 * @param message the message object to log. 1210 */ 1211 @Override 1212 public void log(final Level level, final Object message) { 1213 logIfEnabled(FQCN, level, null, message, null); 1214 } 1215 1216 /** 1217 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 1218 * parameter. 1219 * 1220 * @param level the logging level 1221 * @param message the message to log. 1222 * @param t the exception to log, including its stack trace. 1223 */ 1224 @Override 1225 public void log(final Level level, final Object message, final Throwable t) { 1226 logIfEnabled(FQCN, level, null, message, t); 1227 } 1228 1229 /** 1230 * Logs a message object with the given level. 1231 * 1232 * @param level the logging level 1233 * @param message the message object to log. 1234 */ 1235 @Override 1236 public void log(final Level level, final String message) { 1237 logIfEnabled(FQCN, level, null, message, (Throwable) null); 1238 } 1239 1240 /** 1241 * Logs a message with parameters at the given level. 1242 * 1243 * @param level the logging level 1244 * @param message the message to log. 1245 * @param params parameters to the message. 1246 */ 1247 @Override 1248 public void log(final Level level, final String message, final Object... params) { 1249 logIfEnabled(FQCN, level, null, message, params); 1250 } 1251 1252 /** 1253 * Logs a message at the given level including the stack trace of the {@link Throwable} 1254 * <code>t</code> passed as parameter. 1255 * 1256 * @param level the logging level 1257 * @param message the message to log. 1258 * @param t the exception to log, including its stack trace. 1259 */ 1260 @Override 1261 public void log(final Level level, final String message, final Throwable t) { 1262 logIfEnabled(FQCN, level, null, message, t); 1263 } 1264 1265 /* 1266 * (non-Javadoc) 1267 * @see org.apache.logging.log4j.spi.ExtendedLogger#logIfEnabled(java.lang.String, org.apache.logging.log4j.Level, 1268 * org.apache.logging.log4j.Marker, org.apache.logging.log4j.message.Message, java.lang.Throwable) 1269 */ 1270 @Override 1271 public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final Message msg, 1272 final Throwable t) { 1273 if (isEnabled(level, marker, msg, t)) { 1274 logMessage(fqcn, level, marker, msg, t); 1275 } 1276 } 1277 1278 /* 1279 * (non-Javadoc) 1280 * @see org.apache.logging.log4j.spi.ExtendedLogger#logIfEnabled(java.lang.String, org.apache.logging.log4j.Level, 1281 * org.apache.logging.log4j.Marker, java.lang.Object, java.lang.Throwable) 1282 */ 1283 @Override 1284 public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final Object message, 1285 final Throwable t) { 1286 if (isEnabled(level, marker, message, t)) { 1287 logMessage(fqcn, level, marker, message, t); 1288 } 1289 } 1290 1291 /* 1292 * (non-Javadoc) 1293 * @see org.apache.logging.log4j.spi.ExtendedLogger#logIfEnabled(java.lang.String, org.apache.logging.log4j.Level, 1294 * org.apache.logging.log4j.Marker, java.lang.String) 1295 */ 1296 @Override 1297 public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final String message) { 1298 if (isEnabled(level, marker, message)) { 1299 logMessage(fqcn, level, marker, message); 1300 } 1301 } 1302 1303 /* 1304 * (non-Javadoc) 1305 * @see org.apache.logging.log4j.spi.ExtendedLogger#logIfEnabled(java.lang.String, org.apache.logging.log4j.Level, 1306 * org.apache.logging.log4j.Marker, java.lang.String, java.lang.Object[]) 1307 */ 1308 @Override 1309 public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final String message, 1310 final Object... params) { 1311 if (isEnabled(level, marker, message, params)) { 1312 logMessage(fqcn, level, marker, message, params); 1313 } 1314 } 1315 1316 /* 1317 * (non-Javadoc) 1318 * @see org.apache.logging.log4j.spi.ExtendedLogger#logIfEnabled(java.lang.String, org.apache.logging.log4j.Level, 1319 * org.apache.logging.log4j.Marker, java.lang.String, java.lang.Throwable) 1320 */ 1321 @Override 1322 public void logIfEnabled(final String fqcn, final Level level, final Marker marker, final String message, 1323 final Throwable t) { 1324 if (isEnabled(level, marker, message, t)) { 1325 logMessage(fqcn, level, marker, message, t); 1326 } 1327 } 1328 1329 protected void logMessage(final String fqcn, final Level level, final Marker marker, final Object message, 1330 final Throwable t) { 1331 logMessage(fqcn, level, marker, messageFactory.newMessage(message), t); 1332 } 1333 1334 protected void logMessage(final String fqcn, final Level level, final Marker marker, final String message, 1335 final Throwable t) { 1336 logMessage(fqcn, level, marker, messageFactory.newMessage(message), t); 1337 } 1338 1339 protected void logMessage(final String fqcn, final Level level, final Marker marker, final String message) { 1340 final Message msg = messageFactory.newMessage(message); 1341 logMessage(fqcn, level, marker, msg, msg.getThrowable()); 1342 } 1343 1344 protected void logMessage(final String fqcn, final Level level, final Marker marker, final String message, 1345 final Object... params) { 1346 final Message msg = messageFactory.newMessage(message, params); 1347 logMessage(fqcn, level, marker, msg, msg.getThrowable()); 1348 } 1349 1350 /** 1351 * Logs a formatted message using the specified format string and arguments. 1352 * 1353 * @param level The logging Level. 1354 * @param marker the marker data specific to this log statement. 1355 * @param format The format String. 1356 * @param params Arguments specified by the format. 1357 */ 1358 @Override 1359 public void printf(Level level, Marker marker, String format, Object... params) { 1360 if (isEnabled(level, marker, format, params)) { 1361 Message msg = new StringFormattedMessage(format, params); 1362 logMessage(FQCN, level, marker, msg, msg.getThrowable()); 1363 } 1364 } 1365 1366 /** 1367 * Logs a formatted message using the specified format string and arguments. 1368 * 1369 * @param level The logging Level. 1370 * @param format The format String. 1371 * @param params Arguments specified by the format. 1372 */ 1373 @Override 1374 public void printf(Level level, String format, Object... params) { 1375 if (isEnabled(level, null, format, params)) { 1376 Message msg = new StringFormattedMessage(format, params); 1377 logMessage(FQCN, level, null, msg, msg.getThrowable()); 1378 } 1379 } 1380 1381 /** 1382 * Logs a Throwable to be thrown. 1383 * 1384 * @param <T> the type of the Throwable. 1385 * @param t The Throwable. 1386 * @return the Throwable. 1387 */ 1388 @Override 1389 public <T extends Throwable> T throwing(final T t) { 1390 return throwing(FQCN, Level.ERROR, t); 1391 } 1392 1393 /** 1394 * Logs a Throwable to be thrown. 1395 * 1396 * @param <T> the type of the Throwable. 1397 * @param level The logging Level. 1398 * @param t The Throwable. 1399 * @return the Throwable. 1400 */ 1401 @Override 1402 public <T extends Throwable> T throwing(final Level level, final T t) { 1403 return throwing(FQCN, level, t); 1404 } 1405 1406 /** 1407 * Logs a Throwable to be thrown. 1408 * 1409 * @param <T> the type of the Throwable. 1410 * @param level The logging Level. 1411 * @param t The Throwable. 1412 * @return the Throwable. 1413 */ 1414 protected <T extends Throwable> T throwing(final String fqcn, final Level level, final T t) { 1415 if (isEnabled(level, THROWING_MARKER, (Object) null, null)) { 1416 logMessage(fqcn, level, THROWING_MARKER, throwingMsg(t), t); 1417 } 1418 return t; 1419 } 1420 1421 protected Message throwingMsg(final Throwable t) { 1422 return messageFactory.newMessage(THROWING); 1423 } 1424 1425 /** 1426 * Logs a message with the specific Marker at the TRACE level. 1427 * 1428 * @param marker the marker data specific to this log statement. 1429 * @param msg the message string to be logged 1430 */ 1431 @Override 1432 public void trace(final Marker marker, final Message msg) { 1433 logIfEnabled(FQCN, Level.TRACE, marker, msg, null); 1434 } 1435 1436 /** 1437 * Logs a message with the specific Marker at the TRACE level. 1438 * 1439 * @param marker the marker data specific to this log statement. 1440 * @param msg the message string to be logged 1441 * @param t A Throwable or null. 1442 */ 1443 @Override 1444 public void trace(final Marker marker, final Message msg, final Throwable t) { 1445 logIfEnabled(FQCN, Level.TRACE, marker, msg, t); 1446 } 1447 1448 /** 1449 * Logs a message object with the {@link Level#TRACE TRACE} level. 1450 * 1451 * @param marker the marker data specific to this log statement. 1452 * @param message the message object to log. 1453 */ 1454 @Override 1455 public void trace(final Marker marker, final Object message) { 1456 logIfEnabled(FQCN, Level.TRACE, marker, message, null); 1457 } 1458 1459 /** 1460 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1461 * <code>t</code> passed as parameter. 1462 * <p/> 1463 * <p> 1464 * See {@link #debug(String)} form for more detailed information. 1465 * </p> 1466 * 1467 * @param marker the marker data specific to this log statement. 1468 * @param message the message object to log. 1469 * @param t the exception to log, including its stack trace. 1470 */ 1471 @Override 1472 public void trace(final Marker marker, final Object message, final Throwable t) { 1473 logIfEnabled(FQCN, Level.TRACE, marker, message, t); 1474 } 1475 1476 /** 1477 * Logs a message object with the {@link Level#TRACE TRACE} level. 1478 * 1479 * @param marker the marker data specific to this log statement. 1480 * @param message the message object to log. 1481 */ 1482 @Override 1483 public void trace(final Marker marker, final String message) { 1484 logIfEnabled(FQCN, Level.TRACE, marker, message, (Throwable) null); 1485 } 1486 1487 /** 1488 * Logs a message with parameters at the {@link Level#TRACE TRACE} level. 1489 * 1490 * @param marker the marker data specific to this log statement. 1491 * @param message the message to log. 1492 * @param params parameters to the message. 1493 */ 1494 @Override 1495 public void trace(final Marker marker, final String message, final Object... params) { 1496 logIfEnabled(FQCN, Level.TRACE, marker, message, params); 1497 } 1498 1499 /** 1500 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1501 * <code>t</code> passed as parameter. 1502 * <p/> 1503 * <p> 1504 * See {@link #debug(String)} form for more detailed information. 1505 * </p> 1506 * 1507 * @param marker the marker data specific to this log statement. 1508 * @param message the message object to log. 1509 * @param t the exception to log, including its stack trace. 1510 */ 1511 @Override 1512 public void trace(final Marker marker, final String message, final Throwable t) { 1513 logIfEnabled(FQCN, Level.TRACE, marker, message, t); 1514 } 1515 1516 /** 1517 * Logs the specified Message at the TRACE level. 1518 * 1519 * @param msg the message to be logged 1520 */ 1521 @Override 1522 public void trace(final Message msg) { 1523 logIfEnabled(FQCN, Level.TRACE, null, msg, null); 1524 } 1525 1526 /** 1527 * Logs the specified Message at the TRACE level. 1528 * 1529 * @param msg the message to be logged 1530 * @param t A Throwable or null. 1531 */ 1532 @Override 1533 public void trace(final Message msg, final Throwable t) { 1534 logIfEnabled(FQCN, Level.TRACE, null, msg, t); 1535 } 1536 1537 /** 1538 * Logs a message object with the {@link Level#TRACE TRACE} level. 1539 * 1540 * @param message the message object to log. 1541 */ 1542 @Override 1543 public void trace(final Object message) { 1544 logIfEnabled(FQCN, Level.TRACE, null, message, null); 1545 } 1546 1547 /** 1548 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1549 * <code>t</code> passed as parameter. 1550 * <p/> 1551 * <p> 1552 * See {@link #debug(String)} form for more detailed information. 1553 * </p> 1554 * 1555 * @param message the message object to log. 1556 * @param t the exception to log, including its stack trace. 1557 */ 1558 @Override 1559 public void trace(final Object message, final Throwable t) { 1560 logIfEnabled(FQCN, Level.TRACE, null, message, t); 1561 } 1562 1563 /** 1564 * Logs a message object with the {@link Level#TRACE TRACE} level. 1565 * 1566 * @param message the message object to log. 1567 */ 1568 @Override 1569 public void trace(final String message) { 1570 logIfEnabled(FQCN, Level.TRACE, null, message, (Throwable) null); 1571 } 1572 1573 /** 1574 * Logs a message with parameters at the {@link Level#TRACE TRACE} level. 1575 * 1576 * @param message the message to log. 1577 * @param params parameters to the message. 1578 */ 1579 @Override 1580 public void trace(final String message, final Object... params) { 1581 logIfEnabled(FQCN, Level.TRACE, null, message, params); 1582 } 1583 1584 /** 1585 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1586 * <code>t</code> passed as parameter. 1587 * <p/> 1588 * <p> 1589 * See {@link #debug(String)} form for more detailed information. 1590 * </p> 1591 * 1592 * @param message the message object to log. 1593 * @param t the exception to log, including its stack trace. 1594 */ 1595 @Override 1596 public void trace(final String message, final Throwable t) { 1597 logIfEnabled(FQCN, Level.TRACE, null, message, t); 1598 } 1599 1600 /** 1601 * Logs a message with the specific Marker at the WARN level. 1602 * 1603 * @param marker the marker data specific to this log statement 1604 * @param msg the message string to be logged 1605 */ 1606 @Override 1607 public void warn(final Marker marker, final Message msg) { 1608 logIfEnabled(FQCN, Level.WARN, marker, msg, null); 1609 } 1610 1611 /** 1612 * Logs a message with the specific Marker at the WARN level. 1613 * 1614 * @param marker the marker data specific to this log statement 1615 * @param msg the message string to be logged 1616 * @param t A Throwable or null. 1617 */ 1618 @Override 1619 public void warn(final Marker marker, final Message msg, final Throwable t) { 1620 logIfEnabled(FQCN, Level.WARN, marker, msg, t); 1621 } 1622 1623 /** 1624 * Logs a message object with the {@link Level#WARN WARN} level. 1625 * 1626 * @param marker the marker data specific to this log statement. 1627 * @param message the message object to log. 1628 */ 1629 @Override 1630 public void warn(final Marker marker, final Object message) { 1631 logIfEnabled(FQCN, Level.WARN, marker, message, null); 1632 } 1633 1634 /* 1635 * Instead of one single method with Object... declared the following methods explicitly specify parameters because 1636 * they perform dramatically better than having the JVM convert them to an array. 1637 */ 1638 1639 /** 1640 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1641 * <code>t</code> passed as parameter. 1642 * 1643 * @param marker the marker data specific to this log statement. 1644 * @param message the message object to log. 1645 * @param t the exception to log, including its stack trace. 1646 */ 1647 @Override 1648 public void warn(final Marker marker, final Object message, final Throwable t) { 1649 logIfEnabled(FQCN, Level.WARN, marker, message, t); 1650 } 1651 1652 /** 1653 * Logs a message object with the {@link Level#WARN WARN} level. 1654 * 1655 * @param marker the marker data specific to this log statement. 1656 * @param message the message object to log. 1657 */ 1658 @Override 1659 public void warn(final Marker marker, final String message) { 1660 logIfEnabled(FQCN, Level.WARN, marker, message, (Throwable) null); 1661 } 1662 1663 /** 1664 * Logs a message with parameters at the {@link Level#WARN WARN} level. 1665 * 1666 * @param marker the marker data specific to this log statement. 1667 * @param message the message to log. 1668 * @param params parameters to the message. 1669 */ 1670 @Override 1671 public void warn(final Marker marker, final String message, final Object... params) { 1672 logIfEnabled(FQCN, Level.WARN, marker, message, params); 1673 } 1674 1675 /** 1676 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1677 * <code>t</code> passed as parameter. 1678 * 1679 * @param marker the marker data specific to this log statement. 1680 * @param message the message object to log. 1681 * @param t the exception to log, including its stack trace. 1682 */ 1683 @Override 1684 public void warn(final Marker marker, final String message, final Throwable t) { 1685 logIfEnabled(FQCN, Level.WARN, marker, message, t); 1686 } 1687 1688 /** 1689 * Logs the specified Message at the WARN level. 1690 * 1691 * @param msg the message to be logged 1692 */ 1693 @Override 1694 public void warn(final Message msg) { 1695 logIfEnabled(FQCN, Level.WARN, null, msg, null); 1696 } 1697 1698 /** 1699 * Logs the specified Message at the WARN level. 1700 * 1701 * @param msg the message to be logged 1702 * @param t A Throwable or null. 1703 */ 1704 @Override 1705 public void warn(final Message msg, final Throwable t) { 1706 logIfEnabled(FQCN, Level.WARN, null, msg, t); 1707 } 1708 1709 /** 1710 * Logs a message object with the {@link Level#WARN WARN} level. 1711 * 1712 * @param message the message object to log. 1713 */ 1714 @Override 1715 public void warn(final Object message) { 1716 logIfEnabled(FQCN, Level.WARN, null, message, null); 1717 } 1718 1719 /** 1720 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1721 * <code>t</code> passed as parameter. 1722 * 1723 * @param message the message object to log. 1724 * @param t the exception to log, including its stack trace. 1725 */ 1726 @Override 1727 public void warn(final Object message, final Throwable t) { 1728 logIfEnabled(FQCN, Level.WARN, null, message, t); 1729 } 1730 1731 /** 1732 * Logs a message object with the {@link Level#WARN WARN} level. 1733 * 1734 * @param message the message object to log. 1735 */ 1736 @Override 1737 public void warn(final String message) { 1738 logIfEnabled(FQCN, Level.WARN, null, message, (Throwable) null); 1739 } 1740 1741 /** 1742 * Logs a message with parameters at the {@link Level#WARN WARN} level. 1743 * 1744 * @param message the message to log. 1745 * @param params parameters to the message. 1746 */ 1747 @Override 1748 public void warn(final String message, final Object... params) { 1749 logIfEnabled(FQCN, Level.WARN, null, message, params); 1750 } 1751 1752 /** 1753 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1754 * <code>t</code> passed as parameter. 1755 * 1756 * @param message the message object to log. 1757 * @param t the exception to log, including its stack trace. 1758 */ 1759 @Override 1760 public void warn(final String message, final Throwable t) { 1761 logIfEnabled(FQCN, Level.WARN, null, message, t); 1762 } 1763 1764 }