public Logger(LogCategory category,
    LogStream logStream,
    String baseName) 
{
        this.category = category;
        this.logStream = logStream;
        this.baseName = baseName;
}

 public static  void configure() 
{
        String factoryName = System.getProperty("openejb.log.factory");
        Class< ? > factoryClass = null;
        if (factoryName != null) {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            if (classLoader != null) {
                try {
                    factoryClass = classLoader.loadClass(factoryName);
                } catch (ClassNotFoundException e) {
                }
            }
            if (factoryClass != null) {
                try {
                    factoryClass = Class.forName(factoryName);
                } catch (ClassNotFoundException e) {
                }
            }
        }
        LogStreamFactory factory = null;
        if (factoryClass != null) {
            try {
                factory = (LogStreamFactory) factoryClass.newInstance();
            } catch (Exception e) {
            }
        }
        if (factory == null) {
            factory = new Log4jLogStreamFactory();
        }
        logStreamFactory = factory;
}

 public String debug(String message) 
{
        if (isDebugEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.debug(msg);
            return msg;
        }
        return message;
}

If this level is enabled, then it finds a message for the given key and logs it

 public String debug(String message,
    Object args) 
{
        if (isDebugEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.debug(msg);
            return msg;
        }
        return message;
}

 public String debug(String message,
    Throwable t) 
{
        if (isDebugEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.debug(msg, t);
            return msg;
        }
        return message;
}

 public String debug(String message,
    Throwable t,
    Object args) 
{
        if (isDebugEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.debug(msg, t);
            return msg;
        }
        return message;
}

 public String error(String message) 
{
        if (isErrorEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.error(msg);
            return msg;
        }
        return message;
}

 public String error(String message,
    Object args) 
{
        if (isErrorEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.error(msg);
            return msg;
        }
        return message;
}

 public String error(String message,
    Throwable t) 
{
        if (isErrorEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.error(msg, t);
            return msg;
        }
        return message;
}

 public String error(String message,
    Throwable t,
    Object args) 
{
        if (isErrorEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.error(msg, t);
            return msg;
        }
        return message;
}

 public String fatal(String message) 
{
        if (isFatalEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.fatal(msg);
            return msg;
        }
        return message;
}

 public String fatal(String message,
    Object args) 
{
        if (isFatalEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.fatal(msg);
            return msg;
        }
        return message;
}

 public String fatal(String message,
    Throwable t) 
{
        if (isFatalEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.fatal(msg, t);
            return msg;
        }
        return message;
}

 public String fatal(String message,
    Throwable t,
    Object args) 
{
        if (isFatalEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.fatal(msg, t);
            return msg;
        }
        return message;
}

 public Logger getChildLogger(String child) 
{
        return Logger.getInstance(this.category.createChild(child), this.baseName);
}

 public static Logger getInstance(LogCategory category,
    String baseName) 
{
        try {
            Logger logger = loggerCache.compute(new Object[]{category, baseName});
            return logger;
        } catch (InterruptedException e) {
            // Don't return null here. Just create a new Logger and set it up.
            // It will not be stored in the cache, but a later lookup for the
            // same Logger would probably end up in the cache
            LogStream logStream = logStreamFactory.createLogStream(category);
            Logger logger = new Logger(category, logStream, baseName);
            return logger;
        }
}

Finds a Logger from the cache and returns it. If not found in cache then builds a Logger and returns it.

 public static Logger getInstance(LogCategory category,
    Class clazz) 
{
        return getInstance(category, packageName(clazz));
}

 public String info(String message) 
{
        if (isInfoEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.info(msg);
            return msg;
        }
        return message;
}

 public String info(String message,
    Object args) 
{
        if (isInfoEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.info(msg);
            return msg;
        }
        return message;
}

 public String info(String message,
    Throwable t) 
{
        if (isInfoEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.info(msg, t);
            return msg;
        }
        return message;
}

 public String info(String message,
    Throwable t,
    Object args) 
{
        if (isInfoEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.info(msg, t);
            return msg;
        }
        return message;
}

 public boolean isDebugEnabled() 
{
        return logStream.isDebugEnabled();
}

 public boolean isErrorEnabled() 
{
        return logStream.isErrorEnabled();
}

 public boolean isFatalEnabled() 
{
        return logStream.isFatalEnabled();
}

 public boolean isInfoEnabled() 
{
        return logStream.isInfoEnabled();
}

 public boolean isWarningEnabled() 
{
        return logStream.isWarnEnabled();
}

 public String warning(String message) 
{
        if (isWarningEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.warn(msg);
            return msg;
        }
        return message;
}

 public String warning(String message,
    Object args) 
{
        if (isWarningEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.warn(msg);
            return msg;
        }
        return message;
}

 public String warning(String message,
    Throwable t) 
{
        if (isWarningEnabled()) {
            String msg = getMessage(message, baseName);
            logStream.warn(msg, t);
            return msg;
        }
        return message;
}

 public String warning(String message,
    Throwable t,
    Object args) 
{
        if (isWarningEnabled()) {
            String msg = getMessage(message, baseName);
            msg = formatMessage(msg, args);
            logStream.warn(msg, t);
            return msg;
        }
        return message;
}