/* * Copyright 2001-2004 The Apache Software Foundation. *  * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at *  *      http://www.apache.org/licenses/LICENSE-2.0 *  * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.logging.impl;import java.io.InputStream;import java.io.Serializable;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.security.AccessController;import java.security.PrivilegedAction;import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Properties;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogConfigurationException;/** * <p>Simple implementation of Log that sends all enabled log messages, * for all defined loggers, to System.err.  The following system properties * are supported to configure the behavior of this logger:</p> * <ul> * <li><code>org.apache.commons.logging.simplelog.defaultlog</code> - *     Default logging detail level for all instances of SimpleLog. *     Must be one of ("trace", "debug", "info", "warn", "error", or "fatal"). *     If not specified, defaults to "info". </li> * <li><code>org.apache.commons.logging.simplelog.log.xxxxx</code> - *     Logging detail level for a SimpleLog instance named "xxxxx". *     Must be one of ("trace", "debug", "info", "warn", "error", or "fatal"). *     If not specified, the default logging detail level is used.</li> * <li><code>org.apache.commons.logging.simplelog.showlogname</code> - *     Set to <code>true</code> if you want the Log instance name to be *     included in output messages. Defaults to <code>false</code>.</li> * <li><code>org.apache.commons.logging.simplelog.showShortLogname</code> - *     Set to <code>true</code> if you want the last component of the name to be *     included in output messages. Defaults to <code>true</code>.</li> * <li><code>org.apache.commons.logging.simplelog.showdatetime</code> - *     Set to <code>true</code> if you want the current date and time *     to be included in output messages. Default is <code>false</code>.</li> * <li><code>org.apache.commons.logging.simplelog.dateTimeFormat</code> - *     The date and time format to be used in the output messages. *     The pattern describing the date and time format is the same that is *     used in <code>java.text.SimpleDateFormat</code>. If the format is not *     specified or is invalid, the default format is used. *     The default format is <code>yyyy/MM/dd HH:mm:ss:SSS zzz</code>.</li> * </ul> * * <p>In addition to looking for system properties with the names specified * above, this implementation also checks for a class loader resource named * <code>"simplelog.properties"</code>, and includes any matching definitions * from this resource (if it exists).</p> * * @author <a href="mailto:sanders@apache.org">Scott Sanders</a> * @author Rod Waldhoff * @author Robert Burrell Donkin * * @version $Id: SimpleLog.java,v 1.21 2004/06/06 20:47:56 rdonkin Exp $ */public class SimpleLog implements Log, Serializable {    // ------------------------------------------------------- Class Attributes    /** All system properties used by <code>SimpleLog</code> start with this */    static protected final String systemPrefix =        "org.apache.commons.logging.simplelog.";    /** Properties loaded from simplelog.properties */    static protected final Properties simpleLogProps = new Properties();    /** The default format to use when formating dates */    static protected final String DEFAULT_DATE_TIME_FORMAT =        "yyyy/MM/dd HH:mm:ss:SSS zzz";    /** Include the instance name in the log message? */    static protected boolean showLogName = false;    /** Include the short name ( last component ) of the logger in the log     *  message. Defaults to true - otherwise we'll be lost in a flood of     *  messages without knowing who sends them.     */    static protected boolean showShortName = true;    /** Include the current time in the log message */    static protected boolean showDateTime = false;    /** The date and time format to use in the log message */    static protected String dateTimeFormat = DEFAULT_DATE_TIME_FORMAT;    /** Used to format times */    static protected DateFormat dateFormatter = null;    // ---------------------------------------------------- Log Level Constants    /** "Trace" level logging. */    public static final int LOG_LEVEL_TRACE  = 1;    /** "Debug" level logging. */    public static final int LOG_LEVEL_DEBUG  = 2;    /** "Info" level logging. */    public static final int LOG_LEVEL_INFO   = 3;    /** "Warn" level logging. */    public static final int LOG_LEVEL_WARN   = 4;    /** "Error" level logging. */    public static final int LOG_LEVEL_ERROR  = 5;    /** "Fatal" level logging. */    public static final int LOG_LEVEL_FATAL  = 6;    /** Enable all logging levels */    public static final int LOG_LEVEL_ALL    = (LOG_LEVEL_TRACE - 1);    /** Enable no logging levels */    public static final int LOG_LEVEL_OFF    = (LOG_LEVEL_FATAL + 1);    // ------------------------------------------------------------ Initializer    private static String getStringProperty(String name) {        String prop = null;	try {	    prop = System.getProperty(name);	} catch (SecurityException e) {	    ; // Ignore	}        return (prop == null) ? simpleLogProps.getProperty(name) : prop;    }    private static String getStringProperty(String name, String dephault) {        String prop = getStringProperty(name);        return (prop == null) ? dephault : prop;    }    private static boolean getBooleanProperty(String name, boolean dephault) {        String prop = getStringProperty(name);        return (prop == null) ? dephault : "true".equalsIgnoreCase(prop);    }    // Initialize class attributes.    // Load properties file, if found.    // Override with system properties.    static {        // Add props from the resource simplelog.properties        InputStream in = getResourceAsStream("simplelog.properties");        if(null != in) {            try {                simpleLogProps.load(in);                in.close();            } catch(java.io.IOException e) {                // ignored            }        }        showLogName = getBooleanProperty( systemPrefix + "showlogname", showLogName);        showShortName = getBooleanProperty( systemPrefix + "showShortLogname", showShortName);        showDateTime = getBooleanProperty( systemPrefix + "showdatetime", showDateTime);        if(showDateTime) {            dateTimeFormat = getStringProperty(systemPrefix + "dateTimeFormat",                                               dateTimeFormat);            try {                dateFormatter = new SimpleDateFormat(dateTimeFormat);            } catch(IllegalArgumentException e) {                // If the format pattern is invalid - use the default format                dateTimeFormat = DEFAULT_DATE_TIME_FORMAT;                dateFormatter = new SimpleDateFormat(dateTimeFormat);            }        }    }    // ------------------------------------------------------------- Attributes    /** The name of this simple log instance */    protected String logName = null;    /** The current log level */    protected int currentLogLevel;    /** The short name of this simple log instance */    private String shortLogName = null;    // ------------------------------------------------------------ Constructor    /**     * Construct a simple log with given name.     *     * @param name log name     */    public SimpleLog(String name) {        logName = name;        // Set initial log level        // Used to be: set default log level to ERROR        // IMHO it should be lower, but at least info ( costin ).        setLevel(SimpleLog.LOG_LEVEL_INFO);        // Set log level from properties        String lvl = getStringProperty(systemPrefix + "log." + logName);        int i = String.valueOf(name).lastIndexOf(".");        while(null == lvl && i > -1) {            name = name.substring(0,i);            lvl = getStringProperty(systemPrefix + "log." + name);            i = String.valueOf(name).lastIndexOf(".");        }        if(null == lvl) {            lvl =  getStringProperty(systemPrefix + "defaultlog");        }        if("all".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_ALL);        } else if("trace".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_TRACE);        } else if("debug".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_DEBUG);        } else if("info".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_INFO);        } else if("warn".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_WARN);        } else if("error".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_ERROR);        } else if("fatal".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_FATAL);        } else if("off".equalsIgnoreCase(lvl)) {            setLevel(SimpleLog.LOG_LEVEL_OFF);        }    }    // -------------------------------------------------------- Properties    /**     * <p> Set logging level. </p>     *     * @param currentLogLevel new logging level     */    public void setLevel(int currentLogLevel) {        this.currentLogLevel = currentLogLevel;    }    /**     * <p> Get logging level. </p>     */    public int getLevel() {        return currentLogLevel;    }    // -------------------------------------------------------- Logging Methods    /**     * <p> Do the actual logging.     * This method assembles the message     * and then calls <code>write()</code> to cause it to be written.</p>     *     * @param type One of the LOG_LEVEL_XXX constants defining the log level     * @param message The message itself (typically a String)     * @param t The exception whose stack trace should be logged     */    protected void log(int type, Object message, Throwable t) {        // Use a string buffer for better performance        StringBuffer buf = new StringBuffer();        // Append date-time if so configured        if(showDateTime) {            buf.append(dateFormatter.format(new Date()));            buf.append(" ");        }        // Append a readable representation of the log level        switch(type) {            case SimpleLog.LOG_LEVEL_TRACE: buf.append("[TRACE] "); break;            case SimpleLog.LOG_LEVEL_DEBUG: buf.append("[DEBUG] "); break;            case SimpleLog.LOG_LEVEL_INFO:  buf.append("[INFO] ");  break;            case SimpleLog.LOG_LEVEL_WARN:  buf.append("[WARN] ");  break;            case SimpleLog.LOG_LEVEL_ERROR: buf.append("[ERROR] "); break;            case SimpleLog.LOG_LEVEL_FATAL: buf.append("[FATAL] "); break;        }        // Append the name of the log instance if so configured 	if( showShortName) {            if( shortLogName==null ) {                // Cut all but the last component of the name for both styles                shortLogName = logName.substring(logName.lastIndexOf(".") + 1);                shortLogName =                    shortLogName.substring(shortLogName.lastIndexOf("/") + 1);            }            buf.append(String.valueOf(shortLogName)).append(" - ");        } else if(showLogName) {            buf.append(String.valueOf(logName)).append(" - ");        }        // Append the message        buf.append(String.valueOf(message));        // Append stack trace if not null        if(t != null) {            buf.append(" <");            buf.append(t.toString());            buf.append(">");            java.io.StringWriter sw= new java.io.StringWriter(1024);            java.io.PrintWriter pw= new java.io.PrintWriter(sw);            t.printStackTrace(pw);            pw.close();            buf.append(sw.toString());        }        // Print to the appropriate destination        write(buf);