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  package org.apache.commons.logging.impl;
    19
    20
    21  import java.lang.reflect.Constructor;
    22  import java.lang.reflect.InvocationTargetException;
    23  import java.lang.reflect.Method;
    24  import java.net.URL;
    25  import java.security.AccessController;
    26  import java.security.PrivilegedAction;
    27  import java.util.Enumeration;
    28  import java.util.Hashtable;
    29  import java.util.Vector;
    30
    31  import org.apache.commons.logging.Log;
    32  import org.apache.commons.logging.LogConfigurationException;
    33  import org.apache.commons.logging.LogFactory;
    34
    35
    36  /**
    37   * <p>Concrete subclass of {@link LogFactory} that implements the
    38   * following algorithm to dynamically select a logging implementation
    39   * class to instantiate a wrapper for.</p>
    40   * <ul>
    41   * <li>Use a factory configuration attribute named
    42   *     <code>org.apache.commons.logging.Log</code> to identify the
    43   *     requested implementation class.</li>
    44   * <li>Use the <code>org.apache.commons.logging.Log</code> system property
    45   *     to identify the requested implementation class.</li>
    46   * <li>If <em>Log4J</em> is available, return an instance of
    47   *     <code>org.apache.commons.logging.impl.Log4JLogger</code>.</li>
    48   * <li>If <em>JDK 1.4 or later</em> is available, return an instance of
    49   *     <code>org.apache.commons.logging.impl.Jdk14Logger</code>.</li>
    50   * <li>Otherwise, return an instance of
    51   *     <code>org.apache.commons.logging.impl.SimpleLog</code>.</li>
    52   * </ul>
    53   *
    54   * <p>If the selected {@link Log} implementation class has a
    55   * <code>setLogFactory()</code> method that accepts a {@link LogFactory}
    56   * parameter, this method will be called on each newly created instance
    57   * to identify the associated factory.  This makes factory configuration
    58   * attributes available to the Log instance, if it so desires.</p>
    59   *
    60   * <p>This factory will remember previously created <code>Log</code> instances
    61   * for the same name, and will return them on repeated requests to the
    62   * <code>getInstance()</code> method.</p>
    63   *
    64   * @author Rod Waldhoff
    65   * @author Craig R. McClanahan
    66   * @author Richard A. Sitze
    67   * @author Brian Stansberry
    68   * @version $Revision: 581090 $ $Date: 2007-10-02 00:01:06 +0200 (ti, 02 okt 2007) $
    69   */
    70
    71  public class LogFactoryImpl extends LogFactory {
    72
    73
    74      /** Log4JLogger class name */
    75      private static final String LOGGING_IMPL_LOG4J_LOGGER = "org.apache.commons.logging.impl.Log4JLogger";
    76      /** Jdk14Logger class name */
    77      private static final String LOGGING_IMPL_JDK14_LOGGER = "org.apache.commons.logging.impl.Jdk14Logger";
    78      /** Jdk13LumberjackLogger class name */
    79      private static final String LOGGING_IMPL_LUMBERJACK_LOGGER = "org.apache.commons.logging.impl.Jdk13LumberjackLogger";
    80      /** SimpleLog class name */
    81      private static final String LOGGING_IMPL_SIMPLE_LOGGER = "org.apache.commons.logging.impl.SimpleLog";
    82
    83      private static final String PKG_IMPL="org.apache.commons.logging.impl.";
    84      private static final int PKG_LEN = PKG_IMPL.length();
    85
    86      // ----------------------------------------------------------- Constructors
    87
    88
    89
    90      /**
    91       * Public no-arguments constructor required by the lookup mechanism.
    92       */
    93      public LogFactoryImpl() {
    94          super();
    95          initDiagnostics();  // method on this object
    96          if (isDiagnosticsEnabled()) {
    97              logDiagnostic("Instance created.");
    98          }
    99      }
    100
    101
    102     // ----------------------------------------------------- Manifest Constants
    103
    104
    105     /**
    106      * The name (<code>org.apache.commons.logging.Log</code>) of the system
    107      * property identifying our {@link Log} implementation class.
    108      */
    109     public static final String LOG_PROPERTY =
    110         "org.apache.commons.logging.Log";
    111
    112
    113     /**
    114      * The deprecated system property used for backwards compatibility with
    115      * old versions of JCL.
    116      */
    117     protected static final String LOG_PROPERTY_OLD =
    118         "org.apache.commons.logging.log";
    119
    120     /**
    121      * The name (<code>org.apache.commons.logging.Log.allowFlawedContext</code>)
    122      * of the system property which can be set true/false to
    123      * determine system behaviour when a bad context-classloader is encountered.
    124      * When set to false, a LogConfigurationException is thrown if
    125      * LogFactoryImpl is loaded via a child classloader of the TCCL (this
    126      * should never happen in sane systems).
    127      *
    128      * Default behaviour: true (tolerates bad context classloaders)
    129      *
    130      * See also method setAttribute.
    131      */
    132     public static final String ALLOW_FLAWED_CONTEXT_PROPERTY =
    133         "org.apache.commons.logging.Log.allowFlawedContext";
    134
    135     /**
    136      * The name (<code>org.apache.commons.logging.Log.allowFlawedDiscovery</code>)
    137      * of the system property which can be set true/false to
    138      * determine system behaviour when a bad logging adapter class is
    139      * encountered during logging discovery. When set to false, an
    140      * exception will be thrown and the app will fail to start. When set
    141      * to true, discovery will continue (though the user might end up
    142      * with a different logging implementation than they expected).
    143      *
    144      * Default behaviour: true (tolerates bad logging adapters)
    145      *
    146      * See also method setAttribute.
    147      */
    148     public static final String ALLOW_FLAWED_DISCOVERY_PROPERTY =
    149         "org.apache.commons.logging.Log.allowFlawedDiscovery";
    150
    151     /**
    152      * The name (<code>org.apache.commons.logging.Log.allowFlawedHierarchy</code>)
    153      * of the system property which can be set true/false to
    154      * determine system behaviour when a logging adapter class is
    155      * encountered which has bound to the wrong Log class implementation.
    156      * When set to false, an exception will be thrown and the app will fail
    157      * to start. When set to true, discovery will continue (though the user
    158      * might end up with a different logging implementation than they expected).
    159      *
    160      * Default behaviour: true (tolerates bad Log class hierarchy)
    161      *
    162      * See also method setAttribute.
    163      */
    164     public static final String ALLOW_FLAWED_HIERARCHY_PROPERTY =
    165         "org.apache.commons.logging.Log.allowFlawedHierarchy";
    166
    167
    168     /**
    169      * The names of classes that will be tried (in order) as logging
    170      * adapters. Each class is expected to implement the Log interface,
    171      * and to throw NoClassDefFound or ExceptionInInitializerError when
    172      * loaded if the underlying logging library is not available. Any
    173      * other error indicates that the underlying logging library is available
    174      * but broken/unusable for some reason.
    175      */
    176     private static final String[] classesToDiscover = {
    177             LOGGING_IMPL_LOG4J_LOGGER,
    178             "org.apache.commons.logging.impl.Jdk14Logger",
    179             "org.apache.commons.logging.impl.Jdk13LumberjackLogger",
    180             "org.apache.commons.logging.impl.SimpleLog"
    181     };
    182
    183
    184     // ----------------------------------------------------- Instance Variables
    185
    186     /**
    187      * Determines whether logging classes should be loaded using the thread-context
    188      * classloader, or via the classloader that loaded this LogFactoryImpl class.
    189      */
    190     private boolean useTCCL = true;
    191
    192     /**
    193      * The string prefixed to every message output by the logDiagnostic method.
    194      */
    195     private String diagnosticPrefix;
    196
    197
    198     /**
    199      * Configuration attributes.
    200      */
    201     protected Hashtable attributes = new Hashtable();
    202
    203
    204     /**
    205      * The {@link org.apache.commons.logging.Log} instances that have
    206      * already been created, keyed by logger name.
    207      */
    208     protected Hashtable instances = new Hashtable();
    209
    210
    211     /**
    212      * Name of the class implementing the Log interface.
    213      */
    214     private String logClassName;
    215
    216
    217     /**
    218      * The one-argument constructor of the
    219      * {@link org.apache.commons.logging.Log}
    220      * implementation class that will be used to create new instances.
    221      * This value is initialized by <code>getLogConstructor()</code>,
    222      * and then returned repeatedly.
    223      */
    224     protected Constructor logConstructor = null;
    225
    226
    227     /**
    228      * The signature of the Constructor to be used.
    229      */
    230     protected Class logConstructorSignature[] =
    231     { java.lang.String.class };
    232
    233
    234     /**
    235      * The one-argument <code>setLogFactory</code> method of the selected
    236      * {@link org.apache.commons.logging.Log} method, if it exists.
    237      */
    238     protected Method logMethod = null;
    239
    240
    241     /**
    242      * The signature of the <code>setLogFactory</code> method to be used.
    243      */
    244     protected Class logMethodSignature[] =
    245     { LogFactory.class };
    246
    247     /**
    248      * See getBaseClassLoader and initConfiguration.
    249      */
    250     private boolean allowFlawedContext;
    251
    252     /**
    253      * See handleFlawedDiscovery and initConfiguration.
    254      */
    255     private boolean allowFlawedDiscovery;
    256
    257     /**
    258      * See handleFlawedHierarchy and initConfiguration.
    259      */
    260     private boolean allowFlawedHierarchy;
    261
    262     // --------------------------------------------------------- Public Methods
    263
    264
    265     /**
    266      * Return the configuration attribute with the specified name (if any),
    267      * or <code>null</code> if there is no such attribute.
    268      *
    269      * @param name Name of the attribute to return
    270      */
    271     public Object getAttribute(String name) {
    272
    273         return (attributes.get(name));
    274
    275     }
    276
    277
    278     /**
    279      * Return an array containing the names of all currently defined
    280      * configuration attributes.  If there are no such attributes, a zero
    281      * length array is returned.
    282      */
    283     public String[] getAttributeNames() {
    284
    285         Vector names = new Vector();
    286         Enumeration keys = attributes.keys();
    287         while (keys.hasMoreElements()) {
    288             names.addElement((String) keys.nextElement());
    289         }
    290         String results[] = new String[names.size()];
    291         for (int i = 0; i < results.length; i++) {
    292             results[i] = (String) names.elementAt(i);
    293         }
    294         return (results);
    295
    296     }
    297
    298
    299     /**
    300      * Convenience method to derive a name from the specified class and
    301      * call <code>getInstance(String)</code> with it.
    302      *
    303      * @param clazz Class for which a suitable Log name will be derived
    304      *
    305      * @exception LogConfigurationException if a suitable <code>Log</code>
    306      *  instance cannot be returned
    307      */
    308     public Log getInstance(Class clazz) throws LogConfigurationException {
    309
    310         return (getInstance(clazz.getName()));
    311
    312     }
    313
    314
    315     /**
    316      * <p>Construct (if necessary) and return a <code>Log</code> instance,
    317      * using the factory's current set of configuration attributes.</p>
    318      *
    319      * <p><strong>NOTE</strong> - Depending upon the implementation of
    320      * the <code>LogFactory</code> you are using, the <code>Log</code>
    321      * instance you are returned may or may not be local to the current
    322      * application, and may or may not be returned again on a subsequent
    323      * call with the same name argument.</p>
    324      *
    325      * @param name Logical name of the <code>Log</code> instance to be
    326      *  returned (the meaning of this name is only known to the underlying
    327      *  logging implementation that is being wrapped)
    328      *
    329      * @exception LogConfigurationException if a suitable <code>Log</code>
    330      *  instance cannot be returned
    331      */
    332     public Log getInstance(String name) throws LogConfigurationException {
    333
    334         Log instance = (Log) instances.get(name);
    335         if (instance == null) {
    336             instance = newInstance(name);
    337             instances.put(name, instance);
    338         }
    339         return (instance);
    340
    341     }
    342
    343
    344     /**
    345      * Release any internal references to previously created
    346      * {@link org.apache.commons.logging.Log}
    347      * instances returned by this factory.  This is useful in environments
    348      * like servlet containers, which implement application reloading by
    349      * throwing away a ClassLoader.  Dangling references to objects in that
    350      * class loader would prevent garbage collection.
    351      */
    352     public void release() {
    353
    354         logDiagnostic("Releasing all known loggers");
    355         instances.clear();
    356     }
    357
    358
    359     /**
    360      * Remove any configuration attribute associated with the specified name.
    361      * If there is no such attribute, no action is taken.
    362      *
    363      * @param name Name of the attribute to remove
    364      */
    365     public void removeAttribute(String name) {
    366
    367         attributes.remove(name);
    368
    369     }
    370
    371
    372     /**
    373      * Set the configuration attribute with the specified name.  Calling
    374      * this with a <code>null</code> value is equivalent to calling
    375      * <code>removeAttribute(name)</code>.
    376      * <p>
    377      * This method can be used to set logging configuration programmatically
    378      * rather than via system properties. It can also be used in code running
    379      * within a container (such as a webapp) to configure behaviour on a
    380      * per-component level instead of globally as system properties would do.
    381      * To use this method instead of a system property, call
    382      * <pre>
    383      * LogFactory.getFactory().setAttribute(...)
    384      * </pre>
    385      * This must be done before the first Log object is created; configuration
    386      * changes after that point will be ignored.
    387      * <p>
    388      * This method is also called automatically if LogFactory detects a
    389      * commons-logging.properties file; every entry in that file is set
    390      * automatically as an attribute here.
    391      *
    392      * @param name Name of the attribute to set
    393      * @param value Value of the attribute to set, or <code>null</code>
    394      *  to remove any setting for this attribute
    395      */
    396     public void setAttribute(String name, Object value) {
    397
    398         if (logConstructor != null) {
    399             logDiagnostic("setAttribute: call too late; configuration already performed.");
    400         }
    401
    402         if (value == null) {
    403             attributes.remove(name);
    404         } else {
    405             attributes.put(name, value);
    406         }
    407
    408         if (name.equals(TCCL_KEY)) {
    409             useTCCL = Boolean.valueOf(value.toString()).booleanValue();
    410         }
    411
    412     }
    413
    414
    415     // ------------------------------------------------------
    416     // Static Methods
    417     //
    418     // These methods only defined as workarounds for a java 1.2 bug;
    419     // theoretically none of these are needed.
    420     // ------------------------------------------------------
    421
    422     /**
    423      * Gets the context classloader.
    424      * This method is a workaround for a java 1.2 compiler bug.
    425      * @since 1.1
    426      */
    427     protected static ClassLoader getContextClassLoader() throws LogConfigurationException {
    428         return LogFactory.getContextClassLoader();
    429     }
    430
    431
    432     /**
    433      * Workaround for bug in Java1.2; in theory this method is not needed.
    434      * See LogFactory.isDiagnosticsEnabled.
    435      */
    436     protected static boolean isDiagnosticsEnabled() {
    437         return LogFactory.isDiagnosticsEnabled();
    438     }
    439
    440
    441     /**
    442      * Workaround for bug in Java1.2; in theory this method is not needed.
    443      * See LogFactory.getClassLoader.
    444      * @since 1.1
    445      */
    446     protected static ClassLoader getClassLoader(Class clazz) {
    447         return LogFactory.getClassLoader(clazz);
    448     }
    449
    450
    451     // ------------------------------------------------------ Protected Methods
    452
    453     /**
    454      * Calculate and cache a string that uniquely identifies this instance,
    455      * including which classloader the object was loaded from.
    456      * <p>
    457      * This string will later be prefixed to each "internal logging" message
    458      * emitted, so that users can clearly see any unexpected behaviour.
    459      * <p>
    460      * Note that this method does not detect whether internal logging is
    461      * enabled or not, nor where to output stuff if it is; that is all
    462      * handled by the parent LogFactory class. This method just computes
    463      * its own unique prefix for log messages.
    464      */
    465     private void initDiagnostics() {
    466         // It would be nice to include an identifier of the context classloader
    467         // that this LogFactoryImpl object is responsible for. However that
    468         // isn't possible as that information isn't available. It is possible
    469         // to figure this out by looking at the logging from LogFactory to
    470         // see the context & impl ids from when this object was instantiated,
    471         // in order to link the impl id output as this object's prefix back to
    472         // the context it is intended to manage.
    473         // Note that this prefix should be kept consistent with that
    474         // in LogFactory.
    475         Class clazz = this.getClass();
    476         ClassLoader classLoader = getClassLoader(clazz);
    477         String classLoaderName;
    478         try {
    479             if (classLoader == null) {
    480                 classLoaderName = "BOOTLOADER";
    481             } else {
    482                 classLoaderName = objectId(classLoader);
    483             }
    484         } catch(SecurityException e) {
    485             classLoaderName = "UNKNOWN";
    486         }
    487         diagnosticPrefix = "[LogFactoryImpl@" + System.identityHashCode(this) + " from " + classLoaderName + "] ";
    488     }
    489
    490
    491     /**
    492      * Output a diagnostic message to a user-specified destination (if the
    493      * user has enabled diagnostic logging).
    494      *
    495      * @param msg diagnostic message
    496      * @since 1.1
    497      */
    498     protected void logDiagnostic(String msg) {
    499         if (isDiagnosticsEnabled()) {
    500             logRawDiagnostic(diagnosticPrefix + msg);
    501         }
    502     }
    503
    504     /**
    505      * Return the fully qualified Java classname of the {@link Log}
    506      * implementation we will be using.
    507      *
    508      * @deprecated  Never invoked by this class; subclasses should not assume
    509      *              it will be.
    510      */
    511     protected String getLogClassName() {
    512
    513         if (logClassName == null) {
    514             discoverLogImplementation(getClass().getName());
    515         }
    516
    517         return logClassName;
    518     }
    519
    520
    521     /**
    522      * <p>Return the <code>Constructor</code> that can be called to instantiate
    523      * new {@link org.apache.commons.logging.Log} instances.</p>
    524      *
    525      * <p><strong>IMPLEMENTATION NOTE</strong> - Race conditions caused by
    526      * calling this method from more than one thread are ignored, because
    527      * the same <code>Constructor</code> instance will ultimately be derived
    528      * in all circumstances.</p>
    529      *
    530      * @exception LogConfigurationException if a suitable constructor
    531      *  cannot be returned
    532      *
    533      * @deprecated  Never invoked by this class; subclasses should not assume
    534      *              it will be.
    535      */
    536     protected Constructor getLogConstructor()
    537         throws LogConfigurationException {
    538
    539         // Return the previously identified Constructor (if any)
    540         if (logConstructor == null) {
    541             discoverLogImplementation(getClass().getName());
    542         }
    543
    544         return logConstructor;
    545     }
    546
    547
    548     /**
    549      * Is <em>JDK 1.3 with Lumberjack</em> logging available?
    550      *
    551      * @deprecated  Never invoked by this class; subclasses should not assume
    552      *              it will be.
    553      */
    554     protected boolean isJdk13LumberjackAvailable() {
    555         return isLogLibraryAvailable(
    556                 "Jdk13Lumberjack",
    557                 "org.apache.commons.logging.impl.Jdk13LumberjackLogger");
    558     }
    559
    560
    561     /**
    562      * <p>Return <code>true</code> if <em>JDK 1.4 or later</em> logging
    563      * is available.  Also checks that the <code>Throwable</code> class
    564      * supports <code>getStackTrace()</code>, which is required by
    565      * Jdk14Logger.</p>
    566      *
    567      * @deprecated  Never invoked by this class; subclasses should not assume
    568      *              it will be.
    569      */
    570     protected boolean isJdk14Available() {
    571         return isLogLibraryAvailable(
    572                 "Jdk14",
    573                 "org.apache.commons.logging.impl.Jdk14Logger");
    574     }
    575
    576
    577     /**
    578      * Is a <em>Log4J</em> implementation available?
    579      *
    580      * @deprecated  Never invoked by this class; subclasses should not assume
    581      *              it will be.
    582      */
    583     protected boolean isLog4JAvailable() {
    584         return isLogLibraryAvailable(
    585                 "Log4J",
    586                 LOGGING_IMPL_LOG4J_LOGGER);
    587     }
    588
    589
    590     /**
    591      * Create and return a new {@link org.apache.commons.logging.Log}
    592      * instance for the specified name.
    593      *
    594      * @param name Name of the new logger
    595      *
    596      * @exception LogConfigurationException if a new instance cannot
    597      *  be created
    598      */
    599     protected Log newInstance(String name) throws LogConfigurationException {
    600
    601         Log instance = null;
    602         try {
    603             if (logConstructor == null) {
    604                 instance = discoverLogImplementation(name);
    605             }
    606             else {
    607                 Object params[] = { name };
    608                 instance = (Log) logConstructor.newInstance(params);
    609             }
    610
    611             if (logMethod != null) {
    612                 Object params[] = { this };
    613                 logMethod.invoke(instance, params);
    614             }
    615
    616             return (instance);
    617
    618         } catch (LogConfigurationException lce) {
    619
    620             // this type of exception means there was a problem in discovery
    621             // and we've already output diagnostics about the issue, etc.;
    622             // just pass it on
    623             throw (LogConfigurationException) lce;
    624
    625         } catch (InvocationTargetException e) {
    626             // A problem occurred invoking the Constructor or Method
    627             // previously discovered
    628             Throwable c = e.getTargetException();
    629             if (c != null) {
    630                 throw new LogConfigurationException(c);
    631             } else {
    632                 throw new LogConfigurationException(e);
    633             }
    634         } catch (Throwable t) {
    635             // A problem occurred invoking the Constructor or Method
    636             // previously discovered
    637             throw new LogConfigurationException(t);
    638         }
    639     }
    640
    641
    642     //  ------------------------------------------------------ Private Methods
    643
    644     /**
    645      * Calls LogFactory.directGetContextClassLoader under the control of an
    646      * AccessController class. This means that java code running under a
    647      * security manager that forbids access to ClassLoaders will still work
    648      * if this class is given appropriate privileges, even when the caller
    649      * doesn't have such privileges. Without using an AccessController, the
    650      * the entire call stack must have the privilege before the call is
    651      * allowed.
    652      *
    653      * @return the context classloader associated with the current thread,
    654      * or null if security doesn't allow it.
    655      *
    656      * @throws LogConfigurationException if there was some weird error while
    657      * attempting to get the context classloader.
    658      *
    659      * @throws SecurityException if the current java security policy doesn't
    660      * allow this class to access the context classloader.
    661      */
    662     private static ClassLoader getContextClassLoaderInternal()
    663     throws LogConfigurationException {
    664         return (ClassLoader)AccessController.doPrivileged(
    665             new PrivilegedAction() {
    666                 public Object run() {
    667                     return LogFactory.directGetContextClassLoader();
    668                 }
    669             });
    670     }
    671
    672     /**
    673      * Read the specified system property, using an AccessController so that
    674      * the property can be read if JCL has been granted the appropriate
    675      * security rights even if the calling code has not.
    676      * <p>
    677      * Take care not to expose the value returned by this method to the
    678      * calling application in any way; otherwise the calling app can use that
    679      * info to access data that should not be available to it.
    680      */
    681     private static String getSystemProperty(final String key, final String def)
    682     throws SecurityException {
    683         return (String) AccessController.doPrivileged(
    684                 new PrivilegedAction() {
    685                     public Object run() {
    686                         return System.getProperty(key, def);
    687                     }
    688                 });
    689     }
    690
    691     /**
    692      * Fetch the parent classloader of a specified classloader.
    693      * <p>
    694      * If a SecurityException occurs, null is returned.
    695      * <p>
    696      * Note that this method is non-static merely so logDiagnostic is available.
    697      */
    698     private ClassLoader getParentClassLoader(final ClassLoader cl) {
    699         try {
    700             return (ClassLoader)AccessController.doPrivileged(
    701                     new PrivilegedAction() {
    702                         public Object run() {
    703                             return cl.getParent();
    704                         }
    705                     });
    706         } catch(SecurityException ex) {
    707             logDiagnostic("[SECURITY] Unable to obtain parent classloader");
    708             return null;
    709         }
    710
    711     }
    712
    713     /**
    714      * Utility method to check whether a particular logging library is
    715      * present and available for use. Note that this does <i>not</i>
    716      * affect the future behaviour of this class.
    717      */
    718     private boolean isLogLibraryAvailable(String name, String classname) {
    719         if (isDiagnosticsEnabled()) {
    720             logDiagnostic("Checking for '" + name + "'.");
    721         }
    722         try {
    723             Log log = createLogFromClass(
    724                         classname,
    725                         this.getClass().getName(), // dummy category
    726                         false);
    727
    728             if (log == null) {
    729                 if (isDiagnosticsEnabled()) {
    730                     logDiagnostic("Did not find '" + name + "'.");
    731                 }
    732                 return false;
    733             } else {
    734                 if (isDiagnosticsEnabled()) {
    735                     logDiagnostic("Found '" + name + "'.");
    736                 }
    737                 return true;
    738             }
    739         } catch(LogConfigurationException e) {
    740             if (isDiagnosticsEnabled()) {
    741                 logDiagnostic("Logging system '" + name + "' is available but not useable.");
    742             }
    743             return false;
    744         }
    745     }
    746
    747     /**
    748      * Attempt to find an attribute (see method setAttribute) or a
    749      * system property with the provided name and return its value.
    750      * <p>
    751      * The attributes associated with this object are checked before
    752      * system properties in case someone has explicitly called setAttribute,
    753      * or a configuration property has been set in a commons-logging.properties
    754      * file.
    755      *
    756      * @return the value associated with the property, or null.
    757      */
    758     private String getConfigurationValue(String property) {
    759         if (isDiagnosticsEnabled()) {
    760             logDiagnostic("[ENV] Trying to get configuration for item " + property);
    761         }
    762
    763         Object valueObj =  getAttribute(property);
    764         if (valueObj != null) {
    765             if (isDiagnosticsEnabled()) {
    766                 logDiagnostic("[ENV] Found LogFactory attribute [" + valueObj + "] for " + property);
    767             }
    768             return valueObj.toString();
    769         }
    770
    771         if (isDiagnosticsEnabled()) {
    772             logDiagnostic("[ENV] No LogFactory attribute found for " + property);
    773         }
    774
    775         try {
    776             // warning: minor security hole here, in that we potentially read a system
    777             // property that the caller cannot, then output it in readable form as a
    778             // diagnostic message. However it's only ever JCL-specific properties
    779             // involved here, so the harm is truly trivial.
    780             String value = getSystemProperty(property, null);
    781             if (value != null) {
    782                 if (isDiagnosticsEnabled()) {
    783                     logDiagnostic("[ENV] Found system property [" + value + "] for " + property);
    784                 }
    785                 return value;
    786             }
    787
    788             if (isDiagnosticsEnabled()) {
    789                 logDiagnostic("[ENV] No system property found for property " + property);
    790             }
    791         } catch (SecurityException e) {
    792             if (isDiagnosticsEnabled()) {
    793                 logDiagnostic("[ENV] Security prevented reading system property " + property);
    794             }
    795         }
    796
    797         if (isDiagnosticsEnabled()) {
    798             logDiagnostic("[ENV] No configuration defined for item " + property);
    799         }
    800
    801         return null;
    802     }
    803
    804     /**
    805      * Get the setting for the user-configurable behaviour specified by key.
    806      * If nothing has explicitly been set, then return dflt.
    807      */
    808     private boolean getBooleanConfiguration(String key, boolean dflt) {
    809         String val = getConfigurationValue(key);
    810         if (val == null)
    811             return dflt;
    812         return Boolean.valueOf(val).booleanValue();
    813     }
    814
    815     /**
    816      * Initialize a number of variables that control the behaviour of this
    817      * class and that can be tweaked by the user. This is done when the first
    818      * logger is created, not in the constructor of this class, because we
    819      * need to give the user a chance to call method setAttribute in order to
    820      * configure this object.
    821      */
    822     private void initConfiguration() {
    823         allowFlawedContext = getBooleanConfiguration(ALLOW_FLAWED_CONTEXT_PROPERTY, true);
    824         allowFlawedDiscovery = getBooleanConfiguration(ALLOW_FLAWED_DISCOVERY_PROPERTY, true);
    825         allowFlawedHierarchy = getBooleanConfiguration(ALLOW_FLAWED_HIERARCHY_PROPERTY, true);
    826     }
    827
    828
    829     /**
    830      * Attempts to create a Log instance for the given category name.
    831      * Follows the discovery process described in the class javadoc.
    832      *
    833      * @param logCategory the name of the log category
    834      *
    835      * @throws LogConfigurationException if an error in discovery occurs,
    836      * or if no adapter at all can be instantiated
    837      */
    838     private Log discoverLogImplementation(String logCategory)
    839     throws LogConfigurationException
    840     {
    841         if (isDiagnosticsEnabled()) {
    842             logDiagnostic("Discovering a Log implementation...");
    843         }
    844
    845         initConfiguration();
    846
    847         Log result = null;
    848
    849         // See if the user specified the Log implementation to use
    850         String specifiedLogClassName = findUserSpecifiedLogClassName();
    851
    852         if (specifiedLogClassName != null) {
    853             if (isDiagnosticsEnabled()) {
    854                 logDiagnostic("Attempting to load user-specified log class '" +
    855                     specifiedLogClassName + "'...");
    856             }
    857
    858             result = createLogFromClass(specifiedLogClassName,
    859                                         logCategory,
    860                                         true);
    861             if (result == null) {
    862                 StringBuffer messageBuffer =  new StringBuffer("User-specified log class '");
    863                 messageBuffer.append(specifiedLogClassName);
    864                 messageBuffer.append("' cannot be found or is not useable.");
    865
    866                 // Mistyping or misspelling names is a common fault.
    867                 // Construct a good error message, if we can
    868                 if (specifiedLogClassName != null) {
    869                     informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LOG4J_LOGGER);
    870                     informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_JDK14_LOGGER);
    871                     informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_LUMBERJACK_LOGGER);
    872                     informUponSimilarName(messageBuffer, specifiedLogClassName, LOGGING_IMPL_SIMPLE_LOGGER);
    873                 }
    874                 throw new LogConfigurationException(messageBuffer.toString());
    875             }
    876
    877             return result;
    878         }
    879
    880         // No user specified log; try to discover what's on the classpath
    881         //
    882         // Note that we deliberately loop here over classesToDiscover and
    883         // expect method createLogFromClass to loop over the possible source
    884         // classloaders. The effect is:
    885         //   for each discoverable log adapter
    886         //      for each possible classloader
    887         //          see if it works
    888         //
    889         // It appears reasonable at first glance to do the opposite:
    890         //   for each possible classloader
    891         //     for each discoverable log adapter
    892         //        see if it works
    893         //
    894         // The latter certainly has advantages for user-installable logging
    895         // libraries such as log4j; in a webapp for example this code should
    896         // first check whether the user has provided any of the possible
    897         // logging libraries before looking in the parent classloader.
    898         // Unfortunately, however, Jdk14Logger will always work in jvm>=1.4,
    899         // and SimpleLog will always work in any JVM. So the loop would never
    900         // ever look for logging libraries in the parent classpath. Yet many
    901         // users would expect that putting log4j there would cause it to be
    902         // detected (and this is the historical JCL behaviour). So we go with
    903         // the first approach. A user that has bundled a specific logging lib
    904         // in a webapp should use a commons-logging.properties file or a
    905         // service file in META-INF to force use of that logging lib anyway,
    906         // rather than relying on discovery.
    907
    908         if (isDiagnosticsEnabled()) {
    909             logDiagnostic(
    910                 "No user-specified Log implementation; performing discovery" +
    911                 " using the standard supported logging implementations...");
    912         }
    913         for(int i=0; (i<classesToDiscover.length) && (result == null); ++i) {
    914             result = createLogFromClass(classesToDiscover[i], logCategory, true);
    915         }
    916
    917         if (result == null) {
    918             throw new LogConfigurationException
    919                         ("No suitable Log implementation");
    920         }
    921
    922         return result;
    923     }
    924
    925
    926     /**
    927      * Appends message if the given name is similar to the candidate.
    928      * @param messageBuffer <code>StringBuffer</code> the message should be appended to,
    929      * not null
    930      * @param name the (trimmed) name to be test against the candidate, not null
    931      * @param candidate the candidate name (not null)
    932      */
    933     private void informUponSimilarName(final StringBuffer messageBuffer, final String name,
    934             final String candidate) {
    935         if (name.equals(candidate)) {
    936             // Don't suggest a name that is exactly the same as the one the
    937             // user tried...
    938             return;
    939         }
    940
    941         // If the user provides a name that is in the right package, and gets
    942         // the first 5 characters of the adapter class right (ignoring case),
    943         // then suggest the candidate adapter class name.
    944         if (name.regionMatches(true, 0, candidate, 0, PKG_LEN + 5)) {
    945             messageBuffer.append(" Did you mean '");
    946             messageBuffer.append(candidate);
    947             messageBuffer.append("'?");
    948         }
    949     }
    950
    951
    952     /**
    953      * Checks system properties and the attribute map for
    954      * a Log implementation specified by the user under the
    955      * property names {@link #LOG_PROPERTY} or {@link #LOG_PROPERTY_OLD}.
    956      *
    957      * @return classname specified by the user, or <code>null</code>
    958      */
    959     private String findUserSpecifiedLogClassName()
    960     {
    961         if (isDiagnosticsEnabled()) {
    962             logDiagnostic("Trying to get log class from attribute '" + LOG_PROPERTY + "'");
    963         }
    964         String specifiedClass = (String) getAttribute(LOG_PROPERTY);
    965
    966         if (specifiedClass == null) { // @deprecated
    967             if (isDiagnosticsEnabled()) {
    968                 logDiagnostic("Trying to get log class from attribute '" +
    969                               LOG_PROPERTY_OLD + "'");
    970             }
    971             specifiedClass = (String) getAttribute(LOG_PROPERTY_OLD);
    972         }
    973
    974         if (specifiedClass == null) {
    975             if (isDiagnosticsEnabled()) {
    976                 logDiagnostic("Trying to get log class from system property '" +
    977                           LOG_PROPERTY + "'");
    978             }
    979             try {
    980                 specifiedClass = getSystemProperty(LOG_PROPERTY, null);
    981             } catch (SecurityException e) {
    982                 if (isDiagnosticsEnabled()) {
    983                     logDiagnostic("No access allowed to system property '" +
    984                         LOG_PROPERTY + "' - " + e.getMessage());
    985                 }
    986             }
    987         }
    988
    989         if (specifiedClass == null) { // @deprecated
    990             if (isDiagnosticsEnabled()) {
    991                 logDiagnostic("Trying to get log class from system property '" +
    992                           LOG_PROPERTY_OLD + "'");
    993             }
    994             try {
    995                 specifiedClass = getSystemProperty(LOG_PROPERTY_OLD, null);
    996             } catch (SecurityException e) {
    997                 if (isDiagnosticsEnabled()) {
    998                     logDiagnostic("No access allowed to system property '" +
    999                         LOG_PROPERTY_OLD + "' - " + e.getMessage());
    1000                 }
    1001             }
    1002         }
    1003
    1004         // Remove any whitespace; it's never valid in a classname so its
    1005         // presence just means a user mistake. As we know what they meant,
    1006         // we may as well strip the spaces.
    1007         if (specifiedClass != null) {
    1008             specifiedClass = specifiedClass.trim();
    1009         }
    1010
    1011         return specifiedClass;
    1012     }
    1013
    1014
    1015     /**
    1016      * Attempts to load the given class, find a suitable constructor,
    1017      * and instantiate an instance of Log.
    1018      *
    1019      * @param logAdapterClassName classname of the Log implementation
    1020      *
    1021      * @param logCategory  argument to pass to the Log implementation's
    1022      * constructor
    1023      *
    1024      * @param affectState  <code>true</code> if this object's state should
    1025      * be affected by this method call, <code>false</code> otherwise.
    1026      *
    1027      * @return  an instance of the given class, or null if the logging
    1028      * library associated with the specified adapter is not available.
    1029      *
    1030      * @throws LogConfigurationException if there was a serious error with
    1031      * configuration and the handleFlawedDiscovery method decided this
    1032      * problem was fatal.
    1033      */
    1034     private Log createLogFromClass(String logAdapterClassName,
    1035                                    String logCategory,
    1036                                    boolean affectState)
    1037             throws LogConfigurationException {
    1038
    1039         if (isDiagnosticsEnabled()) {
    1040             logDiagnostic("Attempting to instantiate '" + logAdapterClassName + "'");
    1041         }
    1042
    1043         Object[] params = { logCategory };
    1044         Log logAdapter = null;
    1045         Constructor constructor = null;
    1046
    1047         Class logAdapterClass = null;
    1048         ClassLoader currentCL = getBaseClassLoader();
    1049
    1050         for(;;) {
    1051             // Loop through the classloader hierarchy trying to find
    1052             // a viable classloader.
    1053             logDiagnostic(
    1054                     "Trying to load '"
    1055                     + logAdapterClassName
    1056                     + "' from classloader "
    1057                     + objectId(currentCL));
    1058             try {
    1059                 if (isDiagnosticsEnabled()) {
    1060                     // Show the location of the first occurrence of the .class file
    1061                     // in the classpath. This is the location that ClassLoader.loadClass
    1062                     // will load the class from -- unless the classloader is doing
    1063                     // something weird.
    1064                     URL url;
    1065                     String resourceName = logAdapterClassName.replace('.', '/') + ".class";
    1066                     if (currentCL != null) {
    1067                         url = currentCL.getResource(resourceName );
    1068                     } else {
    1069                         url = ClassLoader.getSystemResource(resourceName + ".class");
    1070                     }
    1071
    1072                     if (url == null) {
    1073                         logDiagnostic("Class '" + logAdapterClassName + "' [" + resourceName + "] cannot be found.");
    1074                     } else {
    1075                         logDiagnostic("Class '" + logAdapterClassName + "' was found at '" + url + "'");
    1076                     }
    1077                 }
    1078
    1079                 Class c = null;
    1080                 try {
    1081                     c = Class.forName(logAdapterClassName, true, currentCL);
    1082                 } catch (ClassNotFoundException originalClassNotFoundException) {
    1083                     // The current classloader was unable to find the log adapter
    1084                     // in this or any ancestor classloader. There's no point in
    1085                     // trying higher up in the hierarchy in this case..
    1086                     String msg = "" + originalClassNotFoundException.getMessage();
    1087                     logDiagnostic(
    1088                         "The log adapter '"
    1089                         + logAdapterClassName
    1090                         + "' is not available via classloader "
    1091                         + objectId(currentCL)
    1092                         + ": "
    1093                         + msg.trim());
    1094                     try {
    1095                         // Try the class classloader.
    1096                         // This may work in cases where the TCCL
    1097                         // does not contain the code executed or JCL.
    1098                         // This behaviour indicates that the application
    1099                         // classloading strategy is not consistent with the
    1100                         // Java 1.2 classloading guidelines but JCL can
    1101                         // and so should handle this case.
    1102                         c = Class.forName(logAdapterClassName);
    1103                     } catch (ClassNotFoundException secondaryClassNotFoundException) {
    1104                         // no point continuing: this adapter isn't available
    1105                         msg = "" + secondaryClassNotFoundException.getMessage();
    1106                         logDiagnostic(
    1107                             "The log adapter '"
    1108                             + logAdapterClassName
    1109                             + "' is not available via the LogFactoryImpl class classloader: "
    1110                             + msg.trim());
    1111                         break;
    1112                     }
    1113                 }
    1114
    1115                 constructor = c.getConstructor(logConstructorSignature);
    1116                 Object o = constructor.newInstance(params);
    1117
    1118                 // Note that we do this test after trying to create an instance
    1119                 // [rather than testing Log.class.isAssignableFrom(c)] so that
    1120                 // we don't complain about Log hierarchy problems when the
    1121                 // adapter couldn't be instantiated anyway.
    1122                 if (o instanceof Log) {
    1123                     logAdapterClass = c;
    1124                     logAdapter = (Log) o;
    1125                     break;
    1126                 }
    1127
    1128                 // Oops, we have a potential problem here. An adapter class
    1129                 // has been found and its underlying lib is present too, but
    1130                 // there are multiple Log interface classes available making it
    1131                 // impossible to cast to the type the caller wanted. We
    1132                 // certainly can't use this logger, but we need to know whether
    1133                 // to keep on discovering or terminate now.
    1134                 //
    1135                 // The handleFlawedHierarchy method will throw
    1136                 // LogConfigurationException if it regards this problem as
    1137                 // fatal, and just return if not.
    1138                 handleFlawedHierarchy(currentCL, c);
    1139             } catch (NoClassDefFoundError e) {
    1140                 // We were able to load the adapter but it had references to
    1141                 // other classes that could not be found. This simply means that
    1142                 // the underlying logger library is not present in this or any
    1143                 // ancestor classloader. There's no point in trying higher up
    1144                 // in the hierarchy in this case..
    1145                 String msg = "" + e.getMessage();
    1146                 logDiagnostic(
    1147                     "The log adapter '"
    1148                     + logAdapterClassName
    1149                     + "' is missing dependencies when loaded via classloader "
    1150                     + objectId(currentCL)
    1151                     + ": "
    1152                     + msg.trim());
    1153                 break;
    1154             } catch (ExceptionInInitializerError e) {
    1155                 // A static initializer block or the initializer code associated
    1156                 // with a static variable on the log adapter class has thrown
    1157                 // an exception.
    1158                 //
    1159                 // We treat this as meaning the adapter's underlying logging
    1160                 // library could not be found.
    1161                 String msg = "" + e.getMessage();
    1162                 logDiagnostic(
    1163                     "The log adapter '"
    1164                     + logAdapterClassName
    1165                     + "' is unable to initialize itself when loaded via classloader "
    1166                     + objectId(currentCL)
    1167                     + ": "
    1168                     + msg.trim());
    1169                 break;
    1170             } catch(LogConfigurationException e) {
    1171                 // call to handleFlawedHierarchy above must have thrown
    1172                 // a LogConfigurationException, so just throw it on
    1173                 throw e;
    1174             } catch(Throwable t) {
    1175                 // handleFlawedDiscovery will determine whether this is a fatal
    1176                 // problem or not. If it is fatal, then a LogConfigurationException
    1177                 // will be thrown.
    1178                 handleFlawedDiscovery(logAdapterClassName, currentCL, t);
    1179             }
    1180
    1181             if (currentCL == null) {
    1182                 break;
    1183             }
    1184
    1185             // try the parent classloader
    1186             // currentCL = currentCL.getParent();
    1187             currentCL = getParentClassLoader(currentCL);
    1188         }
    1189
    1190         if ((logAdapter != null) && affectState) {
    1191             // We've succeeded, so set instance fields
    1192             this.logClassName   = logAdapterClassName;
    1193             this.logConstructor = constructor;
    1194
    1195             // Identify the <code>setLogFactory</code> method (if there is one)
    1196             try {
    1197                 this.logMethod = logAdapterClass.getMethod("setLogFactory",
    1198                                                logMethodSignature);
    1199                 logDiagnostic("Found method setLogFactory(LogFactory) in '"
    1200                               + logAdapterClassName + "'");
    1201             } catch (Throwable t) {
    1202                 this.logMethod = null;
    1203                 logDiagnostic(
    1204                     "[INFO] '" + logAdapterClassName
    1205                     + "' from classloader " + objectId(currentCL)
    1206                     + " does not declare optional method "
    1207                     + "setLogFactory(LogFactory)");
    1208             }
    1209
    1210             logDiagnostic(
    1211                 "Log adapter '" + logAdapterClassName
    1212                 + "' from classloader " + objectId(logAdapterClass.getClassLoader())
    1213                 + " has been selected for use.");
    1214         }
    1215
    1216         return logAdapter;
    1217     }
    1218
    1219
    1220     /**
    1221      * Return the classloader from which we should try to load the logging
    1222      * adapter classes.
    1223      * <p>
    1224      * This method usually returns the context classloader. However if it
    1225      * is discovered that the classloader which loaded this class is a child
    1226      * of the context classloader <i>and</i> the allowFlawedContext option
    1227      * has been set then the classloader which loaded this class is returned
    1228      * instead.
    1229      * <p>
    1230      * The only time when the classloader which loaded this class is a
    1231      * descendant (rather than the same as or an ancestor of the context
    1232      * classloader) is when an app has created custom classloaders but
    1233      * failed to correctly set the context classloader. This is a bug in
    1234      * the calling application; however we provide the option for JCL to
    1235      * simply generate a warning rather than fail outright.
    1236      *
    1237      */
    1238     private ClassLoader getBaseClassLoader() throws LogConfigurationException {
    1239         ClassLoader thisClassLoader = getClassLoader(LogFactoryImpl.class);
    1240
    1241         if (useTCCL == false) {
    1242             return thisClassLoader;
    1243         }
    1244
    1245         ClassLoader contextClassLoader = getContextClassLoaderInternal();
    1246
    1247         ClassLoader baseClassLoader = getLowestClassLoader(
    1248                 contextClassLoader, thisClassLoader);
    1249
    1250         if (baseClassLoader == null) {
    1251            // The two classloaders are not part of a parent child relationship.
    1252            // In some classloading setups (e.g. JBoss with its
    1253            // UnifiedLoaderRepository) this can still work, so if user hasn't
    1254            // forbidden it, just return the contextClassLoader.
    1255            if (allowFlawedContext) {
    1256               if (isDiagnosticsEnabled()) {
    1257                    logDiagnostic(
    1258                            "[WARNING] the context classloader is not part of a"
    1259                            + " parent-child relationship with the classloader that"
    1260                            + " loaded LogFactoryImpl.");
    1261               }
    1262               // If contextClassLoader were null, getLowestClassLoader() would
    1263               // have returned thisClassLoader.  The fact we are here means
    1264               // contextClassLoader is not null, so we can just return it.
    1265               return contextClassLoader;
    1266            }
    1267            else {
    1268             throw new LogConfigurationException(
    1269                 "Bad classloader hierarchy; LogFactoryImpl was loaded via"
    1270                 + " a classloader that is not related to the current context"
    1271                 + " classloader.");
    1272            }
    1273         }
    1274
    1275         if (baseClassLoader != contextClassLoader) {
    1276             // We really should just use the contextClassLoader as the starting
    1277             // point for scanning for log adapter classes. However it is expected
    1278             // that there are a number of broken systems out there which create
    1279             // custom classloaders but fail to set the context classloader so
    1280             // we handle those flawed systems anyway.
    1281             if (allowFlawedContext) {
    1282                 if (isDiagnosticsEnabled()) {
    1283                     logDiagnostic(
    1284                             "Warning: the context classloader is an ancestor of the"
    1285                             + " classloader that loaded LogFactoryImpl; it should be"
    1286                             + " the same or a descendant. The application using"
    1287                             + " commons-logging should ensure the context classloader"
    1288                             + " is used correctly.");
    1289                 }
    1290             } else {
    1291                 throw new LogConfigurationException(
    1292                         "Bad classloader hierarchy; LogFactoryImpl was loaded via"
    1293                         + " a classloader that is not related to the current context"
    1294                         + " classloader.");
    1295             }
    1296         }
    1297
    1298         return baseClassLoader;
    1299     }
    1300
    1301     /**
    1302      * Given two related classloaders, return the one which is a child of
    1303      * the other.
    1304      * <p>
    1305      * @param c1 is a classloader (including the null classloader)
    1306      * @param c2 is a classloader (including the null classloader)
    1307      *
    1308      * @return c1 if it has c2 as an ancestor, c2 if it has c1 as an ancestor,
    1309      * and null if neither is an ancestor of the other.
    1310      */
    1311     private ClassLoader getLowestClassLoader(ClassLoader c1, ClassLoader c2) {
    1312         // TODO: use AccessController when dealing with classloaders here
    1313
    1314         if (c1 == null)
    1315             return c2;
    1316
    1317         if (c2 == null)
    1318             return c1;
    1319
    1320         ClassLoader current;
    1321
    1322         // scan c1's ancestors to find c2
    1323         current = c1;
    1324         while (current != null) {
    1325             if (current == c2)
    1326                 return c1;
    1327             current = current.getParent();
    1328         }
    1329
    1330         // scan c2's ancestors to find c1
    1331         current = c2;
    1332         while (current != null) {
    1333             if (current == c1)
    1334                 return c2;
    1335             current = current.getParent();
    1336         }
    1337
    1338         return null;
    1339     }
    1340
    1341     /**
    1342      * Generates an internal diagnostic logging of the discovery failure and
    1343      * then throws a <code>LogConfigurationException</code> that wraps
    1344      * the passed <code>Throwable</code>.
    1345      *
    1346      * @param logAdapterClassName is the class name of the Log implementation
    1347      * that could not be instantiated. Cannot be <code>null</code>.
    1348      *
    1349      * @param classLoader is the classloader that we were trying to load the
    1350      * logAdapterClassName from when the exception occurred.
    1351      *
    1352      * @param discoveryFlaw is the Throwable created by the classloader
    1353      *
    1354      * @throws LogConfigurationException    ALWAYS
    1355      */
    1356     private void handleFlawedDiscovery(String logAdapterClassName,
    1357                                        ClassLoader classLoader,
    1358                                        Throwable discoveryFlaw) {
    1359
    1360         if (isDiagnosticsEnabled()) {
    1361             logDiagnostic("Could not instantiate Log '"
    1362                       + logAdapterClassName + "' -- "
    1363                       + discoveryFlaw.getClass().getName() + ": "
    1364                       + discoveryFlaw.getLocalizedMessage());
    1365
    1366             if (discoveryFlaw instanceof InvocationTargetException ) {
    1367                 // Ok, the lib is there but while trying to create a real underlying
    1368                 // logger something failed in the underlying lib; display info about
    1369                 // that if possible.
    1370                 InvocationTargetException ite = (InvocationTargetException)discoveryFlaw;
    1371                 Throwable cause = ite.getTargetException();
    1372                 if (cause != null) {
    1373                     logDiagnostic("... InvocationTargetException: " +
    1374                         cause.getClass().getName() + ": " +
    1375                         cause.getLocalizedMessage());
    1376
    1377                     if (cause instanceof ExceptionInInitializerError) {
    1378                         ExceptionInInitializerError eiie = (ExceptionInInitializerError)cause;
    1379                         Throwable cause2 = eiie.getException();
    1380                         if (cause2 != null) {
    1381                             logDiagnostic("... ExceptionInInitializerError: " +
    1382                                 cause2.getClass().getName() + ": " +
    1383                                 cause2.getLocalizedMessage());
    1384                         }
    1385                     }
    1386                 }
    1387             }
    1388         }
    1389
    1390         if (!allowFlawedDiscovery) {
    1391             throw new LogConfigurationException(discoveryFlaw);
    1392         }
    1393     }
    1394
    1395
    1396     /**
    1397      * Report a problem loading the log adapter, then either return
    1398      * (if the situation is considered recoverable) or throw a
    1399      * LogConfigurationException.
    1400      *  <p>
    1401      * There are two possible reasons why we successfully loaded the
    1402      * specified log adapter class then failed to cast it to a Log object:
    1403      * <ol>
    1404      * <li>the specific class just doesn't implement the Log interface
    1405      *     (user screwed up), or
    1406      * <li> the specified class has bound to a Log class loaded by some other
    1407      *      classloader; Log@classloaderX cannot be cast to Log@classloaderY.
    1408      * </ol>
    1409      * <p>
    1410      * Here we try to figure out which case has occurred so we can give the
    1411      * user some reasonable feedback.
    1412      *
    1413      * @param badClassLoader is the classloader we loaded the problem class from,
    1414      * ie it is equivalent to badClass.getClassLoader().
    1415      *
    1416      * @param badClass is a Class object with the desired name, but which
    1417      * does not implement Log correctly.
    1418      *
    1419      * @throws LogConfigurationException when the situation
    1420      * should not be recovered from.
    1421      */
    1422     private void handleFlawedHierarchy(ClassLoader badClassLoader, Class badClass)
    1423     throws LogConfigurationException {
    1424
    1425         boolean implementsLog = false;
    1426         String logInterfaceName = Log.class.getName();
    1427         Class interfaces[] = badClass.getInterfaces();
    1428         for (int i = 0; i < interfaces.length; i++) {
    1429             if (logInterfaceName.equals(interfaces[i].getName())) {
    1430                 implementsLog = true;
    1431                 break;
    1432             }
    1433         }
    1434
    1435         if (implementsLog) {
    1436             // the class does implement an interface called Log, but
    1437             // it is in the wrong classloader
    1438             if (isDiagnosticsEnabled()) {
    1439                 try {
    1440                     ClassLoader logInterfaceClassLoader = getClassLoader(Log.class);
    1441                     logDiagnostic(
    1442                         "Class '" + badClass.getName()
    1443                         + "' was found in classloader "
    1444                         + objectId(badClassLoader)
    1445                         + ". It is bound to a Log interface which is not"
    1446                         + " the one loaded from classloader "
    1447                         + objectId(logInterfaceClassLoader));
    1448                 } catch (Throwable t) {
    1449                     logDiagnostic(
    1450                         "Error while trying to output diagnostics about"
    1451                         + " bad class '" + badClass + "'");
    1452                 }
    1453             }
    1454
    1455             if (!allowFlawedHierarchy) {
    1456                 StringBuffer msg = new StringBuffer();
    1457                 msg.append("Terminating logging for this context ");
    1458                 msg.append("due to bad log hierarchy. ");
    1459                 msg.append("You have more than one version of '");
    1460                 msg.append(Log.class.getName());
    1461                 msg.append("' visible.");
    1462                 if (isDiagnosticsEnabled()) {
    1463                     logDiagnostic(msg.toString());
    1464                 }
    1465                 throw new LogConfigurationException(msg.toString());
    1466             }
    1467
    1468             if (isDiagnosticsEnabled()) {
    1469                 StringBuffer msg = new StringBuffer();
    1470                 msg.append("Warning: bad log hierarchy. ");
    1471                 msg.append("You have more than one version of '");
    1472                 msg.append(Log.class.getName());
    1473                 msg.append("' visible.");
    1474                 logDiagnostic(msg.toString());
    1475             }
    1476         } else {
    1477             // this is just a bad adapter class
    1478             if (!allowFlawedDiscovery) {
    1479                 StringBuffer msg = new StringBuffer();
    1480                 msg.append("Terminating logging for this context. ");
    1481                 msg.append("Log class '");
    1482                 msg.append(badClass.getName());
    1483                 msg.append("' does not implement the Log interface.");
    1484                 if (isDiagnosticsEnabled()) {
    1485                     logDiagnostic(msg.toString());
    1486                 }
    1487
    1488                 throw new LogConfigurationException(msg.toString());
    1489             }
    1490
    1491             if (isDiagnosticsEnabled()) {
    1492                 StringBuffer msg = new StringBuffer();
    1493                 msg.append("[WARNING] Log class '");
    1494                 msg.append(badClass.getName());
    1495                 msg.append("' does not implement the Log interface.");
    1496                 logDiagnostic(msg.toString());
    1497             }
    1498         }
    1499     }
    1500 }