org.ioc.commons.utils.logs.Log4JFormatterLogger Maven / Gradle / Ivy

Go to download
package org.ioc.commons.utils.logs;

import org.apache.log4j.Logger;
import org.ioc.commons.utils.Format;
import org.ioc.commons.utils.FormatterLogger.Implementator;

/**
 * A logger which formats messages by using {@link Format} notation.
 * 
 * When log level is not enabled, parameters are not formatted. It avoids the
 * waste of time because of parsing them.
 * 
 * @author Jesús Lunar Pérez
 */
public class Log4JFormatterLogger implements IFormatterLogger {

	private static final class Log4JLogging implements Implementator {
		@Override
		public IFormatterLogger getLogger(Class clazz) {
			return new Log4JFormatterLogger(Logger.getLogger(clazz));
		}
	}

	protected Logger logger;
	private StringBuffer dent;

	/**
	 * Get a new instance logger for the class passed as parameter.
	 * 
	 * @param clazz
	 *            Class to log.
	 * @return A new instance of a logger
	 */
	public static Log4JFormatterLogger getLogger(Class clazz) {
		return new Log4JFormatterLogger(Logger.getLogger(clazz));
	}

	protected Log4JFormatterLogger(Logger logger) {
		this.logger = logger;
	}
	/**
	 * Substitute params on a string by using the {n} notation, where 'n' is the
	 * position number of the parameter.
	 * 
	 * Example: {@code
	 * 
	 * String formattedString = Format.substitute("Name: 0}; Address: {1};",
	 * name, address);
	 * 
	 * }
	 * 
	 * @param text
	 *            Text with params notations
	 * @param params
	 *            Params to be inserted as string.
	 * @see Format#substitute(String, Object...)
	 * @return The string with substitutions.
	 */
	public static String substitute(String text, Object... params) {
		for (int i = 0; i < params.length; i++) {
			Object p = params[i];
			text = text.replaceAll("\\{" + i + "}", safeRegexReplacement(String.valueOf(p)));
		}
		return text;
	}

	protected static String safeRegexReplacement(String replacement) {
		if (replacement == null) {
			return "";
		}

		return replacement.replaceAll("\\\\", "\\\\\\\\").replaceAll("\\$", "\\\\\\$");
	}

	@Override
	public void log(Level level, String string, Object... params) {
		org.apache.log4j.Level implLevel = getImplLevel(level);
		if (logger.isEnabledFor(implLevel)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(implLevel, substitute(string, params));
		}
	}

	@Override
	public void log(Level level, boolean cond, String string, Object... params) {
		if (cond) {
			log(level, string, params);
		}
	}

	@Override
	public void trace(String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.TRACE)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.trace(substitute(string, params));
		}
	}

	@Override
	public void trace(boolean cond, String string, Object... params) {
		if (cond) {
			trace(string, params);
		}
	}

	@Override
	public void debug(String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.DEBUG)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.debug(substitute(string, params));
		}
	}

	@Override
	public void debug(boolean cond, String string, Object... params) {
		if (cond) {
			debug(string, params);
		}
	}

	@Override
	public void info(String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.INFO)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.info(substitute(string, params));
		}
	}

	@Override
	public void info(boolean cond, String string, Object... params) {
		if (cond) {
			info(string, params);
		}
	}

	@Override
	public void warn(String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.WARN)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.warn(substitute(string, params));
		}
	}

	@Override
	public void warn(Throwable e, String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.WARN)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(org.apache.log4j.Level.WARN, substitute(string, params), e);
		}
	}

	@Override
	public void warn(boolean cond, String string, Object... params) {
		if (cond) {
			warn(string, params);
		}
	}

	@Override
	public void warn(boolean cond, Throwable e, String string, Object... params) {
		if (cond) {
			warn(e, string, params);
		}
	}

	@Override
	public void error(String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.ERROR)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(org.apache.log4j.Level.ERROR, substitute(string, params));
		}
	}

	@Override
	public void error(Throwable e, String string, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.ERROR)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(org.apache.log4j.Level.ERROR, substitute(string, params), e);
		}
	}

	@Override
	public void error(Throwable e) {
		if (logger.isEnabledFor(org.apache.log4j.Level.ERROR)) {
			logger.log(org.apache.log4j.Level.ERROR, null, e);
		}
	}

	@Override
	public void entering(String sourceMethod, String msg, Object... params) {
		if (logger.isEnabledFor(org.apache.log4j.Level.TRACE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.trace(substitute("{0} - Start. {1}", sourceMethod, substitute(msg, params)));
		}
	}

	@Override
	public void entering(String sourceMethod) {
		if (logger.isEnabledFor(org.apache.log4j.Level.TRACE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.trace(substitute("{0} - Start", sourceMethod));
		}
	}

	@Override
	public void exiting(String sourceMethod, String msg, Object... result) {
		if (logger.isEnabledFor(org.apache.log4j.Level.TRACE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.trace(substitute("{0} - End. {1}", sourceMethod, substitute(msg, result)));
		}
	}

	@Override
	public void exiting(String sourceMethod) {
		if (logger.isEnabledFor(org.apache.log4j.Level.TRACE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.trace(substitute("{0} - End", sourceMethod));
		}
	}

	@Override
	public boolean isTraceEnabled() {
		return logger.isEnabledFor(org.apache.log4j.Level.TRACE);
	}

	@Override
	public boolean isDebugEnabled() {
		return logger.isEnabledFor(org.apache.log4j.Level.DEBUG);
	}

	@Override
	public boolean isInfoEnabled() {
		return logger.isEnabledFor(org.apache.log4j.Level.INFO);
	}

	@Override
	public boolean isWarnEnabled() {
		return logger.isEnabledFor(org.apache.log4j.Level.WARN);
	}

	@Override
	public boolean isErrorEnabled() {
		return logger.isEnabledFor(org.apache.log4j.Level.ERROR);
	}

	@Override
	public void indent() {
		if (dent == null) {
			dent = new StringBuffer();
		}

		dent.append('\t');
	}

	@Override
	public void outdent() {
		if (dent != null && dent.length() > 0) {
			dent.setLength(dent.length() - 1);
		}
	}

	public static Implementator implementator() {
		return new Log4JLogging();
	}

	private org.apache.log4j.Level getImplLevel(Level level) {
		switch (level) {
		case DEBUG:
			return org.apache.log4j.Level.DEBUG;
		case ERROR:
			return org.apache.log4j.Level.ERROR;
		case INFO:
			return org.apache.log4j.Level.INFO;
		case TRACE:
			return org.apache.log4j.Level.TRACE;
		case WARNING:
			return org.apache.log4j.Level.WARN;
		default:
			throw new IllegalArgumentException("Unrecognized level " + level);
		}
	}

	@Override
	public Level getLevel() {
		org.apache.log4j.Level level = logger.getLevel();
		if (org.apache.log4j.Level.TRACE.equals(level)) {
			return Level.TRACE;
		} else if (org.apache.log4j.Level.DEBUG.equals(level)) {
			return Level.DEBUG;
		} else if (org.apache.log4j.Level.INFO.equals(level)) {
			return Level.INFO;
		} else if (org.apache.log4j.Level.WARN.equals(level)) {
			return Level.WARNING;
		} else if (org.apache.log4j.Level.ERROR.equals(level)) {
			return Level.ERROR;
		} else {
			return null;
		}
	}

	@Override
	public IFormatterLogger getParent() {
		return new Log4JFormatterLogger((Logger) (logger.getParent() instanceof Logger ? logger.getParent() : null));
	}

}