io.github.iac_m.jsonlogger.JsonLogger Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of json-logger-connector
JSON Logger is a custom-made Mule logger component which allows user to efficiently log traceable messages and Mule variables in JSON format.
The newest version!
package io.github.iac_m.jsonlogger;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.TimeZone;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.mule.api.ExceptionPayload;
import org.mule.api.MuleEvent;
import org.mule.api.MuleMessage;
import org.mule.api.annotations.Config;
import org.mule.api.annotations.Connector;
import org.mule.api.annotations.Processor;
import org.mule.api.annotations.display.Placement;
import org.mule.api.annotations.param.Default;
import org.mule.api.annotations.param.Optional;
import org.mule.api.transport.PropertyScope;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

import io.github.iac_m.jsonlogger.dto.LogMessage;
import io.github.iac_m.jsonlogger.dto.LogVariable;

@Connector(name = "json-logger", friendlyName = "JSON Logger")
public class JsonLogger {

	private final static org.apache.log4j.Logger LOG = LogManager.getLogger("application.jsonlogger");
	private final static String PAYLOAD_NAME = "payload";

	@Config
	private JsonLoggerConfig config;

	@Processor
	public Object log(MuleEvent context, @Placement(group = "Logger") @Default("") String message,
			@Placement(group = "Logger") @Default("") String variables,
			@Placement(group = "Logger") @Default("INFO") LogLevel level,
			@Placement(group = "Logger") @Optional String loggerName) {
		MuleMessage muleMessage = context.getMessage();
		LogMessage logMessage = LogHelper.getBasicLogMessage(muleMessage, message);
		HashSet variableNames = new HashSet(
				Arrays.asList(variables != null ? variables.replace(" ", "").split(",") : new String[0]));

		List varsToBeLogged = new ArrayList<>();
		LogVariable payload = new LogVariable();
		if (variableNames.contains(PAYLOAD_NAME)) {
			try {
				payload.setName(PAYLOAD_NAME);
				if (muleMessage.getPayload() != null) {
					payload.setValue(muleMessage.getPayloadForLogging());
				} else {
					payload.setValue("NULL PAYLOAD");
				}
				variableNames.remove(PAYLOAD_NAME);
			} catch (Exception e) {
				String errorMessage = "Unable to log payload. Message: " + message + ". Exception: " + e.getMessage();
				LOG.fatal(errorMessage, e);
				payload.setValue(errorMessage);
			}
			varsToBeLogged.add(payload);
		}

		varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INBOUND, variableNames,
				config.getLogVariableType()));
		varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.OUTBOUND, variableNames,
				config.getLogVariableType()));
		varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INVOCATION, variableNames,
				config.getLogVariableType()));
		logMessage.setVariables(varsToBeLogged);
		log(logMessage, level, StringUtils.isNotBlank(loggerName) ? loggerName : config.getDefaultLoggerName());
		return context.getMessage().getPayload();
	}

	@Processor
	public Object logAllProperties(MuleEvent context, @Placement(group = "Logger") @Default("") String message,
			@Placement(group = "Logger") @Default("Invocation") LogPropertyScope scope,
			@Placement(group = "Logger") @Default("INFO") LogLevel level,
			@Placement(group = "Logger") @Optional String loggerName) {
		MuleMessage muleMessage = context.getMessage();
		LogMessage logMessage = LogHelper.getBasicLogMessage(muleMessage, message);
		List varsToBeLogged = new ArrayList<>();

		if (scope == LogPropertyScope.Inbound || scope == LogPropertyScope.All) {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INBOUND,
					muleMessage.getPropertyNames(PropertyScope.INBOUND), config.getLogVariableType()));
		}
		if (scope == LogPropertyScope.Outbound || scope == LogPropertyScope.All) {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.OUTBOUND,
					muleMessage.getPropertyNames(PropertyScope.OUTBOUND), config.getLogVariableType()));
		}
		if (scope == LogPropertyScope.Invocation || scope == LogPropertyScope.All) {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INVOCATION,
					muleMessage.getPropertyNames(PropertyScope.INVOCATION), config.getLogVariableType()));
		}

		logMessage.setVariables(varsToBeLogged);

		log(logMessage, level, loggerName == null ? config.getDefaultLoggerName() : loggerName);
		return context.getMessage().getPayload();
	}

	@Processor
	public Object logException(MuleEvent context, @Placement(group = "Logger") @Default("") String message,
			@Placement(group = "Logger") @Default("INFO") LogLevel level,
			@Placement(group = "Logger") @Optional String loggerName) {
		final MuleMessage muleMessage = context.getMessage();
		final LogMessage logMessage = LogHelper.getBasicLogMessage(muleMessage, message);

		ExceptionPayload exceptionPayload = muleMessage.getExceptionPayload();
		if (exceptionPayload != null) {
			Throwable throwable = exceptionPayload.getException();
			logMessage.setThrowable(throwable);
		} else {
			logMessage.setThrowable(new RuntimeException("Unable to extract exception payload from message"));
		}

		List varsToBeLogged = new ArrayList<>();
		try {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INBOUND,
					muleMessage.getPropertyNames(PropertyScope.INBOUND), config.getLogVariableType()));
		} catch (Exception e) {
			LOG.error("Unable to extract inbound properties from mule message.", e);
		}
		try {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.OUTBOUND,
					muleMessage.getPropertyNames(PropertyScope.OUTBOUND), config.getLogVariableType()));
		} catch (Exception e) {
			LOG.error("Unable to extract outbound properties from mule message.", e);
		}
		try {
			varsToBeLogged.addAll(LogHelper.extractVariables(muleMessage, PropertyScope.INVOCATION,
					muleMessage.getPropertyNames(PropertyScope.INVOCATION), config.getLogVariableType()));
		} catch (Exception e) {
			LOG.error("Unable to extract invocation properties from mule message.", e);
		}
		logMessage.setVariables(varsToBeLogged);

		log(logMessage, level, loggerName == null ? config.getDefaultLoggerName() : loggerName);
		return context.getMessage().getPayload();
	}

	private void log(LogMessage logMessage, LogLevel level, String loggerName) {
		String logMessageString;
		if (config.getLogInPlainString()) {
			StringBuilder sb = new StringBuilder();
			sb.append("[CID: ").append(logMessage.getCorrelationId());
			if (StringUtils.isNotBlank(logMessage.getCorrelationIdLocal())) {
				sb.append(" CID.Local: ").append(logMessage.getCorrelationIdLocal());
			}
			sb.append("] ").append(logMessage.getMessage());
			String varsInString = LogHelper.variablesToString(logMessage.getVariables(), config.getLogVariableType());
			if (varsInString.length() > 0) {
				sb.append(" [").append(varsInString).append("]");
			}
			if (logMessage.getThrowable() != null) {
				Throwable t = logMessage.getThrowable();
				sb.append("\nException: ").append(ExceptionUtils.getMessage(t)).append(" ")
						.append(ExceptionUtils.getStackTrace(logMessage.getThrowable()));
				sb.append("");
			}
			logMessageString = sb.toString();
		} else {
			TimeZone tz = TimeZone.getTimeZone("UTC");
			DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
			df.setTimeZone(tz);
			logMessage.setTimestamp(df.format(new Date()));
			logMessage.setLevel(level.toString());
			logMessage.setLogger(loggerName);
			logMessage.setThread(Thread.currentThread().toString());
			Gson gson = new GsonBuilder().disableHtmlEscaping().disableHtmlEscaping().create();
			logMessageString = gson.toJson(logMessage);
		}

		Logger logger = LogManager.getLogger(loggerName);
		switch (level) {
		case INFO:
			logger.info(logMessageString);
			break;
		case ERROR:
			logger.error(logMessageString);
			break;
		case FATAL:
			logger.fatal(logMessageString);
			break;
		case DEBUG:
			logger.debug(logMessageString);
			break;
		}
	}

	public JsonLoggerConfig getConfig() {
		return config;
	}

	public void setConfig(JsonLoggerConfig config) {
		this.config = config;
	}

}