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 */ 017package org.apache.logging.log4j; 018 019import org.apache.logging.log4j.message.Message; 020import org.apache.logging.log4j.message.MessageFactory; 021 022/** 023 * This is the central interface in the log4j package. Most logging operations, except configuration, are done through 024 * this interface. 025 * 026 * <p> 027 * The canonical way to obtain a Logger for a class is through {@link LogManager#getLogger()}. Typically, each class 028 * gets its own Logger named after its fully qualified class name (the default Logger name when obtained through the 029 * {@link LogManager#getLogger()} method). Thus, the simplest way to use this would be like so: 030 * </p> 031 * <pre> 032 * public class MyClass { 033 * private static final Logger LOGGER = LogManager.getLogger(); 034 * // ... 035 * } 036 * </pre> 037 * <p> 038 * For ease of filtering, searching, sorting, etc., it is generally a good idea to create Loggers for each class rather 039 * than sharing Loggers. Instead, {@link Marker Markers} should be used for shared, filterable identification. 040 * </p> 041 * <p> 042 * For service provider implementations, it is recommended to extend the 043 * {@link org.apache.logging.log4j.spi.AbstractLogger} class rather than implementing this interface directly. 044 * </p> 045 */ 046public interface Logger { 047 048 /** 049 * Logs an exception or error that has been caught to a specific logging level. 050 * 051 * @param level The logging Level. 052 * @param t The Throwable. 053 */ 054 void catching(Level level, Throwable t); 055 056 /** 057 * Logs an exception or error that has been caught. Normally, one may wish to provide additional information with 058 * an exception while logging it; in these cases, one would not use this method. In other cases where simply 059 * logging the fact that an exception was swallowed somewhere (e.g., at the top of the stack trace in a 060 * {@code main()} method), this method is ideal for it. 061 * 062 * @param t The Throwable. 063 */ 064 void catching(Throwable t); 065 066 /** 067 * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level. 068 * 069 * @param marker the marker data specific to this log statement 070 * @param msg the message string to be logged 071 */ 072 void debug(Marker marker, Message msg); 073 074 /** 075 * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level. 076 * 077 * @param marker the marker data specific to this log statement 078 * @param msg the message string to be logged 079 * @param t A Throwable or null. 080 */ 081 void debug(Marker marker, Message msg, Throwable t); 082 083 /** 084 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 085 * 086 * @param marker the marker data specific to this log statement 087 * @param message the message object to log. 088 */ 089 void debug(Marker marker, Object message); 090 091 /** 092 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 093 * <code>t</code> passed as parameter. 094 * 095 * @param marker the marker data specific to this log statement 096 * @param message the message to log. 097 * @param t the exception to log, including its stack trace. 098 */ 099 void debug(Marker marker, Object message, Throwable t); 100 101 /** 102 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 103 * 104 * @param marker the marker data specific to this log statement 105 * @param message the message object to log. 106 */ 107 void debug(Marker marker, String message); 108 109 /** 110 * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level. 111 * 112 * @param marker the marker data specific to this log statement 113 * @param message the message to log; the format depends on the message factory. 114 * @param params parameters to the message. 115 * @see #getMessageFactory() 116 */ 117 void debug(Marker marker, String message, Object... params); 118 119 /** 120 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 121 * <code>t</code> passed as parameter. 122 * 123 * @param marker the marker data specific to this log statement 124 * @param message the message to log. 125 * @param t the exception to log, including its stack trace. 126 */ 127 void debug(Marker marker, String message, Throwable t); 128 129 /** 130 * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level. 131 * 132 * @param msg the message string to be logged 133 */ 134 void debug(Message msg); 135 136 /** 137 * Logs a message with the specific Marker at the {@link Level#DEBUG DEBUG} level. 138 * 139 * @param msg the message string to be logged 140 * @param t A Throwable or null. 141 */ 142 void debug(Message msg, Throwable t); 143 144 /** 145 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 146 * 147 * @param message the message object to log. 148 */ 149 void debug(Object message); 150 151 /** 152 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 153 * <code>t</code> passed as parameter. 154 * 155 * @param message the message to log. 156 * @param t the exception to log, including its stack trace. 157 */ 158 void debug(Object message, Throwable t); 159 160 /** 161 * Logs a message object with the {@link Level#DEBUG DEBUG} level. 162 * 163 * @param message the message string to log. 164 */ 165 void debug(String message); 166 167 /** 168 * Logs a message with parameters at the {@link Level#DEBUG DEBUG} level. 169 * 170 * @param message the message to log; the format depends on the message factory. 171 * @param params parameters to the message. 172 * @see #getMessageFactory() 173 */ 174 void debug(String message, Object... params); 175 176 /** 177 * Logs a message at the {@link Level#DEBUG DEBUG} level including the stack trace of the {@link Throwable} 178 * <code>t</code> passed as parameter. 179 * 180 * @param message the message to log. 181 * @param t the exception to log, including its stack trace. 182 */ 183 void debug(String message, Throwable t); 184 185 /** 186 * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not be 187 * logged. 188 */ 189 void entry(); 190 191 /** 192 * Logs entry to a method along with its parameters. For example, 193 * <pre> 194 * public void doSomething(String foo, int bar) { 195 * LOGGER.entry(foo, bar); 196 * // do something 197 * } 198 * </pre> 199 * <p>The use of methods such as this are more effective when combined with aspect-oriented programming or other 200 * bytecode manipulation tools. It can be rather tedious (and messy) to use this type of method manually.</p> 201 * 202 * @param params The parameters to the method. 203 * TODO Use of varargs results in array creation which can be a substantial portion of no-op case. LogMF/LogSF 204 * provides several overrides to avoid vararg except in edge cases. (RG) LogMF and LogSF implement these in 205 * LogXF which calls logger.callAppenders. callAppenders is part of the implementation and cannot be used by 206 * the API. Adding more methods here and in AbstractLogger is sufficient. 207 */ 208 void entry(Object... params); 209 210 /** 211 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 212 * 213 * @param marker the marker data specific to this log statement 214 * @param msg the message string to be logged 215 */ 216 void error(Marker marker, Message msg); 217 218 /** 219 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 220 * 221 * @param marker the marker data specific to this log statement 222 * @param msg the message string to be logged 223 * @param t A Throwable or null. 224 */ 225 void error(Marker marker, Message msg, Throwable t); 226 227 /** 228 * Logs a message object with the {@link Level#ERROR ERROR} level. 229 * 230 * @param marker the marker data specific to this log statement. 231 * @param message the message object to log. 232 */ 233 void error(Marker marker, Object message); 234 235 /** 236 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 237 * <code>t</code> passed as parameter. 238 * 239 * @param marker the marker data specific to this log statement. 240 * @param message the message object to log. 241 * @param t the exception to log, including its stack trace. 242 */ 243 void error(Marker marker, Object message, Throwable t); 244 245 /** 246 * Logs a message object with the {@link Level#ERROR ERROR} level. 247 * 248 * @param marker the marker data specific to this log statement. 249 * @param message the message object to log. 250 */ 251 void error(Marker marker, String message); 252 253 /** 254 * Logs a message with parameters at the {@link Level#ERROR ERROR} level. 255 * 256 * @param marker the marker data specific to this log statement. 257 * @param message the message to log; the format depends on the message factory. 258 * @param params parameters to the message. 259 * @see #getMessageFactory() 260 * 261 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 262 * array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be 263 * misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 264 * 1, 2 or 3 parameters. 265 */ 266 void error(Marker marker, String message, Object... params); 267 268 /** 269 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 270 * <code>t</code> passed as parameter. 271 * 272 * @param marker the marker data specific to this log statement. 273 * @param message the message object to log. 274 * @param t the exception to log, including its stack trace. 275 */ 276 void error(Marker marker, String message, Throwable t); 277 278 /** 279 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 280 * 281 * @param msg the message string to be logged 282 */ 283 void error(Message msg); 284 285 /** 286 * Logs a message with the specific Marker at the {@link Level#ERROR ERROR} level. 287 * 288 * @param msg the message string to be logged 289 * @param t A Throwable or null. 290 */ 291 void error(Message msg, Throwable t); 292 293 /** 294 * Logs a message object with the {@link Level#ERROR ERROR} level. 295 * 296 * @param message the message object to log. 297 */ 298 void error(Object message); 299 300 /** 301 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 302 * <code>t</code> passed as parameter. 303 * 304 * @param message the message object to log. 305 * @param t the exception to log, including its stack trace. 306 */ 307 void error(Object message, Throwable t); 308 309 /** 310 * Logs a message object with the {@link Level#ERROR ERROR} level. 311 * 312 * @param message the message string to log. 313 */ 314 void error(String message); 315 316 /** 317 * Logs a message with parameters at the {@link Level#ERROR ERROR} level. 318 * 319 * @param message the message to log; the format depends on the message factory. 320 * @param params parameters to the message. 321 * @see #getMessageFactory() 322 * 323 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 324 * array creation expense on every call. (RG) I assume you meant error, not info. It isn't possible to be 325 * misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 326 * 1, 2 or 3 parameters. 327 */ 328 void error(String message, Object... params); 329 330 /** 331 * Logs a message at the {@link Level#ERROR ERROR} level including the stack trace of the {@link Throwable} 332 * <code>t</code> passed as parameter. 333 * 334 * @param message the message object to log. 335 * @param t the exception to log, including its stack trace. 336 */ 337 void error(String message, Throwable t); 338 339 /** 340 * Logs exit from a method. Used for methods that do not return anything. 341 */ 342 void exit(); 343 344 /** 345 * Logs exiting from a method with the result. This may be coded as: 346 * <pre> 347 * return LOGGER.exit(myResult); 348 * </pre> 349 * 350 * @param <R> The type of the parameter and object being returned. 351 * @param result The result being returned from the method call. 352 * @return the result. 353 */ 354 <R> R exit(R result); 355 356 /** 357 * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level. 358 * 359 * @param marker the marker data specific to this log statement 360 * @param msg the message string to be logged 361 */ 362 void fatal(Marker marker, Message msg); 363 364 /** 365 * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level. 366 * 367 * @param marker the marker data specific to this log statement 368 * @param msg the message string to be logged 369 * @param t A Throwable or null. 370 */ 371 void fatal(Marker marker, Message msg, Throwable t); 372 373 /** 374 * Logs a message object with the {@link Level#FATAL FATAL} level. 375 * 376 * @param marker The marker data specific to this log statement. 377 * @param message the message object to log. 378 */ 379 void fatal(Marker marker, Object message); 380 381 /** 382 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 383 * <code>t</code> passed as parameter. 384 * 385 * @param marker The marker data specific to this log statement. 386 * @param message the message object to log. 387 * @param t the exception to log, including its stack trace. 388 */ 389 void fatal(Marker marker, Object message, Throwable t); 390 391 /** 392 * Logs a message object with the {@link Level#FATAL FATAL} level. 393 * 394 * @param marker The marker data specific to this log statement. 395 * @param message the message object to log. 396 */ 397 void fatal(Marker marker, String message); 398 399 /** 400 * Logs a message with parameters at the {@link Level#FATAL FATAL} level. 401 * 402 * @param marker The marker data specific to this log statement. 403 * @param message the message to log; the format depends on the message factory. 404 * @param params parameters to the message. 405 * @see #getMessageFactory() 406 * 407 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 408 * array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be 409 * misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 410 * 1, 2 or 3 parameters. 411 */ 412 void fatal(Marker marker, String message, Object... params); 413 414 /** 415 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 416 * <code>t</code> passed as parameter. 417 * 418 * @param marker The marker data specific to this log statement. 419 * @param message the message object to log. 420 * @param t the exception to log, including its stack trace. 421 */ 422 void fatal(Marker marker, String message, Throwable t); 423 424 /** 425 * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level. 426 * 427 * @param msg the message string to be logged 428 */ 429 void fatal(Message msg); 430 431 /** 432 * Logs a message with the specific Marker at the {@link Level#FATAL FATAL} level. 433 * 434 * @param msg the message string to be logged 435 * @param t A Throwable or null. 436 */ 437 void fatal(Message msg, Throwable t); 438 439 /** 440 * Logs a message object with the {@link Level#FATAL FATAL} level. 441 * 442 * @param message the message object to log. 443 */ 444 void fatal(Object message); 445 446 /** 447 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 448 * <code>t</code> passed as parameter. 449 * 450 * @param message the message object to log. 451 * @param t the exception to log, including its stack trace. 452 */ 453 void fatal(Object message, Throwable t); 454 455 /** 456 * Logs a message object with the {@link Level#FATAL FATAL} level. 457 * 458 * @param message the message string to log. 459 */ 460 void fatal(String message); 461 462 /** 463 * Logs a message with parameters at the {@link Level#FATAL FATAL} level. 464 * 465 * @param message the message to log; the format depends on the message factory. 466 * @param params parameters to the message. 467 * @see #getMessageFactory() 468 * 469 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 470 * array creation expense on every call.(RG) I assume you meant fatal, not info. It isn't possible to be 471 * misinterpreted as the previous method is for that signature. Methods should be added to avoid varargs for 472 * 1, 2 or 3 parameters. 473 */ 474 void fatal(String message, Object... params); 475 476 /** 477 * Logs a message at the {@link Level#FATAL FATAL} level including the stack trace of the {@link Throwable} 478 * <code>t</code> passed as parameter. 479 * 480 * @param message the message object to log. 481 * @param t the exception to log, including its stack trace. 482 */ 483 void fatal(String message, Throwable t); 484 485 /** 486 * Gets the Level associated with the Logger. 487 * 488 * @return the Level associate with the Logger. 489 */ 490 Level getLevel(); 491 492 /** 493 * Gets the message factory used to convert message Objects and Strings into actual log Messages. 494 * 495 * @return the message factory. 496 */ 497 MessageFactory getMessageFactory(); 498 499 /** 500 * Gets the logger name. 501 * 502 * @return the logger name. 503 */ 504 String getName(); 505 506 /** 507 * Logs a message with the specific Marker at the {@link Level#INFO INFO} level. 508 * 509 * @param marker the marker data specific to this log statement 510 * @param msg the message string to be logged 511 */ 512 void info(Marker marker, Message msg); 513 514 /** 515 * Logs a message with the specific Marker at the {@link Level#INFO INFO} level. 516 * 517 * @param marker the marker data specific to this log statement 518 * @param msg the message string to be logged 519 * @param t A Throwable or null. 520 */ 521 void info(Marker marker, Message msg, Throwable t); 522 523 /** 524 * Logs a message object with the {@link Level#INFO INFO} level. 525 * 526 * @param marker the marker data specific to this log statement 527 * @param message the message object to log. 528 */ 529 void info(Marker marker, Object message); 530 531 /** 532 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 533 * <code>t</code> passed as parameter. 534 * 535 * @param marker the marker data specific to this log statement 536 * @param message the message object to log. 537 * @param t the exception to log, including its stack trace. 538 */ 539 void info(Marker marker, Object message, Throwable t); 540 541 /** 542 * Logs a message object with the {@link Level#INFO INFO} level. 543 * 544 * @param marker the marker data specific to this log statement 545 * @param message the message object to log. 546 */ 547 void info(Marker marker, String message); 548 549 /** 550 * Logs a message with parameters at the {@link Level#INFO INFO} level. 551 * 552 * @param marker the marker data specific to this log statement 553 * @param message the message to log; the format depends on the message factory. 554 * @param params parameters to the message. 555 * @see #getMessageFactory() 556 * 557 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 558 * array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method 559 * is for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters. 560 */ 561 void info(Marker marker, String message, Object... params); 562 563 /** 564 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 565 * <code>t</code> passed as parameter. 566 * 567 * @param marker the marker data specific to this log statement 568 * @param message the message object to log. 569 * @param t the exception to log, including its stack trace. 570 */ 571 void info(Marker marker, String message, Throwable t); 572 573 /** 574 * Logs a message with the specific Marker at the {@link Level#INFO INFO} level. 575 * 576 * @param msg the message string to be logged 577 */ 578 void info(Message msg); 579 580 /** 581 * Logs a message with the specific Marker at the {@link Level#INFO INFO} level. 582 * 583 * @param msg the message string to be logged 584 * @param t A Throwable or null. 585 */ 586 void info(Message msg, Throwable t); 587 588 /** 589 * Logs a message object with the {@link Level#INFO INFO} level. 590 * 591 * @param message the message object to log. 592 */ 593 void info(Object message); 594 595 /** 596 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 597 * <code>t</code> passed as parameter. 598 * 599 * @param message the message object to log. 600 * @param t the exception to log, including its stack trace. 601 */ 602 void info(Object message, Throwable t); 603 604 /** 605 * Logs a message object with the {@link Level#INFO INFO} level. 606 * 607 * @param message the message string to log. 608 */ 609 void info(String message); 610 611 /** 612 * Logs a message with parameters at the {@link Level#INFO INFO} level. 613 * 614 * @param message the message to log; the format depends on the message factory. 615 * @param params parameters to the message. 616 * @see #getMessageFactory() 617 * 618 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 619 * array creation expense on every call. (RG) It isn't possible to be misinterpreted as the previous method 620 * is for that signature. Methods should be added to avoid varargs for 1, 2 or 3 parameters. 621 */ 622 void info(String message, Object... params); 623 624 /** 625 * Logs a message at the {@link Level#INFO INFO} level including the stack trace of the {@link Throwable} 626 * <code>t</code> passed as parameter. 627 * 628 * @param message the message object to log. 629 * @param t the exception to log, including its stack trace. 630 */ 631 void info(String message, Throwable t); 632 633 /** 634 * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level. 635 * 636 * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise. 637 */ 638 boolean isDebugEnabled(); 639 640 /** 641 * Checks whether this Logger is enabled for the {@link Level#DEBUG DEBUG} Level. 642 * 643 * @param marker The marker data specific to this log statement. 644 * @return boolean - {@code true} if this Logger is enabled for level DEBUG, {@code false} otherwise. 645 */ 646 boolean isDebugEnabled(Marker marker); 647 648 /** 649 * Checks whether this Logger is enabled for the the given Level. 650 * <p> 651 * Note that passing in {@link Level#OFF OFF} always returns {@code true}. 652 * </p> 653 * 654 * @param level the level to check 655 * @return boolean - {@code true} if this Logger is enabled for level, {@code false} otherwise. 656 */ 657 boolean isEnabled(Level level); 658 659 /** 660 * Checks whether this logger is enabled at the specified level and an optional Marker. 661 * 662 * @param level The Level to check. 663 * @param marker The marker data specific to this log statement. 664 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false} 665 * otherwise. 666 */ 667 boolean isEnabled(Level level, Marker marker); 668 669 /** 670 * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level. 671 * 672 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false} 673 * otherwise. 674 */ 675 boolean isErrorEnabled(); 676 677 /** 678 * Checks whether this Logger is enabled for the {@link Level#ERROR ERROR} Level. 679 * 680 * @param marker The marker data specific to this log statement. 681 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#ERROR ERROR}, {@code false} 682 * otherwise. 683 */ 684 boolean isErrorEnabled(Marker marker); 685 686 /** 687 * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level. 688 * 689 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false} 690 * otherwise. 691 */ 692 boolean isFatalEnabled(); 693 694 /** 695 * Checks whether this Logger is enabled for the {@link Level#FATAL FATAL} Level. 696 * 697 * @param marker The marker data specific to this log statement. 698 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#FATAL FATAL}, {@code false} 699 * otherwise. 700 */ 701 boolean isFatalEnabled(Marker marker); 702 703 /** 704 * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level. 705 * 706 * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise. 707 */ 708 boolean isInfoEnabled(); 709 710 /** 711 * Checks whether this Logger is enabled for the {@link Level#INFO INFO} Level. 712 * 713 * @param marker The marker data specific to this log statement. 714 * @return boolean - {@code true} if this Logger is enabled for level INFO, {@code false} otherwise. 715 */ 716 boolean isInfoEnabled(Marker marker); 717 718 /** 719 * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level. 720 * 721 * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise. 722 */ 723 boolean isTraceEnabled(); 724 725 /** 726 * Checks whether this Logger is enabled for the {@link Level#TRACE TRACE} level. 727 * 728 * @param marker The marker data specific to this log statement. 729 * @return boolean - {@code true} if this Logger is enabled for level TRACE, {@code false} otherwise. 730 */ 731 boolean isTraceEnabled(Marker marker); 732 733 /** 734 * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level. 735 * 736 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false} 737 * otherwise. 738 */ 739 boolean isWarnEnabled(); 740 741 /** 742 * Checks whether this Logger is enabled for the {@link Level#WARN WARN} Level. 743 * 744 * @param marker The marker data specific to this log statement. 745 * @return boolean - {@code true} if this Logger is enabled for level {@link Level#WARN WARN}, {@code false} 746 * otherwise. 747 */ 748 boolean isWarnEnabled(Marker marker); 749 750 /** 751 * Logs a message with the specific Marker at the given level. 752 * 753 * @param level the logging level 754 * @param marker the marker data specific to this log statement 755 * @param msg the message string to be logged 756 */ 757 void log(Level level, Marker marker, Message msg); 758 759 /** 760 * Logs a message with the specific Marker at the given level. 761 * 762 * @param level the logging level 763 * @param marker the marker data specific to this log statement 764 * @param msg the message string to be logged 765 * @param t A Throwable or null. 766 */ 767 void log(Level level, Marker marker, Message msg, Throwable t); 768 769 /** 770 * Logs a message object with the given level. 771 * 772 * @param level the logging level 773 * @param marker the marker data specific to this log statement 774 * @param message the message object to log. 775 */ 776 void log(Level level, Marker marker, Object message); 777 778 /** 779 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 780 * parameter. 781 * 782 * @param level the logging level 783 * @param marker the marker data specific to this log statement 784 * @param message the message to log. 785 * @param t the exception to log, including its stack trace. 786 */ 787 void log(Level level, Marker marker, Object message, Throwable t); 788 789 /** 790 * Logs a message object with the given level. 791 * 792 * @param level the logging level 793 * @param marker the marker data specific to this log statement 794 * @param message the message object to log. 795 */ 796 void log(Level level, Marker marker, String message); 797 798 /** 799 * Logs a message with parameters at the given level. 800 * 801 * @param level the logging level 802 * @param marker the marker data specific to this log statement 803 * @param message the message to log; the format depends on the message factory. 804 * @param params parameters to the message. 805 * @see #getMessageFactory() 806 */ 807 void log(Level level, Marker marker, String message, Object... params); 808 809 /** 810 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 811 * parameter. 812 * 813 * @param level the logging level 814 * @param marker the marker data specific to this log statement 815 * @param message the message to log. 816 * @param t the exception to log, including its stack trace. 817 */ 818 void log(Level level, Marker marker, String message, Throwable t); 819 820 /** 821 * Logs a message with the specific Marker at the given level. 822 * 823 * @param level the logging level 824 * @param msg the message string to be logged 825 */ 826 void log(Level level, Message msg); 827 828 /** 829 * Logs a message with the specific Marker at the given level. 830 * 831 * @param level the logging level 832 * @param msg the message string to be logged 833 * @param t A Throwable or null. 834 */ 835 void log(Level level, Message msg, Throwable t); 836 837 /** 838 * Logs a message object with the given level. 839 * 840 * @param level the logging level 841 * @param message the message object to log. 842 */ 843 void log(Level level, Object message); 844 845 /** 846 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 847 * parameter. 848 * 849 * @param level the logging level 850 * @param message the message to log. 851 * @param t the exception to log, including its stack trace. 852 */ 853 void log(Level level, Object message, Throwable t); 854 855 /** 856 * Logs a message object with the given level. 857 * 858 * @param level the logging level 859 * @param message the message string to log. 860 */ 861 void log(Level level, String message); 862 863 /** 864 * Logs a message with parameters at the given level. 865 * 866 * @param level the logging level 867 * @param message the message to log; the format depends on the message factory. 868 * @param params parameters to the message. 869 * @see #getMessageFactory() 870 */ 871 void log(Level level, String message, Object... params); 872 873 /** 874 * Logs a message at the given level including the stack trace of the {@link Throwable} <code>t</code> passed as 875 * parameter. 876 * 877 * @param level the logging level 878 * @param message the message to log. 879 * @param t the exception to log, including its stack trace. 880 */ 881 void log(Level level, String message, Throwable t); 882 883 /** 884 * Logs a formatted message using the specified format string and arguments. 885 * 886 * @param level The logging Level. 887 * @param marker the marker data specific to this log statement. 888 * @param format The format String. 889 * @param params Arguments specified by the format. 890 */ 891 void printf(Level level, Marker marker, String format, Object... params); 892 893 /** 894 * Logs a formatted message using the specified format string and arguments. 895 * 896 * @param level The logging Level. 897 * @param format The format String. 898 * @param params Arguments specified by the format. 899 */ 900 void printf(Level level, String format, Object... params); 901 902 /** 903 * Logs an exception or error to be thrown. This may be coded as: 904 * <pre> 905 * throw logger.throwing(Level.DEBUG, myException); 906 * </pre> 907 * 908 * @param <T> the Throwable type. 909 * @param level The logging Level. 910 * @param t The Throwable. 911 * @return the Throwable. 912 */ 913 <T extends Throwable> T throwing(Level level, T t); 914 915 /** 916 * Logs an exception or error to be thrown. This may be coded as: 917 * <pre> 918 * throw logger.throwing(myException); 919 * </pre> 920 * 921 * @param <T> the Throwable type. 922 * @param t The Throwable. 923 * @return the Throwable. 924 */ 925 <T extends Throwable> T throwing(T t); 926 927 /** 928 * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level. 929 * 930 * @param marker the marker data specific to this log statement 931 * @param msg the message string to be logged 932 */ 933 void trace(Marker marker, Message msg); 934 935 /** 936 * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level. 937 * 938 * @param marker the marker data specific to this log statement 939 * @param msg the message string to be logged 940 * @param t A Throwable or null. 941 */ 942 void trace(Marker marker, Message msg, Throwable t); 943 944 /** 945 * Logs a message object with the {@link Level#TRACE TRACE} level. 946 * 947 * @param marker the marker data specific to this log statement 948 * @param message the message object to log. 949 */ 950 void trace(Marker marker, Object message); 951 952 /** 953 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 954 * <code>t</code> passed as parameter. 955 * 956 * @param marker the marker data specific to this log statement 957 * @param message the message object to log. 958 * @param t the exception to log, including its stack trace. 959 * @see #debug(String) 960 */ 961 void trace(Marker marker, Object message, Throwable t); 962 963 /** 964 * Logs a message object with the {@link Level#TRACE TRACE} level. 965 * 966 * @param marker the marker data specific to this log statement 967 * @param message the message string to log. 968 */ 969 void trace(Marker marker, String message); 970 971 /** 972 * Logs a message with parameters at the {@link Level#TRACE TRACE} level. 973 * 974 * @param marker the marker data specific to this log statement 975 * @param message the message to log; the format depends on the message factory. 976 * @param params parameters to the message. 977 * @see #getMessageFactory() 978 */ 979 void trace(Marker marker, String message, Object... params); 980 981 /** 982 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 983 * <code>t</code> passed as parameter. 984 * 985 * @param marker the marker data specific to this log statement 986 * @param message the message object to log. 987 * @param t the exception to log, including its stack trace. 988 * @see #debug(String) 989 */ 990 void trace(Marker marker, String message, Throwable t); 991 992 /** 993 * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level. 994 * 995 * @param msg the message string to be logged 996 */ 997 void trace(Message msg); 998 999 /** 1000 * Logs a message with the specific Marker at the {@link Level#TRACE TRACE} level. 1001 * 1002 * @param msg the message string to be logged 1003 * @param t A Throwable or null. 1004 */ 1005 void trace(Message msg, Throwable t); 1006 1007 /** 1008 * Logs a message object with the {@link Level#TRACE TRACE} level. 1009 * 1010 * @param message the message object to log. 1011 */ 1012 void trace(Object message); 1013 1014 /** 1015 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1016 * <code>t</code> passed as parameter. 1017 * 1018 * @param message the message object to log. 1019 * @param t the exception to log, including its stack trace. 1020 * @see #debug(String) 1021 */ 1022 void trace(Object message, Throwable t); 1023 1024 /** 1025 * Logs a message object with the {@link Level#TRACE TRACE} level. 1026 * 1027 * @param message the message string to log. 1028 */ 1029 void trace(String message); 1030 1031 /** 1032 * Logs a message with parameters at the {@link Level#TRACE TRACE} level. 1033 * 1034 * @param message the message to log; the format depends on the message factory. 1035 * @param params parameters to the message. 1036 * @see #getMessageFactory() 1037 */ 1038 void trace(String message, Object... params); 1039 1040 /** 1041 * Logs a message at the {@link Level#TRACE TRACE} level including the stack trace of the {@link Throwable} 1042 * <code>t</code> passed as parameter. 1043 * 1044 * @param message the message object to log. 1045 * @param t the exception to log, including its stack trace. 1046 * @see #debug(String) 1047 */ 1048 void trace(String message, Throwable t); 1049 1050 /** 1051 * Logs a message with the specific Marker at the {@link Level#WARN WARN} level. 1052 * 1053 * @param marker the marker data specific to this log statement 1054 * @param msg the message string to be logged 1055 */ 1056 void warn(Marker marker, Message msg); 1057 1058 /** 1059 * Logs a message with the specific Marker at the {@link Level#WARN WARN} level. 1060 * 1061 * @param marker the marker data specific to this log statement 1062 * @param msg the message string to be logged 1063 * @param t A Throwable or null. 1064 */ 1065 void warn(Marker marker, Message msg, Throwable t); 1066 1067 /** 1068 * Logs a message object with the {@link Level#WARN WARN} level. 1069 * 1070 * @param marker the marker data specific to this log statement 1071 * @param message the message object to log. 1072 */ 1073 void warn(Marker marker, Object message); 1074 1075 /** 1076 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1077 * <code>t</code> passed as parameter. 1078 * 1079 * @param marker the marker data specific to this log statement 1080 * @param message the message object to log. 1081 * @param t the exception to log, including its stack trace. 1082 */ 1083 void warn(Marker marker, Object message, Throwable t); 1084 1085 /** 1086 * Logs a message object with the {@link Level#WARN WARN} level. 1087 * 1088 * @param marker the marker data specific to this log statement 1089 * @param message the message object to log. 1090 */ 1091 void warn(Marker marker, String message); 1092 1093 /** 1094 * Logs a message with parameters at the {@link Level#WARN WARN} level. 1095 * 1096 * @param marker the marker data specific to this log statement. 1097 * @param message the message to log; the format depends on the message factory. 1098 * @param params parameters to the message. 1099 * @see #getMessageFactory() 1100 * 1101 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 1102 * array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be 1103 * misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for 1104 * 1, 2 or 3 parameters. 1105 */ 1106 void warn(Marker marker, String message, Object... params); 1107 1108 /** 1109 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1110 * <code>t</code> passed as parameter. 1111 * 1112 * @param marker the marker data specific to this log statement 1113 * @param message the message object to log. 1114 * @param t the exception to log, including its stack trace. 1115 */ 1116 void warn(Marker marker, String message, Throwable t); 1117 1118 /** 1119 * Logs a message with the specific Marker at the {@link Level#WARN WARN} level. 1120 * 1121 * @param msg the message string to be logged 1122 */ 1123 void warn(Message msg); 1124 1125 /** 1126 * Logs a message with the specific Marker at the {@link Level#WARN WARN} level. 1127 * 1128 * @param msg the message string to be logged 1129 * @param t A Throwable or null. 1130 */ 1131 void warn(Message msg, Throwable t); 1132 1133 /** 1134 * Logs a message object with the {@link Level#WARN WARN} level. 1135 * 1136 * @param message the message object to log. 1137 */ 1138 void warn(Object message); 1139 1140 /** 1141 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1142 * <code>t</code> passed as parameter. 1143 * 1144 * @param message the message object to log. 1145 * @param t the exception to log, including its stack trace. 1146 */ 1147 void warn(Object message, Throwable t); 1148 1149 /** 1150 * Logs a message object with the {@link Level#WARN WARN} level. 1151 * 1152 * @param message the message string to log. 1153 */ 1154 void warn(String message); 1155 1156 /** 1157 * Logs a message with parameters at the {@link Level#WARN WARN} level. 1158 * 1159 * @param message the message to log; the format depends on the message factory. 1160 * @param params parameters to the message. 1161 * @see #getMessageFactory() 1162 * 1163 * TODO Likely to misinterpret existing log4j client code that intended to call info(Object,Throwable). Incurs 1164 * array creation expense on every call. (RG) I assume you meant warn, not info. It isn't possible to be 1165 * misinterpreted as the previous method is for that signature.Methods should be added to avoid varargs for 1166 * 1, 2 or 3 parameters. 1167 */ 1168 void warn(String message, Object... params); 1169 1170 /** 1171 * Logs a message at the {@link Level#WARN WARN} level including the stack trace of the {@link Throwable} 1172 * <code>t</code> passed as parameter. 1173 * 1174 * @param message the message object to log. 1175 * @param t the exception to log, including its stack trace. 1176 */ 1177 void warn(String message, Throwable t); 1178}