JSONEventLayout.java

package com.cwbase.logback;

import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.IThrowableProxy;
import ch.qos.logback.classic.spi.ThrowableProxyUtil;
import ch.qos.logback.core.LayoutBase;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Adapt from XMLLayout
 * 
 * @author kmtong
 * 
 */
public class JSONEventLayout extends LayoutBase<ILoggingEvent> {

	private final int DEFAULT_SIZE = 256;
	private final int UPPER_LIMIT = 2048;
	private final static char DBL_QUOTE = '"';
	private final static char COMMA = ',';

	private StringBuilder buf = new StringBuilder(DEFAULT_SIZE);
	private DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
	private Pattern MDC_VAR_PATTERN = Pattern.compile("\\@\\{([^}^:-]*)(:-([^}]*)?)?\\}");

	private boolean locationInfo = false;
	private int callerStackIdx = 0;
	private boolean properties = false;

	String source;
	String sourceHost;
	String sourcePath;
	List<String> tags;
	List<AdditionalField> additionalFields;
	String type;

	
	public JSONEventLayout() {
		try {
			setSourceHost(InetAddress.getLocalHost().getHostName());
		} catch (UnknownHostException e) {
		}
	}

	@Override
	public void start() {
		super.start();
	}

	/**
	 * The <b>LocationInfo</b> option takes a boolean value. By default, it is
	 * set to false which means there will be no location information output by
	 * this layout. If the the option is set to true, then the file name and
	 * line number of the statement at the origin of the log statement will be
	 * output.
	 * 
	 * <p>
	 * If you are embedding this layout within an
	 * <code>org.apache.log4j.net.SMTPAppender</code> then make sure to set the
	 * <b>LocationInfo</b> option of that appender as well.
	 */
	public void setLocationInfo(boolean flag) {
		locationInfo = flag;
	}

	/**
	 * Returns the current value of the <b>LocationInfo</b> option.
	 */
	public boolean getLocationInfo() {
		return locationInfo;
	}

	/**
	 * Sets whether MDC key-value pairs should be output, default false.
	 * 
	 * @param flag
	 *            new value.
	 * @since 1.2.15
	 */
	public void setProperties(final boolean flag) {
		properties = flag;
	}

	/**
	 * Gets whether MDC key-value pairs should be output.
	 * 
	 * @return true if MDC key-value pairs are output.
	 * @since 1.2.15
	 */
	public boolean getProperties() {
		return properties;
	}

	/**
	 * Formats a {@link ILoggingEvent} in conformity with the log4j.dtd.
	 */
	public synchronized String doLayout(ILoggingEvent event) {

		// Reset working buffer. If the buffer is too large, then we need a new
		// one in order to avoid the penalty of creating a large array.
		if (buf.capacity() > UPPER_LIMIT) {
			buf = new StringBuilder(DEFAULT_SIZE);
		} else {
			buf.setLength(0);
		}

		Map<String, String> mdc = event.getMDCPropertyMap();
		buf.append("{");
		appendKeyValue(buf, "source", source, mdc);
		buf.append(COMMA);
		appendKeyValue(buf, "host", sourceHost, mdc);
		buf.append(COMMA);
		appendKeyValue(buf, "path", sourcePath, mdc);
		buf.append(COMMA);
		appendKeyValue(buf, "type", type, mdc);
		buf.append(COMMA);
		appendKeyValue(buf, "tags", tags, mdc);
		buf.append(COMMA);
		appendKeyValue(buf, "message", event.getFormattedMessage(), null);
		buf.append(COMMA);
		appendKeyValue(buf, "@timestamp",
				df.format(new Date(event.getTimeStamp())), null);
		buf.append(COMMA);

		// ---- fields ----
		appendKeyValue(buf, "logger", event.getLoggerName(), null);
		buf.append(COMMA);
		appendKeyValue(buf, "level", event.getLevel().toString(), null);
		buf.append(COMMA);
		appendKeyValue(buf, "thread", event.getThreadName(), null);
		IThrowableProxy tp = event.getThrowableProxy();
		if (tp != null) {
			buf.append(COMMA);
			String throwable = ThrowableProxyUtil.asString(tp);
			appendKeyValue(buf, "throwable", throwable, null);
		}
		if (locationInfo) {
			StackTraceElement[] callerDataArray = event.getCallerData();
			if (callerDataArray != null
					&& callerDataArray.length > callerStackIdx) {
				buf.append(COMMA);
				buf.append("\"location\":{");
				StackTraceElement immediateCallerData = callerDataArray[callerStackIdx];
				appendKeyValue(buf, "class",
						immediateCallerData.getClassName(), null);
				buf.append(COMMA);
				appendKeyValue(buf, "method",
						immediateCallerData.getMethodName(), null);
				buf.append(COMMA);
				appendKeyValue(buf, "file", immediateCallerData.getFileName(),
						null);
				buf.append(COMMA);
				appendKeyValue(buf, "line",
						Integer.toString(immediateCallerData.getLineNumber()),
						null);
				buf.append("}");
			}
		}

		/*
		 * <log4j:properties> <log4j:data name="name" value="value"/>
		 * </log4j:properties>
		 */
		if (properties) {
			Map<String, String> propertyMap = event.getMDCPropertyMap();
			if ((propertyMap != null) && (propertyMap.size() != 0)) {
				Set<Entry<String, String>> entrySet = propertyMap.entrySet();
				buf.append(COMMA);
				buf.append("\"properties\":{");
				Iterator<Entry<String, String>> i = entrySet.iterator();
				while (i.hasNext()) {
					Entry<String, String> entry = i.next();
					appendKeyValue(buf, entry.getKey(), entry.getValue(), null);
					if (i.hasNext()) {
						buf.append(COMMA);
					}
				}
				buf.append("}");
			}
		}

		if(additionalFields != null) {
			for(AdditionalField field : additionalFields) {
				buf.append(COMMA);
				appendKeyValue(buf, field.getKey(), field.getValue(), mdc);
			}
		}

		buf.append("}");

		return buf.toString();
	}

