/**
* Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.engine.calcnode;
import java.util.EnumSet;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.builder.ToStringStyle;
import com.opengamma.engine.view.ExecutionLog;
import com.opengamma.engine.view.ExecutionLogMode;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.log.LogEvent;
import com.opengamma.util.log.LogLevel;
import com.opengamma.util.log.SimpleLogEvent;
/**
* Allows log events which occur during function execution to be collected.
*/
public class MutableExecutionLog implements ExecutionLog {
private final ExecutionLogMode _logMode;
private final EnumSet<LogLevel> _logLevels = EnumSet.noneOf(LogLevel.class);
private final List<LogEvent> _events;
private String _exceptionClass;
private String _exceptionMessage;
private String _exceptionStackTrace;
public MutableExecutionLog(ExecutionLogMode logMode) {
ArgumentChecker.notNull(logMode, "logMode");
_events = logMode == ExecutionLogMode.FULL ? new LinkedList<LogEvent>() : null;
_logMode = logMode;
}
public MutableExecutionLog(ExecutionLog copyFrom) {
_logMode = ExecutionLogMode.FULL;
_logLevels.addAll(copyFrom.getLogLevels());
if (copyFrom.getEvents() != null) {
_events = new LinkedList<LogEvent>(copyFrom.getEvents());
} else {
_events = new LinkedList<LogEvent>();
}
_exceptionClass = copyFrom.getExceptionClass();
_exceptionMessage = copyFrom.getExceptionMessage();
_exceptionStackTrace = copyFrom.getExceptionStackTrace();
}
public static ExecutionLog single(LogEvent logEvent, ExecutionLogMode logMode) {
MutableExecutionLog log = new MutableExecutionLog(logMode);
log.add(logEvent);
return log;
}
//-------------------------------------------------------------------------
public void add(LogEvent logEvent) {
ArgumentChecker.notNull(logEvent, "logEvent");
LogLevel level = logEvent.getLevel();
_logLevels.add(level);
if (_logMode == ExecutionLogMode.FULL) {
_events.add(new SimpleLogEvent(level, logEvent.getMessage()));
}
}
public void setException(Throwable exception) {
_exceptionClass = exception.getClass().getName();
_exceptionMessage = exception.getMessage();
final StringBuilder buffer = new StringBuilder();
for (StackTraceElement element : exception.getStackTrace()) {
buffer.append(element.toString()).append("\n");
}
_exceptionStackTrace = buffer.toString();
_logLevels.add(LogLevel.WARN);
}
public void setException(String exceptionClass, String exceptionMessage) {
ArgumentChecker.notNull(exceptionClass, "exceptionClass");
_exceptionClass = exceptionClass;
_exceptionMessage = exceptionMessage;
_exceptionStackTrace = null;
_logLevels.add(LogLevel.WARN);
}
//-------------------------------------------------------------------------
@Override
public EnumSet<LogLevel> getLogLevels() {
return EnumSet.copyOf(_logLevels);
}
@Override
public List<LogEvent> getEvents() {
return _events;
}
//-------------------------------------------------------------------------
@Override
public boolean hasException() {
return getExceptionClass() != null;
}
@Override
public String getExceptionClass() {
return _exceptionClass;
}
@Override
public String getExceptionMessage() {
return _exceptionMessage;
}
@Override
public String getExceptionStackTrace() {
return _exceptionStackTrace;
}
//-------------------------------------------------------------------------
@Override
public boolean isEmpty() {
return _logLevels.isEmpty() && !hasException();
}
//-------------------------------------------------------------------------
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((_events == null) ? 0 : _events.hashCode());
result = prime * result + ((_exceptionClass == null) ? 0 : _exceptionClass.hashCode());
result = prime * result + ((_exceptionMessage == null) ? 0 : _exceptionMessage.hashCode());
result = prime * result + ((_exceptionStackTrace == null) ? 0 : _exceptionStackTrace.hashCode());
result = prime * result + ((_logLevels == null) ? 0 : _logLevels.hashCode());
result = prime * result + ((_logMode == null) ? 0 : _logMode.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof MutableExecutionLog)) {
return false;
}
MutableExecutionLog other = (MutableExecutionLog) obj;
return ObjectUtils.equals(_events, other._events)
&& ObjectUtils.equals(_exceptionClass, other._exceptionClass)
&& ObjectUtils.equals(_exceptionMessage, other._exceptionMessage)
&& ObjectUtils.equals(_exceptionStackTrace, other._exceptionStackTrace)
&& ObjectUtils.equals(_logLevels, other._logLevels)
&& ObjectUtils.equals(_logMode, other._logMode);
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer();
ToStringStyle style = ToStringStyle.SHORT_PREFIX_STYLE;
style.appendStart(sb, this);
if (hasException()) {
style.append(sb, "exception", getExceptionClass(), null);
}
if (!_logLevels.isEmpty()) {
style.append(sb, "logLevels", _logLevels, null);
}
style.appendEnd(sb, this);
return sb.toString();
}
}