Java, how to trace functions called

Question

I want to trace the beginning [& ending] of functions called in Java, like the following code:

    public void foo() {
  System.out.println(\"begin of fo         


        

Answer 1

Another approach would be using BTrace - it is kind of similar to AspectJ but can attach to a running java application and apply the logging code on-the-fly (it can also detach from the application, removing all the injected code but leaving the app running as it was before using BTrace)

In order to use BTrace you would write a simple tracing script which is POJO annotated with BTrace annotations (and some restrictions regarding what is possible to use to avoid crashing the target application).

In this case the the script would look like this:

@BTrace public class FooTracer {
  @OnMethod(clazz="Bar", method="foo")
  public static void onEntry() {
    println("begin of foo()");
  }

  @OnMethod(clazz="Bar", method="foo", location=@Location(Kind.RETURN))
  public static void onExit() {
    println("end of foo");
  }
}

There are many more things you can do with BTrace - just refer to the user guide and examples. Nominally, it is console application but there is integration into VisualVM making the experience of working with BTrace more pleasant.

Answer 2

If there are lots of methods to log, AOP could be used. For example, aspectJ.

Answer 3

You could use log4j for this:

static Logger log = Logger.getLogger(
                      log4jExample.class.getName());

public void loggedMethod() {

 log.info("begin of loggedMethod()");
  ...
 log.info("e-n-d of loggedMethod()");
}

Answer 4

The easiest approach is the one you've chose.

An easy replacement for the System.out calls would be using a logging framework. Then you could switch the information on and off according to a selected "logging level"

More sophisticated solutions would use aspect oriented programming techniques (provide by AspectJ, for instance), but this puts you on a steep learning curve.

Maybe a tool-based a approach fits your needs: so called "profilers" can "instrument" your code and report exactly which method was called during a run.