git.gag.com Git - debian/openrocket/blob - core/src/net/sf/openrocket/logging/LogHelper.java

   1 package net.sf.openrocket.logging;
   2
   3 import net.sf.openrocket.util.BugException;
   4
   5
   6 /**
   7  * Base class for all loggers used in OpenRocket.
   8  * <p>
   9  * This class contains methods for logging at various log levels, and methods
  10  * which take the logging level as a parameter.  All methods may take three types
  11  * of parameters:
  12  * <ul>
  13  *      <li><code>levels</code>         number of additional levels of the stack trace to print
  14  *                                                              on the log line.  This is useful to determine from where
  15  *                                                              the current method has been called.  Zero if not provided.
  16  *  <li><code>message</code>    the String message (may be null).
  17  *  <li><code>cause</code>              the exception that caused this log (may be null).
  18  * </ul>
  19  * <p>
  20  * The logging methods are guaranteed never to throw an exception, and can thus be safely
  21  * used in finally blocks.
  22  *
  23  * @author Sampo Niskanen <sampo.niskanen@iki.fi>
  24  */
  25 public abstract class LogHelper {
  26         /**
  27          * Level from which upward a TraceException is added to the log lines.
  28          */
  29         private static final LogLevel TRACING_LOG_LEVEL =
  30                         LogLevel.fromString(System.getProperty("openrocket.log.tracelevel"), LogLevel.INFO);
  31
  32         private static final DelegatorLogger delegator = new DelegatorLogger();
  33
  34
  35
  36         /**
  37          * Get the logger to be used in logging.
  38          *
  39          * @return      the logger to be used in all logging.
  40          */
  41         public static LogHelper getInstance() {
  42                 return delegator;
  43         }
  44
  45
  46
  47         /**
  48          * Log a LogLine object.  This method needs to be able to cope with multiple threads
  49          * accessing it concurrently (for example by being synchronized).
  50          *
  51          * @param line  the LogLine to log.
  52          */
  53         public abstract void log(LogLine line);
  54
  55
  56         /**
  57          * Log using VBOSE level.
  58          *
  59          * @param message       the logged message (may be null).
  60          */
  61         public void verbose(String message) {
  62                 try {
  63                         log(createLogLine(0, LogLevel.VBOSE, message, null));
  64                 } catch (Exception e) {
  65                         e.printStackTrace();
  66                 }
  67         }
  68
  69         /**
  70          * Log using VBOSE level.
  71          *
  72          * @param message       the logged message (may be null).
  73          * @param cause         the causing exception (may be null).
  74          */
  75         public void verbose(String message, Throwable cause) {
  76                 try {
  77                         log(createLogLine(0, LogLevel.VBOSE, message, cause));
  78                 } catch (Exception e) {
  79                         e.printStackTrace();
  80                 }
  81         }
  82
  83         /**
  84          * Log using VBOSE level.
  85          *
  86          * @param levels        number of additional levels of stack trace to include.
  87          * @param message       the logged message (may be null).
  88          */
  89         public void verbose(int levels, String message) {
  90                 try {
  91                         log(createLogLine(levels, LogLevel.VBOSE, message, null));
  92                 } catch (Exception e) {
  93                         e.printStackTrace();
  94                 }
  95         }
  96
  97         /**
  98          * Log using VBOSE level.
  99          *
 100          * @param levels        number of additional levels of stack trace to include.
 101          * @param message       the logged message (may be null).
 102          * @param cause         the causing exception (may be null).
 103          */
 104         public void verbose(int levels, String message, Throwable cause) {
 105                 try {
 106                         log(createLogLine(levels, LogLevel.VBOSE, message, cause));
 107                 } catch (Exception e) {
 108                         e.printStackTrace();
 109                 }
 110         }
 111
 112
 113         /**
 114          * Log using DEBUG level.
 115          *
 116          * @param message       the logged message (may be null).
 117          */
 118         public void debug(String message) {
 119                 try {
 120                         log(createLogLine(0, LogLevel.DEBUG, message, null));
 121                 } catch (Exception e) {
 122                         e.printStackTrace();
 123                 }
 124         }
 125
 126         /**
 127          * Log using DEBUG level.
 128          *
 129          * @param message       the logged message (may be null).
 130          * @param cause         the causing exception (may be null).
 131          */
 132         public void debug(String message, Throwable cause) {
 133                 try {
 134                         log(createLogLine(0, LogLevel.DEBUG, message, cause));
 135                 } catch (Exception e) {
 136                         e.printStackTrace();
 137                 }
 138         }
 139
 140         /**
 141          * Log using DEBUG level.
 142          *
 143          * @param levels        number of additional levels of stack trace to include.
 144          * @param message       the logged message (may be null).
 145          */
 146         public void debug(int levels, String message) {
 147                 try {
 148                         log(createLogLine(levels, LogLevel.DEBUG, message, null));
 149                 } catch (Exception e) {
 150                         e.printStackTrace();
 151                 }
 152         }
 153
 154         /**
 155          * Log using DEBUG level.
 156          *
 157          * @param levels        number of additional levels of stack trace to include.
 158          * @param message       the logged message (may be null).
 159          * @param cause         the causing exception (may be null).
 160          */
 161         public void debug(int levels, String message, Throwable cause) {
 162                 try {
 163                         log(createLogLine(levels, LogLevel.DEBUG, message, cause));
 164                 } catch (Exception e) {
 165                         e.printStackTrace();
 166                 }
 167         }
 168
 169
 170         /**
 171          * Log using INFO level.
 172          *
 173          * @param message       the logged message (may be null).
 174          */
 175         public void info(String message) {
 176                 try {
 177                         log(createLogLine(0, LogLevel.INFO, message, null));
 178                 } catch (Exception e) {
 179                         e.printStackTrace();
 180                 }
 181         }
 182
 183         /**
 184          * Log using INFO level.
 185          *
 186          * @param message       the logged message (may be null).
 187          * @param cause         the causing exception (may be null).
 188          */
 189         public void info(String message, Throwable cause) {
 190                 try {
 191                         log(createLogLine(0, LogLevel.INFO, message, cause));
 192                 } catch (Exception e) {
 193                         e.printStackTrace();
 194                 }
 195         }
 196
 197         /**
 198          * Log using INFO level.
 199          *
 200          * @param levels        number of additional levels of stack trace to include.
 201          * @param message       the logged message (may be null).
 202          */
 203         public void info(int levels, String message) {
 204                 try {
 205                         log(createLogLine(levels, LogLevel.INFO, message, null));
 206                 } catch (Exception e) {
 207                         e.printStackTrace();
 208                 }
 209         }
 210
 211         /**
 212          * Log using INFO level.
 213          *
 214          * @param levels        number of additional levels of stack trace to include.
 215          * @param message       the logged message (may be null).
 216          * @param cause         the causing exception (may be null).
 217          */
 218         public void info(int levels, String message, Throwable cause) {
 219                 try {
 220                         log(createLogLine(levels, LogLevel.INFO, message, cause));
 221                 } catch (Exception e) {
 222                         e.printStackTrace();
 223                 }
 224         }
 225
 226
 227         /**
 228          * Log using USER level.
 229          *
 230          * @param message       the logged message (may be null).
 231          */
 232         public void user(String message) {
 233                 try {
 234                         log(createLogLine(0, LogLevel.USER, message, null));
 235                 } catch (Exception e) {
 236                         e.printStackTrace();
 237                 }
 238         }
 239
 240         /**
 241          * Log using USER level.
 242          *
 243          * @param message       the logged message (may be null).
 244          * @param cause         the causing exception (may be null).
 245          */
 246         public void user(String message, Throwable cause) {
 247                 try {
 248                         log(createLogLine(0, LogLevel.USER, message, cause));
 249                 } catch (Exception e) {
 250                         e.printStackTrace();
 251                 }
 252         }
 253
 254         /**
 255          * Log using USER level.
 256          *
 257          * @param levels        number of additional levels of stack trace to include.
 258          * @param message       the logged message (may be null).
 259          */
 260         public void user(int levels, String message) {
 261                 try {
 262                         log(createLogLine(levels, LogLevel.USER, message, null));
 263                 } catch (Exception e) {
 264                         e.printStackTrace();
 265                 }
 266         }
 267
 268         /**
 269          * Log using USER level.
 270          *
 271          * @param levels        number of additional levels of stack trace to include.
 272          * @param message       the logged message (may be null).
 273          * @param cause         the causing exception (may be null).
 274          */
 275         public void user(int levels, String message, Throwable cause) {
 276                 try {
 277                         log(createLogLine(levels, LogLevel.USER, message, cause));
 278                 } catch (Exception e) {
 279                         e.printStackTrace();
 280                 }
 281         }
 282
 283
 284         /**
 285          * Log using WARN level.
 286          *
 287          * @param message       the logged message (may be null).
 288          */
 289         public void warn(String message) {
 290                 try {
 291                         log(createLogLine(0, LogLevel.WARN, message, null));
 292                 } catch (Exception e) {
 293                         e.printStackTrace();
 294                 }
 295         }
 296
 297         /**
 298          * Log using WARN level.
 299          *
 300          * @param message       the logged message (may be null).
 301          * @param cause         the causing exception (may be null).
 302          */
 303         public void warn(String message, Throwable cause) {
 304                 try {
 305                         log(createLogLine(0, LogLevel.WARN, message, cause));
 306                 } catch (Exception e) {
 307                         e.printStackTrace();
 308                 }
 309         }
 310
 311         /**
 312          * Log using WARN level.
 313          *
 314          * @param levels        number of additional levels of stack trace to include.
 315          * @param message       the logged message (may be null).
 316          */
 317         public void warn(int levels, String message) {
 318                 try {
 319                         log(createLogLine(levels, LogLevel.WARN, message, null));
 320                 } catch (Exception e) {
 321                         e.printStackTrace();
 322                 }
 323         }
 324
 325         /**
 326          * Log using WARN level.
 327          *
 328          * @param levels        number of additional levels of stack trace to include.
 329          * @param message       the logged message (may be null).
 330          * @param cause         the causing exception (may be null).
 331          */
 332         public void warn(int levels, String message, Throwable cause) {
 333                 try {
 334                         log(createLogLine(levels, LogLevel.WARN, message, cause));
 335                 } catch (Exception e) {
 336                         e.printStackTrace();
 337                 }
 338         }
 339
 340
 341         /**
 342          * Log using ERROR level.
 343          *
 344          * @param message       the logged message (may be null).
 345          */
 346         public void error(String message) {
 347                 try {
 348                         log(createLogLine(0, LogLevel.ERROR, message, null));
 349                 } catch (Exception e) {
 350                         e.printStackTrace();
 351                 }
 352         }
 353
 354         /**
 355          * Log using ERROR level.
 356          *
 357          * @param message       the logged message (may be null).
 358          * @param cause         the causing exception (may be null).
 359          */
 360         public void error(String message, Throwable cause) {
 361                 try {
 362                         log(createLogLine(0, LogLevel.ERROR, message, cause));
 363                 } catch (Exception e) {
 364                         e.printStackTrace();
 365                 }
 366         }
 367
 368         /**
 369          * Log using ERROR level.
 370          *
 371          * @param levels        number of additional levels of stack trace to include.
 372          * @param message       the logged message (may be null).
 373          */
 374         public void error(int levels, String message) {
 375                 try {
 376                         log(createLogLine(levels, LogLevel.ERROR, message, null));
 377                 } catch (Exception e) {
 378                         e.printStackTrace();
 379                 }
 380         }
 381
 382         /**
 383          * Log using ERROR level.
 384          *
 385          * @param levels        number of additional levels of stack trace to include.
 386          * @param message       the logged message (may be null).
 387          * @param cause         the causing exception (may be null).
 388          */
 389         public void error(int levels, String message, Throwable cause) {
 390                 try {
 391                         log(createLogLine(levels, LogLevel.ERROR, message, cause));
 392                 } catch (Exception e) {
 393                         e.printStackTrace();
 394                 }
 395         }
 396
 397
 398
 399         /**
 400          * Log using the provided log level.
 401          *
 402          * @param level         the logging level.
 403          * @param message       the logged message (may be null).
 404          */
 405         public void log(LogLevel level, String message) {
 406                 try {
 407                         log(createLogLine(0, level, message, null));
 408                 } catch (Exception e) {
 409                         e.printStackTrace();
 410                 }
 411         }
 412
 413         /**
 414          * Log using the provided log level.
 415          *
 416          * @param level         the logging level.
 417          * @param message       the logged message (may be null).
 418          * @param cause         the causing exception (may be null).
 419          */
 420         public void log(LogLevel level, String message, Throwable cause) {
 421                 try {
 422                         log(createLogLine(0, level, message, cause));
 423                 } catch (Exception e) {
 424                         e.printStackTrace();
 425                 }
 426         }
 427
 428         /**
 429          * Log using the provided log level.
 430          *
 431          * @param levels        number of additional levels of stack trace to include.
 432          * @param level         the logging level.
 433          * @param message       the logged message (may be null).
 434          */
 435         public void log(int levels, LogLevel level, String message) {
 436                 try {
 437                         log(createLogLine(levels, level, message, null));
 438                 } catch (Exception e) {
 439                         e.printStackTrace();
 440                 }
 441         }
 442
 443         /**
 444          * Log using the provided log level.
 445          *
 446          * @param levels        number of additional levels of stack trace to include.
 447          * @param level         the logging level.
 448          * @param message       the logged message (may be null).
 449          * @param cause         the causing exception (may be null).
 450          */
 451         public void log(int levels, LogLevel level, String message, Throwable cause) {
 452                 try {
 453                         log(createLogLine(levels, level, message, cause));
 454                 } catch (Exception e) {
 455                         e.printStackTrace();
 456                 }
 457         }
 458
 459
 460
 461         /**
 462          * Instantiates, logs and throws a BugException.  The message is logged at
 463          * ERROR level.
 464          * <p>
 465          * This method never returns normally.
 466          *
 467          * @param message       the message for the log and exception.
 468          * @throws BugException always.
 469          */
 470         public void throwBugException(String message) throws BugException {
 471                 BugException e = new BugException(message);
 472                 log(createLogLine(0, LogLevel.ERROR, message, e));
 473                 throw e;
 474         }
 475
 476         /**
 477          * Instantiates, logs and throws a BugException.  The message is logged at
 478          * ERROR level with the specified cause.
 479          * <p>
 480          * This method never returns normally.
 481          *
 482          * @param message       the message for the log and exception.
 483          * @param cause         the causing exception (may be null).
 484          * @throws BugException always.
 485          */
 486         public void throwBugException(String message, Throwable cause) throws BugException {
 487                 BugException e = new BugException(message, cause);
 488                 log(createLogLine(0, LogLevel.ERROR, message, cause));
 489                 throw e;
 490         }
 491
 492
 493
 494
 495         /**
 496          * Create a LogLine object from the provided information.  This method must be
 497          * called directly from the called method in order for the trace position
 498          * to be correct!
 499          *
 500          * @param additionalLevels      how many additional stack trace levels to include on the line.
 501          * @param level                         the log level.
 502          * @param message                       the log message (null ok).
 503          * @param cause                         the log exception (null ok).
 504          *
 505          * @return                                      a LogLine populated with all necessary fields.
 506          */
 507         private LogLine createLogLine(int additionalLevels, LogLevel level, String message,
 508                         Throwable cause) {
 509                 TraceException trace;
 510                 if (level.atLeast(TRACING_LOG_LEVEL)) {
 511                         trace = new TraceException(2, 2 + additionalLevels);
 512                 } else {
 513                         trace = null;
 514                 }
 515                 return new LogLine(level, trace, message, cause);
 516         }
 517 }