Session of the day: JVM debugging

The second day at JavaOne was surprisingly just average. Kohsuke had a great talk about distributed Hudson builds and Hudson EC2 integration but the rest of the sessions was pretty normal. Then I am going into this session “Debugging your production JVM” from Ken Sipe and the guy blasts the roof off. He is showing all these nifty, cool tools that can help to get an insight what is going on in your JVM. Not just one tool but many. I am really having a hard time to write everything down. A lot of command-line tools that already come with Java like jstat, jps or jmap. They are ready to be used, you just need to know how to use them with the right parameters etc.

Then Ken starts to talk about something really fancy - BTrace. So how can BTrace help to debug your production VM. Essentially it is a little tool that you can use at runtime to at debugging “aspects” to your running Java bytecode. I use the word Aspect here because when I first saw it, BTrace felt quite similar to AspectJ. What BTrace does, it takes a little Script that your write in Java and dynamically injects it as tracing code into the running JVM.

What I called Script here is pure Java code. What you write looks almost exactly like a plain Java Classes with a lot of Annotations. The Code you can write as BTrace Script is really limited however. Ken had a slide in the presentation about all the Java stuff that is not doable. I only remember that you could not use the new keyword to create new objects. Luckily I found the other restrictions on the BTrace website:

• can not create new
  
• can not create new arrays.
  
• can not throw exceptions.
  
• can not catch exceptions.
  
• can not make arbitrary instance or static method calls - only the public static methods of com.sun.btrace.BTraceUtils class may be called from a BTrace program.
  
• can not assign to static or instance fields of target program's classes and objects. But, BTrace class can assign to it's own static fields ("trace state" can be mutated).
  
• can not have instance fields and methods. Only static public void returning methods are allowed for a BTrace class. And all fields have to be static.
  
• can not have outer, inner, nested or local classes.
  
• can not have synchronized blocks or synchronized methods.
  
• can not have loops (for, while, do..while)
  
• can not extend arbitrary class (super class has to be java.lang.Object)
  
• can not implement interfaces.
  
• can not contains assert statements.
  
• can not use class literals.
  

Your hands are tied. Well almost. So let's have a look at a sample from the BTrace website.

import com.sun.btrace.annotations.*;
import static com.sun.btrace.BTraceUtils.*;

// @BTrace annotation tells that this is a BTrace program
@BTrace
public class HelloWorld {

// @OnMethod annotation tells where to probe.
// In this example, we are interested in entry
// into the Thread.start() method.
@OnMethod(
    clazz="java.lang.Thread",
    method="start"
)
public static void func() {
    // println is defined in BTraceUtils
    // you can only call the static methods of BTraceUtils
    println("about to start a thread!");
}
}

You can see, it is a standard Java class annotated with @BTrace. Then it says @OnMethod with two parameters which translates to – every time the start method is invoked in java.lang.Thread ... What it will do in that case is invoke the static function it will find within the @BTrace annotated class. It has to be a static method. I forgot if it had to follow a naming convention too. So the static method will be invoked every time a Thread is started. In the sample, it will just print out something fixed on the console. You could also count the number of Threads or other things.

Here is another example.

@BTrace public class Memory {
@OnTimer(4000)
public static void printMem() {
    println("Heap:");
    println(heapUsage());
    println("Non-Heap:");
    println(nonHeapUsage());
}
}

This will print out memory usage every 4 seconds. Awesome. Now something really huge.

@BTrace public class HistogramBean {
// @Property exposes this field as MBean attribute
@Property
private static Map histo = newHashMap();

@OnMethod(
    clazz="javax.swing.JComponent",
    method=""
)
public static void onnewObject(@Self Object obj) {
    ....
}

@OnTimer(4000)
public static void print() {
    if (size(histo) != 0) {
        printNumberMap("Component Histogram", histo);
    }
}
}

Don't worry about the details what it does right now. The important part is that you can annotate fields with @Property and have BTrace expose these fields as Mbean. All you need to do is inject the BTrace script a little bit different from the command line.

Some words on the @OnMethod, @OnTimer stuff. These Annotations are called probe points and there are more like @OnMemoryLow, @OnExit, @OnError etc. Another example is to use BTrace to monitor entering and leaving of synchronization blocks.

Unfortunately BTrace requires Java 6+, it will not work with 5. Now you have a good reason to step up your Java version.