SimpleLog xref

View Javadoc

    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *      http://www.apache.org/licenses/LICENSE-2.0
    10   *
    11   * Unless required by applicable law or agreed to in writing, software
    12   * distributed under the License is distributed on an "AS IS" BASIS,
    13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14   * See the License for the specific language governing permissions and
    15   * limitations under the License.
    16   */
    17
    18
    19  package org.apache.commons.logging.impl;
    20
    21  import java.io.InputStream;
    22  import java.io.Serializable;
    23  import java.lang.reflect.InvocationTargetException;
    24  import java.lang.reflect.Method;
    25  import java.security.AccessController;
    26  import java.security.PrivilegedAction;
    27  import java.text.DateFormat;
    28  import java.text.SimpleDateFormat;
    29  import java.util.Date;
    30  import java.util.Properties;
    31
    32  import org.apache.commons.logging.Log;
    33  import org.apache.commons.logging.LogConfigurationException;
    34
    35  /**
    36   * <p>Simple implementation of Log that sends all enabled log messages,
    37   * for all defined loggers, to System.err.  The following system properties
    38   * are supported to configure the behavior of this logger:</p>
    39   * <ul>
    40   * <li><code>org.apache.commons.logging.simplelog.defaultlog</code> -
    41   *     Default logging detail level for all instances of SimpleLog.
    42   *     Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
    43   *     If not specified, defaults to "info". </li>
    44   * <li><code>org.apache.commons.logging.simplelog.log.xxxxx</code> -
    45   *     Logging detail level for a SimpleLog instance named "xxxxx".
    46   *     Must be one of ("trace", "debug", "info", "warn", "error", or "fatal").
    47   *     If not specified, the default logging detail level is used.</li>
    48   * <li><code>org.apache.commons.logging.simplelog.showlogname</code> -
    49   *     Set to <code>true</code> if you want the Log instance name to be
    50   *     included in output messages. Defaults to <code>false</code>.</li>
    51   * <li><code>org.apache.commons.logging.simplelog.showShortLogname</code> -
    52   *     Set to <code>true</code> if you want the last component of the name to be
    53   *     included in output messages. Defaults to <code>true</code>.</li>
    54   * <li><code>org.apache.commons.logging.simplelog.showdatetime</code> -
    55   *     Set to <code>true</code> if you want the current date and time
    56   *     to be included in output messages. Default is <code>false</code>.</li>
    57   * <li><code>org.apache.commons.logging.simplelog.dateTimeFormat</code> -
    58   *     The date and time format to be used in the output messages.
    59   *     The pattern describing the date and time format is the same that is
    60   *     used in <code>java.text.SimpleDateFormat</code>. If the format is not
    61   *     specified or is invalid, the default format is used.
    62   *     The default format is <code>yyyy/MM/dd HH:mm:ss:SSS zzz</code>.</li>
    63   * </ul>
    64   *
    65   * <p>In addition to looking for system properties with the names specified
    66   * above, this implementation also checks for a class loader resource named
    67   * <code>"simplelog.properties"</code>, and includes any matching definitions
    68   * from this resource (if it exists).</p>
    69   *
    70   * @author <a href="mailto:sanders@apache.org">Scott Sanders</a>
    71   * @author Rod Waldhoff
    72   * @author Robert Burrell Donkin
    73   *
    74   * @version $Id: SimpleLog.java 581090 2007-10-01 22:01:06Z dennisl $
    75   */
    76  public class SimpleLog implements Log, Serializable {
    77
    78
    79      // ------------------------------------------------------- Class Attributes
    80
    81      /** All system properties used by <code>SimpleLog</code> start with this */
    82      static protected final String systemPrefix =
    83          "org.apache.commons.logging.simplelog.";
    84
    85      /** Properties loaded from simplelog.properties */
    86      static protected final Properties simpleLogProps = new Properties();
    87
    88      /** The default format to use when formating dates */
    89      static protected final String DEFAULT_DATE_TIME_FORMAT =
    90          "yyyy/MM/dd HH:mm:ss:SSS zzz";
    91
    92      /** Include the instance name in the log message? */
    93      static protected boolean showLogName = false;
    94      /** Include the short name ( last component ) of the logger in the log
    95       *  message. Defaults to true - otherwise we'll be lost in a flood of
    96       *  messages without knowing who sends them.
    97       */
    98      static protected boolean showShortName = true;
    99      /** Include the current time in the log message */
    100     static protected boolean showDateTime = false;
    101     /** The date and time format to use in the log message */
    102     static protected String dateTimeFormat = DEFAULT_DATE_TIME_FORMAT;
    103
    104     /**
    105      * Used to format times.
    106      * <p>
    107      * Any code that accesses this object should first obtain a lock on it,
    108      * ie use synchronized(dateFormatter); this requirement was introduced
    109      * in 1.1.1 to fix an existing thread safety bug (SimpleDateFormat.format
    110      * is not thread-safe).
    111      */
    112     static protected DateFormat dateFormatter = null;
    113
    114     // ---------------------------------------------------- Log Level Constants
    115
    116
    117     /** "Trace" level logging. */
    118     public static final int LOG_LEVEL_TRACE  = 1;
    119     /** "Debug" level logging. */
    120     public static final int LOG_LEVEL_DEBUG  = 2;
    121     /** "Info" level logging. */
    122     public static final int LOG_LEVEL_INFO   = 3;
    123     /** "Warn" level logging. */
    124     public static final int LOG_LEVEL_WARN   = 4;
    125     /** "Error" level logging. */
    126     public static final int LOG_LEVEL_ERROR  = 5;
    127     /** "Fatal" level logging. */
    128     public static final int LOG_LEVEL_FATAL  = 6;
    129
    130     /** Enable all logging levels */
    131     public static final int LOG_LEVEL_ALL    = (LOG_LEVEL_TRACE - 1);
    132
    133     /** Enable no logging levels */
    134     public static final int LOG_LEVEL_OFF    = (LOG_LEVEL_FATAL + 1);
    135
    136     // ------------------------------------------------------------ Initializer
    137
    138     private static String getStringProperty(String name) {
    139         String prop = null;
    140         try {
    141             prop = System.getProperty(name);
    142         } catch (SecurityException e) {
    143             ; // Ignore
    144         }
    145         return (prop == null) ? simpleLogProps.getProperty(name) : prop;
    146     }
    147
    148     private static String getStringProperty(String name, String dephault) {
    149         String prop = getStringProperty(name);
    150         return (prop == null) ? dephault : prop;
    151     }
    152
    153     private static boolean getBooleanProperty(String name, boolean dephault) {
    154         String prop = getStringProperty(name);
    155         return (prop == null) ? dephault : "true".equalsIgnoreCase(prop);
    156     }
    157
    158     // Initialize class attributes.
    159     // Load properties file, if found.
    160     // Override with system properties.
    161     static {
    162         // Add props from the resource simplelog.properties
    163         InputStream in = getResourceAsStream("simplelog.properties");
    164         if(null != in) {
    165             try {
    166                 simpleLogProps.load(in);
    167                 in.close();
    168             } catch(java.io.IOException e) {
    169                 // ignored
    170             }
    171         }
    172
    173         showLogName = getBooleanProperty( systemPrefix + "showlogname", showLogName);
    174         showShortName = getBooleanProperty( systemPrefix + "showShortLogname", showShortName);
    175         showDateTime = getBooleanProperty( systemPrefix + "showdatetime", showDateTime);
    176
    177         if(showDateTime) {
    178             dateTimeFormat = getStringProperty(systemPrefix + "dateTimeFormat",
    179                                                dateTimeFormat);
    180             try {
    181                 dateFormatter = new SimpleDateFormat(dateTimeFormat);
    182             } catch(IllegalArgumentException e) {
    183                 // If the format pattern is invalid - use the default format
    184                 dateTimeFormat = DEFAULT_DATE_TIME_FORMAT;
    185                 dateFormatter = new SimpleDateFormat(dateTimeFormat);
    186             }
    187         }
    188     }
    189
    190     // ------------------------------------------------------------- Attributes
    191
    192     /** The name of this simple log instance */
    193     protected String logName = null;
    194     /** The current log level */
    195     protected int currentLogLevel;
    196     /** The short name of this simple log instance */
    197     private String shortLogName = null;
    198
    199
    200     // ------------------------------------------------------------ Constructor
    201
    202     /**
    203      * Construct a simple log with given name.
    204      *
    205      * @param name log name
    206      */
    207     public SimpleLog(String name) {
    208
    209         logName = name;
    210
    211         // Set initial log level
    212         // Used to be: set default log level to ERROR
    213         // IMHO it should be lower, but at least info ( costin ).
    214         setLevel(SimpleLog.LOG_LEVEL_INFO);
    215
    216         // Set log level from properties
    217         String lvl = getStringProperty(systemPrefix + "log." + logName);
    218         int i = String.valueOf(name).lastIndexOf(".");
    219         while(null == lvl && i > -1) {
    220             name = name.substring(0,i);
    221             lvl = getStringProperty(systemPrefix + "log." + name);
    222             i = String.valueOf(name).lastIndexOf(".");
    223         }
    224
    225         if(null == lvl) {
    226             lvl =  getStringProperty(systemPrefix + "defaultlog");
    227         }
    228
    229         if("all".equalsIgnoreCase(lvl)) {
    230             setLevel(SimpleLog.LOG_LEVEL_ALL);
    231         } else if("trace".equalsIgnoreCase(lvl)) {
    232             setLevel(SimpleLog.LOG_LEVEL_TRACE);
    233         } else if("debug".equalsIgnoreCase(lvl)) {
    234             setLevel(SimpleLog.LOG_LEVEL_DEBUG);
    235         } else if("info".equalsIgnoreCase(lvl)) {
    236             setLevel(SimpleLog.LOG_LEVEL_INFO);
    237         } else if("warn".equalsIgnoreCase(lvl)) {
    238             setLevel(SimpleLog.LOG_LEVEL_WARN);
    239         } else if("error".equalsIgnoreCase(lvl)) {
    240             setLevel(SimpleLog.LOG_LEVEL_ERROR);
    241         } else if("fatal".equalsIgnoreCase(lvl)) {
    242             setLevel(SimpleLog.LOG_LEVEL_FATAL);
    243         } else if("off".equalsIgnoreCase(lvl)) {
    244             setLevel(SimpleLog.LOG_LEVEL_OFF);
    245         }
    246
    247     }
    248
    249
    250     // -------------------------------------------------------- Properties
    251
    252     /**
    253      * <p> Set logging level. </p>
    254      *
    255      * @param currentLogLevel new logging level
    256      */
    257     public void setLevel(int currentLogLevel) {
    258
    259         this.currentLogLevel = currentLogLevel;
    260
    261     }
    262
    263
    264     /**
    265      * <p> Get logging level. </p>
    266      */
    267     public int getLevel() {
    268
    269         return currentLogLevel;
    270     }
    271
    272
    273     // -------------------------------------------------------- Logging Methods
    274
    275
    276     /**
    277      * <p> Do the actual logging.
    278      * This method assembles the message
    279      * and then calls <code>write()</code> to cause it to be written.</p>
    280      *
    281      * @param type One of the LOG_LEVEL_XXX constants defining the log level
    282      * @param message The message itself (typically a String)
    283      * @param t The exception whose stack trace should be logged
    284      */
    285     protected void log(int type, Object message, Throwable t) {
    286         // Use a string buffer for better performance
    287         StringBuffer buf = new StringBuffer();
    288
    289         // Append date-time if so configured
    290         if(showDateTime) {
    291             Date now = new Date();
    292             String dateText;
    293             synchronized(dateFormatter) {
    294                 dateText = dateFormatter.format(now);
    295             }
    296             buf.append(dateText);
    297             buf.append(" ");
    298         }
    299
    300         // Append a readable representation of the log level
    301         switch(type) {
    302             case SimpleLog.LOG_LEVEL_TRACE: buf.append("[TRACE] "); break;
    303             case SimpleLog.LOG_LEVEL_DEBUG: buf.append("[DEBUG] "); break;
    304             case SimpleLog.LOG_LEVEL_INFO:  buf.append("[INFO] ");  break;
    305             case SimpleLog.LOG_LEVEL_WARN:  buf.append("[WARN] ");  break;
    306             case SimpleLog.LOG_LEVEL_ERROR: buf.append("[ERROR] "); break;
    307             case SimpleLog.LOG_LEVEL_FATAL: buf.append("[FATAL] "); break;
    308         }
    309
    310         // Append the name of the log instance if so configured
    311         if( showShortName) {
    312             if( shortLogName==null ) {
    313                 // Cut all but the last component of the name for both styles
    314                 shortLogName = logName.substring(logName.lastIndexOf(".") + 1);
    315                 shortLogName =
    316                     shortLogName.substring(shortLogName.lastIndexOf("/") + 1);
    317             }
    318             buf.append(String.valueOf(shortLogName)).append(" - ");
    319         } else if(showLogName) {
    320             buf.append(String.valueOf(logName)).append(" - ");
    321         }
    322
    323         // Append the message
    324         buf.append(String.valueOf(message));
    325
    326         // Append stack trace if not null
    327         if(t != null) {
    328             buf.append(" <");
    329             buf.append(t.toString());
    330             buf.append(">");
    331
    332             java.io.StringWriter sw= new java.io.StringWriter(1024);
    333             java.io.PrintWriter pw= new java.io.PrintWriter(sw);
    334             t.printStackTrace(pw);
    335             pw.close();
    336             buf.append(sw.toString());
    337         }
    338
    339         // Print to the appropriate destination
    340         write(buf);
    341
    342     }
    343
    344
    345     /**
    346      * <p>Write the content of the message accumulated in the specified
    347      * <code>StringBuffer</code> to the appropriate output destination.  The
    348      * default implementation writes to <code>System.err</code>.</p>
    349      *
    350      * @param buffer A <code>StringBuffer</code> containing the accumulated
    351      *  text to be logged
    352      */
    353     protected void write(StringBuffer buffer) {
    354
    355         System.err.println(buffer.toString());
    356
    357     }
    358
    359
    360     /**
    361      * Is the given log level currently enabled?
    362      *
    363      * @param logLevel is this level enabled?
    364      */
    365     protected boolean isLevelEnabled(int logLevel) {
    366         // log level are numerically ordered so can use simple numeric
    367         // comparison
    368         return (logLevel >= currentLogLevel);
    369     }
    370
    371
    372     // -------------------------------------------------------- Log Implementation
    373
    374
    375     /**
    376      * Logs a message with
    377      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_DEBUG</code>.
    378      *
    379      * @param message to log
    380      * @see org.apache.commons.logging.Log#debug(Object)
    381      */
    382     public final void debug(Object message) {
    383
    384         if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
    385             log(SimpleLog.LOG_LEVEL_DEBUG, message, null);
    386         }
    387     }
    388
    389
    390     /**
    391      * Logs a message with
    392      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_DEBUG</code>.
    393      *
    394      * @param message to log
    395      * @param t log this cause
    396      * @see org.apache.commons.logging.Log#debug(Object, Throwable)
    397      */
    398     public final void debug(Object message, Throwable t) {
    399
    400         if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
    401             log(SimpleLog.LOG_LEVEL_DEBUG, message, t);
    402         }
    403     }
    404
    405
    406     /**
    407      * Logs a message with
    408      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_TRACE</code>.
    409      *
    410      * @param message to log
    411      * @see org.apache.commons.logging.Log#trace(Object)
    412      */
    413     public final void trace(Object message) {
    414
    415         if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
    416             log(SimpleLog.LOG_LEVEL_TRACE, message, null);
    417         }
    418     }
    419
    420
    421     /**
    422      * Logs a message with
    423      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_TRACE</code>.
    424      *
    425      * @param message to log
    426      * @param t log this cause
    427      * @see org.apache.commons.logging.Log#trace(Object, Throwable)
    428      */
    429     public final void trace(Object message, Throwable t) {
    430
    431         if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
    432             log(SimpleLog.LOG_LEVEL_TRACE, message, t);
    433         }
    434     }
    435
    436
    437     /**
    438      * Logs a message with
    439      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_INFO</code>.
    440      *
    441      * @param message to log
    442      * @see org.apache.commons.logging.Log#info(Object)
    443      */
    444     public final void info(Object message) {
    445
    446         if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
    447             log(SimpleLog.LOG_LEVEL_INFO,message,null);
    448         }
    449     }
    450
    451
    452     /**
    453      * Logs a message with
    454      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_INFO</code>.
    455      *
    456      * @param message to log
    457      * @param t log this cause
    458      * @see org.apache.commons.logging.Log#info(Object, Throwable)
    459      */
    460     public final void info(Object message, Throwable t) {
    461
    462         if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
    463             log(SimpleLog.LOG_LEVEL_INFO, message, t);
    464         }
    465     }
    466
    467
    468     /**
    469      * Logs a message with
    470      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_WARN</code>.
    471      *
    472      * @param message to log
    473      * @see org.apache.commons.logging.Log#warn(Object)
    474      */
    475     public final void warn(Object message) {
    476
    477         if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
    478             log(SimpleLog.LOG_LEVEL_WARN, message, null);
    479         }
    480     }
    481
    482
    483     /**
    484      * Logs a message with
    485      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_WARN</code>.
    486      *
    487      * @param message to log
    488      * @param t log this cause
    489      * @see org.apache.commons.logging.Log#warn(Object, Throwable)
    490      */
    491     public final void warn(Object message, Throwable t) {
    492
    493         if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
    494             log(SimpleLog.LOG_LEVEL_WARN, message, t);
    495         }
    496     }
    497
    498
    499     /**
    500      * Logs a message with
    501      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_ERROR</code>.
    502      *
    503      * @param message to log
    504      * @see org.apache.commons.logging.Log#error(Object)
    505      */
    506     public final void error(Object message) {
    507
    508         if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
    509             log(SimpleLog.LOG_LEVEL_ERROR, message, null);
    510         }
    511     }
    512
    513
    514     /**
    515      * Logs a message with
    516      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_ERROR</code>.
    517      *
    518      * @param message to log
    519      * @param t log this cause
    520      * @see org.apache.commons.logging.Log#error(Object, Throwable)
    521      */
    522     public final void error(Object message, Throwable t) {
    523
    524         if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
    525             log(SimpleLog.LOG_LEVEL_ERROR, message, t);
    526         }
    527     }
    528
    529
    530     /**
    531      * Log a message with
    532      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_FATAL</code>.
    533      *
    534      * @param message to log
    535      * @see org.apache.commons.logging.Log#fatal(Object)
    536      */
    537     public final void fatal(Object message) {
    538
    539         if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
    540             log(SimpleLog.LOG_LEVEL_FATAL, message, null);
    541         }
    542     }
    543
    544
    545     /**
    546      * Logs a message with
    547      * <code>org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_FATAL</code>.
    548      *
    549      * @param message to log
    550      * @param t log this cause
    551      * @see org.apache.commons.logging.Log#fatal(Object, Throwable)
    552      */
    553     public final void fatal(Object message, Throwable t) {
    554
    555         if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
    556             log(SimpleLog.LOG_LEVEL_FATAL, message, t);
    557         }
    558     }
    559
    560
    561     /**
    562      * <p> Are debug messages currently enabled? </p>
    563      *
    564      * <p> This allows expensive operations such as <code>String</code>
    565      * concatenation to be avoided when the message will be ignored by the
    566      * logger. </p>
    567      */
    568     public final boolean isDebugEnabled() {
    569
    570         return isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG);
    571     }
    572
    573
    574     /**
    575      * <p> Are error messages currently enabled? </p>
    576      *
    577      * <p> This allows expensive operations such as <code>String</code>
    578      * concatenation to be avoided when the message will be ignored by the
    579      * logger. </p>
    580      */
    581     public final boolean isErrorEnabled() {
    582
    583         return isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR);
    584     }
    585
    586
    587     /**
    588      * <p> Are fatal messages currently enabled? </p>
    589      *
    590      * <p> This allows expensive operations such as <code>String</code>
    591      * concatenation to be avoided when the message will be ignored by the
    592      * logger. </p>
    593      */
    594     public final boolean isFatalEnabled() {
    595
    596         return isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL);
    597     }
    598
    599
    600     /**
    601      * <p> Are info messages currently enabled? </p>
    602      *
    603      * <p> This allows expensive operations such as <code>String</code>
    604      * concatenation to be avoided when the message will be ignored by the
    605      * logger. </p>
    606      */
    607     public final boolean isInfoEnabled() {
    608
    609         return isLevelEnabled(SimpleLog.LOG_LEVEL_INFO);
    610     }
    611
    612
    613     /**
    614      * <p> Are trace messages currently enabled? </p>
    615      *
    616      * <p> This allows expensive operations such as <code>String</code>
    617      * concatenation to be avoided when the message will be ignored by the
    618      * logger. </p>
    619      */
    620     public final boolean isTraceEnabled() {
    621
    622         return isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE);
    623     }
    624
    625
    626     /**
    627      * <p> Are warn messages currently enabled? </p>
    628      *
    629      * <p> This allows expensive operations such as <code>String</code>
    630      * concatenation to be avoided when the message will be ignored by the
    631      * logger. </p>
    632      */
    633     public final boolean isWarnEnabled() {
    634
    635         return isLevelEnabled(SimpleLog.LOG_LEVEL_WARN);
    636     }
    637
    638
    639     /**
    640      * Return the thread context class loader if available.
    641      * Otherwise return null.
    642      *
    643      * The thread context class loader is available for JDK 1.2
    644      * or later, if certain security conditions are met.
    645      *
    646      * @exception LogConfigurationException if a suitable class loader
    647      * cannot be identified.
    648      */
    649     private static ClassLoader getContextClassLoader()
    650     {
    651         ClassLoader classLoader = null;
    652
    653         if (classLoader == null) {
    654             try {
    655                 // Are we running on a JDK 1.2 or later system?
    656                 Method method = Thread.class.getMethod("getContextClassLoader",
    657                         (Class[]) null);
    658
    659                 // Get the thread context class loader (if there is one)
    660                 try {
    661                     classLoader = (ClassLoader)method.invoke(Thread.currentThread(),
    662                             (Class[]) null);
    663                 } catch (IllegalAccessException e) {
    664                     ;  // ignore
    665                 } catch (InvocationTargetException e) {
    666                     /**
    667                      * InvocationTargetException is thrown by 'invoke' when
    668                      * the method being invoked (getContextClassLoader) throws
    669                      * an exception.
    670                      *
    671                      * getContextClassLoader() throws SecurityException when
    672                      * the context class loader isn't an ancestor of the
    673                      * calling class's class loader, or if security
    674                      * permissions are restricted.
    675                      *
    676                      * In the first case (not related), we want to ignore and
    677                      * keep going.  We cannot help but also ignore the second
    678                      * with the logic below, but other calls elsewhere (to
    679                      * obtain a class loader) will trigger this exception where
    680                      * we can make a distinction.
    681                      */
    682                     if (e.getTargetException() instanceof SecurityException) {
    683                         ;  // ignore
    684                     } else {
    685                         // Capture 'e.getTargetException()' exception for details
    686                         // alternate: log 'e.getTargetException()', and pass back 'e'.
    687                         throw new LogConfigurationException
    688                             ("Unexpected InvocationTargetException", e.getTargetException());
    689                     }
    690                 }
    691             } catch (NoSuchMethodException e) {
    692                 // Assume we are running on JDK 1.1
    693                 ;  // ignore
    694             }
    695         }
    696
    697         if (classLoader == null) {
    698             classLoader = SimpleLog.class.getClassLoader();
    699         }
    700
    701         // Return the selected class loader
    702         return classLoader;
    703     }
    704
    705     private static InputStream getResourceAsStream(final String name)
    706     {
    707         return (InputStream)AccessController.doPrivileged(
    708             new PrivilegedAction() {
    709                 public Object run() {
    710                     ClassLoader threadCL = getContextClassLoader();
    711
    712                     if (threadCL != null) {
    713                         return threadCL.getResourceAsStream(name);
    714                     } else {
    715                         return ClassLoader.getSystemResourceAsStream(name);
    716                     }
    717                 }
    718             });
    719     }
    720 }
    721