/*
* Copyright (c) 2014, 2015, Dynatrace and/or its affiliates. All rights reserved.
*
* This file is part of the Lock Contention Tracing Subsystem for the HotSpot
* Virtual Machine, which is developed at Christian Doppler Laboratory on
* Monitoring and Evolution of Very-Large-Scale Software Systems. Please
* contact us at if you need additional information
* or have any questions.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work. If not, see .
*
*/
package sun.evtracing.processing;
import static java.lang.System.err;
import sun.evtracing.parser.ClassLoaderUnloadEvent;
import sun.evtracing.parser.ClassMetadataEvent;
import sun.evtracing.parser.GroupEvent;
import sun.evtracing.parser.MetadataResetEvent;
import sun.evtracing.parser.MethodMetadataEvent;
import sun.evtracing.parser.MonitorContendedEnterEvent;
import sun.evtracing.parser.MonitorContendedEnteredEvent;
import sun.evtracing.parser.MonitorContendedExitedEvent;
import sun.evtracing.parser.MonitorDeflateEvent;
import sun.evtracing.parser.MonitorInflateEvent;
import sun.evtracing.parser.SafepointBeginEvent;
import sun.evtracing.parser.SafepointEndEvent;
import sun.evtracing.parser.StackMetadataEvent;
import sun.evtracing.parser.ThreadExitEvent;
import sun.evtracing.parser.ThreadInterruptEvent;
import sun.evtracing.parser.ThreadNameChangeEvent;
import sun.evtracing.parser.ThreadParkBeginEvent;
import sun.evtracing.parser.ThreadParkEndEvent;
import sun.evtracing.parser.ThreadStartEvent;
import sun.evtracing.parser.ThreadStateChangeEvent;
import sun.evtracing.parser.ThreadUnparkEvent;
import sun.evtracing.parser.VMEndEvent;
public class TraceEventPrintHandler extends DelegateTraceEventHandler {
private long time = -1;
public TraceEventPrintHandler(TraceEventHandler delegate) {
super(delegate);
}
private String update(long time) {
long diff = time - this.time;
if (this.time == -1) {
diff = 0;
}
this.time = time;
return String.format("time +%05d", diff / 100);
}
@Override
public void threadStart(ThreadStartEvent event) {
err.printf("thread %d %s start: \"%s\"%n", event.thread().identifier(), update(event.timestamp()), event.name());
super.threadStart(event);
}
@Override
public void threadNameChange(ThreadNameChangeEvent event) {
err.printf("thread %d %s name change of thread %d: \"%s\"%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier(), event.newName());
super.threadNameChange(event);
}
@Override
public void threadStateChange(ThreadStateChangeEvent event) {
err.printf("thread %d %s state change of thread %d: %s%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier(), event.newState().toString());
super.threadStateChange(event);
}
@Override
public void threadInterrupt(ThreadInterruptEvent event) {
err.printf("thread %d %s interrupt of thread %d%n", event.thread().identifier(), update(event.timestamp()), event.affectedThread().identifier());
super.threadInterrupt(event);
}
@Override
public void threadExit(ThreadExitEvent event) {
err.printf("thread %d %s end%n", event.thread().identifier(), update(event.timestamp()));
super.threadExit(event);
}
@Override
public void threadParkBegin(ThreadParkBeginEvent event) {
err.printf("thread %d %s seq %05d park begin nestingLevel %d isAbsolute %b for %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.nestingLevel(), event.isAbsolute(), event.parkTime());
super.threadParkBegin(event);
}
@Override
public void threadParkEnd(ThreadParkEndEvent event) {
err.printf("thread %d %s seq %05d park end %s caused by unpark %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.parkReturnCode(), event.unparkSequenceNumber());
super.threadParkEnd(event);
}
@Override
public void threadUnpark(ThreadUnparkEvent event) {
err.printf("thread %d %s seq %05d unpark thread %d replaced unpark %d%n", event.thread().identifier(), update(event.timestamp()), event.sequenceNumber(), event.unparkedThread().identifier(), event.chainedSequenceNumber());
super.threadUnpark(event);
}
@Override
public void monitorInflate(MonitorInflateEvent event) {
err.printf("thread %d %s inflated monitor %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
super.monitorInflate(event);
}
@Override
public void monitorDeflate(MonitorDeflateEvent event) {
err.printf("thread %d %s deflated monitor %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
super.monitorDeflate(event);
}
@Override
public void monitorContendedEnter(MonitorContendedEnterEvent event) {
err.printf("thread %d %s contended enter on %d with stack trace %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor(), event.stack().identifier());
super.monitorContendedEnter(event);
}
@Override
public void monitorContendedEntered(MonitorContendedEnteredEvent event) {
err.printf("thread %d %s contended entered on %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor());
super.monitorContendedEntered(event);
}
@Override
public void monitorContendedExited(MonitorContendedExitedEvent event) {
err.printf("thread %d %s contended exited on %d with stack trace %d%n", event.thread().identifier(), update(event.timestamp()), event.monitor(), event.stack().identifier());
super.monitorContendedExited(event);
}
@Override
public void classMetadata(ClassMetadataEvent event) {
err.printf("class %d from class loader %d has name %s%n", event.clazz(), event.classLoader(), event.name());
super.classMetadata(event);
}
@Override
public void safepointBegin(SafepointBeginEvent event) {
err.printf("thread %d %s begin safepoint %s%n", event.thread().identifier(), update(event.timestamp()), event.reason().toString());
super.safepointBegin(event);
}
@Override
public void safepointEnd(SafepointEndEvent event) {
err.printf("thread %d %s end safepoint, %d op(s) processed%n", event.thread().identifier(), update(event.timestamp()), event.processedOps());
super.safepointEnd(event);
}
@Override
public void endVM(VMEndEvent event) {
err.printf("thread %d %s end VM%n", event.thread().identifier(), update(event.timestamp()));
super.endVM(event);
}
@Override
public void methodMetadata(MethodMetadataEvent event) {
err.printf("method %d from class %d has name %s and signature %s%n", event.method(), event.clazz().identifier(), event.name(), event.signature());
super.methodMetadata(event);
}
@Override
public void classLoaderUnload(ClassLoaderUnloadEvent event) {
err.printf("class loader %d unloaded%n", event.classLoader());
super.classLoaderUnload(event);
}
@Override
public void stackMetadata(StackMetadataEvent event) {
err.printf("stack trace %d with %d frames%n", event.stack(), event.methods().length);
super.stackMetadata(event);
}
@Override
public void metadataReset(MetadataResetEvent event) {
err.printf("thread %d metadata reset%n", event.thread().identifier());
super.metadataReset(event);
}
@Override
public void group(GroupEvent event) {
err.printf("thread %d group %d %d src %s@%s%n", event.thread().identifier(), event.sequenceBeginReference(), event.sequenceNumber(), event.clazz().metadata().name(), Integer.toHexString(event.obj()));
super.group(event);
}
}