/**
* Generate log event.
*
* @param logEventPack the log event pack
* @param header the header
* @return the list
* @throws IOException the io exception
*/
protected List<LogEventDto> generateLogEvent(LogEventPack logEventPack, RecordHeader header)
throws IOException {
LOG.debug(
"Generate LogEventDto objects from LogEventPack [{}] and header [{}]",
logEventPack,
header);
List<LogEventDto> events = new ArrayList<>(logEventPack.getEvents().size());
GenericAvroConverter<GenericRecord> eventConverter =
getConverter(logEventPack.getLogSchema().getSchema());
GenericAvroConverter<GenericRecord> headerConverter =
getConverter(header.getSchema().toString());
try {
for (LogEvent logEvent : logEventPack.getEvents()) {
LOG.debug("Convert log events [{}] to dto objects.", logEvent);
if (logEvent == null | logEvent.getLogData() == null) {
continue;
}
LOG.trace(
"Avro record converter [{}] with log data [{}]", eventConverter, logEvent.getLogData());
GenericRecord decodedLog = eventConverter.decodeBinary(logEvent.getLogData());
LOG.trace("Avro header record converter [{}]", headerConverter);
String encodedJsonLogHeader = headerConverter.encodeToJson(header);
String encodedJsonLog = eventConverter.encodeToJson(decodedLog);
events.add(new LogEventDto(encodedJsonLogHeader, encodedJsonLog));
}
} catch (IOException e) {
LOG.error("Unexpected IOException while decoding LogEvents", e);
throw e;
}
return events;
}
private void verifyEvent(LogEventListener listener1) {
ArgumentCaptor<LogEvent> event = ArgumentCaptor.forClass(LogEvent.class);
verify(listener1).onEvent(event.capture());
LogEvent value = event.getValue();
assertThat(value.getElement(), equalTo("div"));
assertThat(value.getSubject(), equalTo("click()"));
assertThat(value.getStatus(), equalTo(PASS));
}
@Override
public int compare(LogEvent o1, LogEvent o2) {
LocalDateTime t1 = o1.getTime();
LocalDateTime t2 = o2.getTime();
if (t1.isBefore(t2)) return 1;
else if (t1.isAfter(t2)) return -1;
return 0;
}
public synchronized LogEvent log(LogEvent ev) {
org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(ev.getRealm());
if (logger.isEnabledFor(_level)) {
ByteArrayOutputStream w = new ByteArrayOutputStream();
PrintStream p = new PrintStream(w);
ev.dump(p, "");
logger.log(_level, w.toString());
}
return ev;
}
@Override
public void log(LogEvent logEvent) {
LogRecord logRecord = logEvent.getLogRecord();
if (logRecord.getLevel() == Level.OFF) {
return;
}
String name = logEvent.getLogRecord().getLoggerName();
org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(name);
org.apache.log4j.Level level = toLog4jLevel(logRecord.getLevel());
String message = logRecord.getMessage();
Throwable throwable = logRecord.getThrown();
logger.callAppenders(new LoggingEvent(name, logger, level, message, throwable));
}
@Override
public void channelRead0(ChannelHandlerContext channelHandlerContext, LogEvent event)
throws Exception {
StringBuilder builder = new StringBuilder();
builder.append(event.getReceivedTimestamp());
builder.append(" [");
builder.append(event.getSource().toString());
builder.append("] [");
builder.append(event.getLogfile());
builder.append("] : ");
builder.append(event.getMsg());
System.out.println(builder.toString());
}
/** 日志服务主方法 由日志服务线程调用 */
public void process(Collection<LogEvent> list) {
for (LogEvent e : list) {
/*
* 对每一个LogEvent检查是否被过滤
*/
if (checkFilter(e) == false) {
continue;
}
// 获取LogAppender并输出日志
LogAppender appender = repository.getLogAppender(e);
appender.append(e.getLogContent());
}
}
public synchronized LogEvent log(LogEvent ev) {
if (p != null) {
if (permitLogging(ev.tag)) {
Date d = new Date();
p.println(
"<log realm=\""
+ ev.getRealm()
+ "\" at=\""
+ d.toString()
+ "."
+ d.getTime() % 1000
+ "\">");
ev.dump(p, " ");
p.println("</log>");
p.flush();
}
}
return ev;
}
// The implementing class can assume that the provided LogAbstraction
// partialTrace is
// of the same class, i.e. this.getClass().equals(partialTrace.getClass()) =
// true
//
// The implementing class can assume that the LogEvent provided is in the
// set returned by
// getPossibleNextLogEvents(partialTrace), i.e. in all instances
// represented by this abstraction, the given LogEvent is a possible
// next step.
public final Recommendation getRecommendation(
LogEvent logEventToDo, LogAbstraction partialTrace, SortedSet<LogEvent> enabledEvents) {
Recommendation rec = new Recommendation();
rec.setTask(logEventToDo.getModelElementName());
rec.setEventType(logEventToDo.getEventType());
double weight = calculateFitness(partialTrace);
if (weight > 0) {
SortedSet<LogEvent> possibleEvents = getPossibleNextLogEvents(partialTrace);
if (possibleEvents.contains(logEventToDo) && enabledEvents.contains(logEventToDo)) {
// It is possible to do this event, so give a recommendation
double[] vals = getAllValuesAndWeights(weight);
rec.setDoExpectedValue(vals[0]);
rec.setDoExpectedSquaredValue(vals[1]);
rec.setDoWeight(vals[2]);
} else {
// It is not possible to do this event, so give a "negative"
// recommendation
double w = 0;
double e = 0;
double e2 = 0;
for (LogEvent evt : possibleEvents) {
if (!enabledEvents.contains(evt)) {
continue;
}
// Event evt is not a possible event in this case,
// but is enabled in the query
double[] vals = getAllValuesAndWeights(weight);
double newW = w + vals[2];
e = (e * w + vals[0] * vals[2]) / newW;
e2 = (e2 * w + vals[1] * vals[2]) / newW;
w = newW;
}
rec.setDontExpectedValue(e);
rec.setDontExpectedSquaredValue(e2);
rec.setDontWeight(w);
}
}
return rec;
}
@Override
protected void finished(Description description) {
StringBuilder sb = new StringBuilder();
sb.append("Report for ").append(description.getDisplayName()).append('\n');
String delimiter = '+' + Joiner.on('+').join(line(20), line(70), line(10), line(10)) + "+\n";
sb.append(delimiter);
sb.append(String.format("|%-20s|%-70s|%-10s|%-10s|%n", "Element", "Subject", "Status", "ms."));
sb.append(delimiter);
for (LogEvent e : logEvents) {
sb.append(
String.format(
"|%-20s|%-70s|%-10s|%-10s|%n",
e.getElement(), e.getSubject(), e.getStatus(), e.getDuration()));
}
sb.append(delimiter);
log.info(sb.toString());
}
public synchronized LogEvent log(LogEvent ev) {
if (socket != null && ev.getTag() != null && tags.contains(ev.getTag())) {
int facility = cfg.getInt(ev.getTag() + ".facility", defaultFacility);
int severity = cfg.getInt(ev.getTag() + ".severity", defaultSeverity);
int priority = (facility << 3) | severity;
StringBuilder sb = new StringBuilder();
sb.append('<');
sb.append(Integer.toString(priority));
sb.append('>');
if (prefix != null) {
sb.append(prefix);
sb.append(' ');
}
sb.append(ev.getRealm());
sb.append(' ');
sb.append(ev.getTag());
sb.append(" - ");
synchronized (ev.getPayLoad()) {
Iterator iter = ev.getPayLoad().iterator();
for (int i = 0; iter.hasNext(); i++) {
if (i > 0) sb.append(' ');
sb.append(iter.next().toString());
}
}
byte[] b = sb.toString().getBytes();
DatagramPacket packet = new DatagramPacket(b, Math.min(b.length, 1024), host, port);
try {
socket.send(packet);
} catch (IOException e) {
ev.addMessage("--- SysLogListener error ---");
ev.addMessage(e);
}
}
return ev;
}
public void writeExternal(ObjectOutput out) throws IOException {
super.writeExternal(out);
out.writeObject(processId);
out.writeObject(processName);
out.writeLong(processInstanceId);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
super.readExternal(in);
processId = (String) in.readObject();
processName = (String) in.readObject();
processInstanceId = in.readLong();
}
public void logEvent(LogEvent logEvent) {
message = logEvent.getMessage();
}