	private void appendKeyValue(StringBuilder buf, String key, String value,
			Map<String, String> mdc) {
		if (value != null) {
			buf.append(DBL_QUOTE);
			buf.append(escape(key));
			buf.append(DBL_QUOTE);
			buf.append(':');
			buf.append(DBL_QUOTE);
			buf.append(escape(mdcSubst(value, mdc)));
			buf.append(DBL_QUOTE);
		} else {
			buf.append(DBL_QUOTE);
			buf.append(escape(key));
			buf.append(DBL_QUOTE);
			buf.append(':');
			buf.append("null");
		}
	}

	private void appendKeyValue(StringBuilder buf, String key,
			List<String> values, Map<String, String> mdc) {
		buf.append(DBL_QUOTE);
		buf.append(escape(key));
		buf.append(DBL_QUOTE);
		buf.append(':');
		buf.append('[');
		if (values != null) {
			Iterator<String> i = values.iterator();
			while (i.hasNext()) {
				String v = i.next();
				buf.append(DBL_QUOTE);
				buf.append(escape(mdcSubst(v, mdc)));
				buf.append(DBL_QUOTE);
				if (i.hasNext()) {
					buf.append(',');
				}
			}
		}
		buf.append(']');
	}

	private String mdcSubst(String v, Map<String, String> mdc) {
		if (mdc != null && v != null && v.contains("@{")) {
			Matcher m = MDC_VAR_PATTERN.matcher(v);
			StringBuffer sb = new StringBuffer(v.length());
			while (m.find()) {
				String val = mdc.get(m.group(1));
				if (val == null) {
					// If a default value exists, use it
					val = (m.group(3) != null) ? val = m.group(3) : m.group(1) + "_NOT_FOUND";
				}
				m.appendReplacement(sb, Matcher.quoteReplacement(val));
			}
			m.appendTail(sb);
			return sb.toString();
		}
		return v;
	}

	private String escape(String s) {
		if (s == null)
			return null;
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < s.length(); i++) {
			char ch = s.charAt(i);
			switch (ch) {
			case '"':
				sb.append("\\\"");
				break;
			case '\\':
				sb.append("\\\\");
				break;
			case '\b':
				sb.append("\\b");
				break;
			case '\f':
				sb.append("\\f");
				break;
			case '\n':
				sb.append("\\n");
				break;
			case '\r':
				sb.append("\\r");
				break;
			case '\t':
				sb.append("\\t");
				break;
			case '/':
				sb.append("\\/");
				break;
			default:
				if (ch >= '\u0000' && ch <= '\u001F') {
					String ss = Integer.toHexString(ch);
					sb.append("\\u");
					for (int k = 0; k < 4 - ss.length(); k++) {
						sb.append('0');
					}
					sb.append(ss.toUpperCase());
				} else {
					sb.append(ch);
				}
			}
		}// for
		return sb.toString();
	}

	@Override
	public String getContentType() {
		return "application/json";
	}

	public String getSource() {
		return source;
	}

	public void setSource(String source) {
		this.source = source;
	}

	public String getSourceHost() {
		return sourceHost;
	}

	public void setSourceHost(String sourceHost) {
		this.sourceHost = sourceHost;
	}

	public String getSourcePath() {
		return sourcePath;
	}

	public void setSourcePath(String sourcePath) {
		this.sourcePath = sourcePath;
	}

	public List<String> getTags() {
		return tags;
	}

	public void setTags(List<String> tags) {
		this.tags = tags;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public int getCallerStackIdx() {
		return callerStackIdx;
	}

	/**
	 * Location information dump with respect to call stack level. Some
	 * framework (Play) wraps the original logging method, and dumping the
	 * location always log the file of the wrapper instead of the actual caller.
	 * For PlayFramework, I use 2.
	 * 
	 * @param callerStackIdx
	 */
	public void setCallerStackIdx(int callerStackIdx) {
		this.callerStackIdx = callerStackIdx;
	}

	public void addAdditionalField(AdditionalField p) {
		if(additionalFields == null) {
			additionalFields = new ArrayList<AdditionalField>();
		}
		additionalFields.add(p);
	}

}