org.ioc.commons.utils.BufferLogger Maven / Gradle / Ivy

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

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

import org.ioc.commons.utils.FormatterLogger.Implementator;
import org.ioc.commons.utils.logs.IFormatterLogger.Level;

/**
 * A logger able to hold messages until calling flush methods.
 * 
 * @author Jesús Lunar Pérez
 * 
 */
public class BufferLogger {

	protected final FormatterLogger logger;
	private StringBuffer dent;
	private static final ThreadLocal> heldMessagesTL = new ThreadLocal>();

	protected BufferLogger(FormatterLogger logger) {
		this.logger = logger;
	}

	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("\\$", "\\\\\\$");
	}

	public static BufferLogger getLogger(Class clazz) {
		return new BufferLogger(FormatterLogger.getLogger(clazz));
	}

	public static BufferLogger getLogger(Class clazz, Implementator implementation) {
		return new BufferLogger(FormatterLogger.getLogger(clazz, implementation));
	}

	public void trace(String string, Object... params) {
		if (logger.isTraceEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.trace(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

	public void debug(String string, Object... params) {
		if (logger.isDebugEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.debug(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

	public void info(String string, Object... params) {
		if (logger.isInfoEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.info(msg);
			} else {
				heldMessages.add(msg);
			}

		}
	}

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

	public void warn(String string, Object... params) {
		if (logger.isWarnEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.warn(msg);
			} else {
				heldMessages.add(msg);
			}

		}
	}

	public void warn(Throwable e, String string, Object... params) {
		if (logger.isWarnEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.warn(e, msg);
			} else {
				heldMessages.add(msg);
				holdStackTrace(e, heldMessages);
			}
		}
	}

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

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

	public void error(String string, Object... params) {
		if (logger.isErrorEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.error(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

	public void error(Throwable e, String string, Object... params) {
		if (logger.isErrorEnabled()) {
			if (dent != null) {
				string = dent + string;
			}
			String msg = substitute(string, params);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.error(e, msg);
			} else {
				heldMessages.add(msg);
				holdStackTrace(e, heldMessages);
			}
		}
	}

	private void holdStackTrace(Throwable e, List heldMessages) {
		String newline = "\n";
		String indent = "\t";
		if (e == null) {
			return;
		}
		// For each cause, print the requested number of entries of its stack
		// trace, being careful to avoid getting stuck in an infinite loop.
		//
		StringBuffer s = new StringBuffer(newline);
		Throwable currentCause = e;
		String causedBy = "";
		HashSet seenCauses = new HashSet();
		while (currentCause != null && !seenCauses.contains(currentCause)) {
			seenCauses.add(currentCause);
			s.append(causedBy);
			causedBy = newline + "Caused by: "; // after 1st, all say
												// "caused by"
			s.append(currentCause.getClass().getName());
			s.append(": " + currentCause.getMessage());
			StackTraceElement[] stackElems = currentCause.getStackTrace();
			if (stackElems != null) {
				for (int i = 0; i < stackElems.length; ++i) {
					s.append(newline + indent + "at ");
					s.append(stackElems[i].toString());
				}
			}

			currentCause = currentCause.getCause();
		}
		heldMessages.add(s.toString());
	}

	public void error(Throwable e) {
		if (logger.isErrorEnabled()) {
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.error(e, null);
			} else {
				holdStackTrace(e, heldMessages);
			}
		}
	}

	public void entering(String sourceMethod, String string, Object... params) {
		if (logger.isTraceEnabled()) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			String msg = substitute("{0} - Start. {1}", sourceMethod, substitute(string, params));
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.trace(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

	public void entering(String sourceMethod) {
		if (logger.isTraceEnabled()) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			String msg = substitute("{0} - Start", sourceMethod);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.trace(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

	public void exiting(String sourceMethod, String string, Object... result) {
		if (logger.isTraceEnabled()) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			String msg = substitute("{0} - End. {1}", sourceMethod, substitute(string, result));
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.trace(msg);
			} else {
				heldMessages.add(msg);
			}

		}
	}

	public void exiting(String sourceMethod) {
		if (logger.isTraceEnabled()) {
			if (dent != null) {
				sourceMethod = dent + sourceMethod;
			}
			String msg = substitute("{0} - End", sourceMethod);
			List heldMessages = heldMessagesTL.get();
			if (heldMessages == null) {
				logger.trace(msg);
			} else {
				heldMessages.add(msg);
			}
		}
	}

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

	public boolean isTraceEnabled() {
		return logger.isTraceEnabled();
	}

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

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

	public boolean isWarnEnabled() {
		return logger.isWarnEnabled();
	}

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

	public void indent() {
		synchronized (this) {
			if (dent == null) {
				dent = new StringBuffer();
			}
		}

		dent.append('\t');
	}

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

	/**
	 * Starts holding messages unitl {@link #flush()} method is called.
	 */
	public void hold() {
		List heldMessages = heldMessagesTL.get();
		if (heldMessages == null) {
			heldMessages = new ArrayList();
			heldMessagesTL.set(heldMessages);
		}
	}

	/**
	 * Get the current buffer for held messages. Messages are not flushed yet.
	 * 
	 * @return Current buffer.
	 */
	public StringBuffer toBuffer() {
		return toBuffer(false);
	}

	/**
	 * Flushes held messages from {@link #hold()} method was called.
	 */
	public void flush() {
		StringBuffer buffer = toBuffer(true);

		Level level = null;

		if (buffer.length() == 0) {
			return;
		}

		FormatterLogger fromLogger = logger;
		while (fromLogger != null && (level = fromLogger.getLevel()) == null) {
			fromLogger = logger.getParent();
		}

		if (level == null) {
			/*
			 * By default
			 */
			level = Level.INFO;
		}

		logger.log(level, buffer.toString());
	}

	protected StringBuffer toBuffer(boolean flush) {
		StringBuffer buffer = new StringBuffer();
		List heldMessages = heldMessagesTL.get();
		if (heldMessages != null) {
			for (String message : heldMessages) {
				buffer.append(message).append('\n');
			}
			if (flush) {
				heldMessagesTL.set(null);
			}
		}
		return buffer;
	}

	/**
	 * Indicates if a message which was logged previously is currently held.
	 * 
	 * @param string Message
	 * @param params Params
	 * @return Messages are held or not.
	 */
	public boolean isHeld(String string, Object... params) {
		if (dent != null) {
			string = dent + string;
		}

		String msg = substitute(string, params);
		List heldMessages = heldMessagesTL.get();
		return (heldMessages == null) ? false : heldMessages.contains(msg);
	}

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

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


}