Any code that accesses this object should first obtain a lock on it, ie use synchronized(dateFormatter); this requirement was introduced in 1.1.1 to fix an existing thread safety bug (SimpleDateFormat.format is not thread-safe). 

 public SimpleLog(String name) 
{
    // ------------------------------------------------------------ Constructor
        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);
        }
}

Construct a simple log with given name.

Parameters:

name - log name

 public final  void debug(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
            log(SimpleLog.LOG_LEVEL_DEBUG, message, null);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_DEBUG.

 public final  void debug(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
            log(SimpleLog.LOG_LEVEL_DEBUG, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_DEBUG.

 public final  void error(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
            log(SimpleLog.LOG_LEVEL_ERROR, message, null);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_ERROR.

 public final  void error(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR)) {
            log(SimpleLog.LOG_LEVEL_ERROR, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_ERROR.

 public final  void fatal(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
            log(SimpleLog.LOG_LEVEL_FATAL, message, null);
        }
}

Log a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_FATAL.

 public final  void fatal(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL)) {
            log(SimpleLog.LOG_LEVEL_FATAL, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_FATAL.

 public int getLevel() 
{
        return currentLogLevel;
}

Get logging level.

 public final  void info(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
            log(SimpleLog.LOG_LEVEL_INFO,message,null);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_INFO.

 public final  void info(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_INFO)) {
            log(SimpleLog.LOG_LEVEL_INFO, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_INFO.

 public final boolean isDebugEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG);
}

Are debug messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 public final boolean isErrorEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_ERROR);
}

Are error messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 public final boolean isFatalEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_FATAL);
}

Are fatal messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 public final boolean isInfoEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_INFO);
}

Are info messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 protected boolean isLevelEnabled(int logLevel) 
{
        // log level are numerically ordered so can use simple numeric
        // comparison
        return (logLevel  >= currentLogLevel);
}

Is the given log level currently enabled?

 public final boolean isTraceEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE);
}

Are trace messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 public final boolean isWarnEnabled() 
{
        return isLevelEnabled(SimpleLog.LOG_LEVEL_WARN);
}

Are warn messages currently enabled?

This allows expensive operations such as String concatenation to be avoided when the message will be ignored by the logger.

 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) {
            Date now = new Date();
            String dateText;
            synchronized(dateFormatter) {
                dateText = dateFormatter.format(now);
            }
            buf.append(dateText);
            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);
}

Do the actual logging. This method assembles the message and then calls write() to cause it to be written.

 public  void setLevel(int currentLogLevel) 
{
        this.currentLogLevel = currentLogLevel;
}

Set logging level.

 public final  void trace(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
            log(SimpleLog.LOG_LEVEL_TRACE, message, null);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_TRACE.

 public final  void trace(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_TRACE)) {
            log(SimpleLog.LOG_LEVEL_TRACE, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_TRACE.

 public final  void warn(Object message) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
            log(SimpleLog.LOG_LEVEL_WARN, message, null);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_WARN.

 public final  void warn(Object message,
    Throwable t) 
{
        if (isLevelEnabled(SimpleLog.LOG_LEVEL_WARN)) {
            log(SimpleLog.LOG_LEVEL_WARN, message, t);
        }
}

Logs a message with org.apache.commons.logging.impl.SimpleLog.LOG_LEVEL_WARN.

 protected  void write(StringBuffer buffer) 
{
        System.err.println(buffer.toString());
}

Write the content of the message accumulated in the specified StringBuffer to the appropriate output destination. The default implementation writes to System.err.