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

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

import java.util.logging.Handler;
import java.util.logging.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 JavaLoggingFormatterLogger implements IFormatterLogger {

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

	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 JavaLoggingFormatterLogger getLogger(Class clazz) {
		return new JavaLoggingFormatterLogger(Logger.getLogger(clazz.getName()));
	}

	protected JavaLoggingFormatterLogger(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) {
		java.util.logging.Level implLevel = getImplLevel(level);
		if (logger.isLoggable(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.isLoggable(java.util.logging.Level.FINER)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.finer(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.isLoggable(java.util.logging.Level.FINE)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.fine(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.isLoggable(java.util.logging.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.isLoggable(java.util.logging.Level.WARNING)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.warning(substitute(string, params));
		}
	}

	@Override
	public void warn(Throwable e, String string, Object... params) {
		if (logger.isLoggable(java.util.logging.Level.WARNING)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(java.util.logging.Level.WARNING, 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.isLoggable(java.util.logging.Level.SEVERE)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(java.util.logging.Level.SEVERE, substitute(string, params));
		}
	}

	@Override
	public void error(Throwable e, String string, Object... params) {
		if (logger.isLoggable(java.util.logging.Level.SEVERE)) {
			if (dent != null) {
				string = dent + string;
			}
			logger.log(java.util.logging.Level.SEVERE, substitute(string, params), e);
		}
	}

	@Override
	public void error(Throwable e) {
		if (logger.isLoggable(java.util.logging.Level.SEVERE)) {
			logger.log(java.util.logging.Level.SEVERE, null, e);
		}
	}

	@Override
	public void entering(String sourceMethod, String msg, Object... params) {
		if (logger.isLoggable(java.util.logging.Level.FINE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.fine(substitute("{0} - Start. {1}", sourceMethod, substitute(msg, params)));
		}
	}

	@Override
	public void entering(String sourceMethod) {
		if (logger.isLoggable(java.util.logging.Level.FINE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.fine(substitute("{0} - Start", sourceMethod));
		}
	}

	@Override
	public void exiting(String sourceMethod, String msg, Object... result) {
		if (logger.isLoggable(java.util.logging.Level.FINE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.fine(substitute("{0} - End. {1}", sourceMethod, substitute(msg, result)));
		}
	}

	@Override
	public void exiting(String sourceMethod) {
		if (logger.isLoggable(java.util.logging.Level.FINE)) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			logger.fine(substitute("{0} - End", sourceMethod));
		}
	}

	// @Override
	public void addHandler(Handler handler) {
		logger.addHandler(handler);
	}

	@Override
	public boolean isTraceEnabled() {
		return logger.isLoggable(java.util.logging.Level.FINER);
	}

	@Override
	public boolean isDebugEnabled() {
		return logger.isLoggable(java.util.logging.Level.FINE);
	}

	@Override
	public boolean isInfoEnabled() {
		return logger.isLoggable(java.util.logging.Level.INFO);
	}

	@Override
	public boolean isWarnEnabled() {
		return logger.isLoggable(java.util.logging.Level.WARNING);
	}

	@Override
	public boolean isErrorEnabled() {
		return logger.isLoggable(java.util.logging.Level.SEVERE);
	}

	@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 JavaLogging();
	}

	private java.util.logging.Level getImplLevel(Level level) {
		switch (level) {
		case DEBUG:
			return java.util.logging.Level.FINE;
		case ERROR:
			return java.util.logging.Level.SEVERE;
		case INFO:
			return java.util.logging.Level.INFO;
		case TRACE:
			return java.util.logging.Level.FINER;
		case WARNING:
			return java.util.logging.Level.WARNING;
		default:
			throw new IllegalArgumentException("Unrecognized level " + level);
		}
	}

	@Override
	public Level getLevel() {
		java.util.logging.Level level = logger.getLevel();
		int iLevel = level.intValue();
		if (iLevel < java.util.logging.Level.FINE.intValue()) {
			return Level.TRACE;
		} else if (iLevel >= java.util.logging.Level.FINE.intValue() && iLevel < java.util.logging.Level.INFO.intValue()) {
			return Level.DEBUG;
		} else if (iLevel >= java.util.logging.Level.INFO.intValue() && iLevel < java.util.logging.Level.WARNING.intValue()) {
			return Level.INFO;
		} else if (iLevel >= java.util.logging.Level.WARNING.intValue() && iLevel < java.util.logging.Level.SEVERE.intValue()) {
			return Level.WARNING;
		} else if (iLevel >= java.util.logging.Level.SEVERE.intValue()) {
			return Level.ERROR;
		} else {
			return null;
		}
	}

	@Override
	public IFormatterLogger getParent() {
		return new JavaLoggingFormatterLogger(logger.getParent());
	}

}