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 foo()");
  ...
  System.out.println("e-n-d of foo()");
 }

But maintaining of the dump code System.out.println is something tedious and error-prone, for there may be tens of thounds of function in an class.

Any good idea can ease this work? I don't want dump statements all over the file.

Implementation of both or one of the beginning & ending traces is perferd.
But, if impossible, recordings of that the function has been called is also helpful. I mean not care the exact beginnig and ending, just tell that the function has been called.

For what it's worth, I believe AspectJ is intended for things like this. It will modify your compiled byte code with hooks that you specify. Never used it, but I think that's something it does. — david van brink, Jan 13 '11 at 06:47
http://stackoverflow.com/questions/4653013/is-there-an-aspect-already-written-and-tested-well-for-trace-logging — Aravind Yarram, Jan 13 '11 at 06:54

score 9 · Answer 1 · answered Jan 13 '11 at 18:07

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.

score 2 · Accepted Answer · answered Jan 13 '11 at 06:50

2

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.

answered Jan 13 '11 at 06:50

Andreas Dolk

113,398
19
180
268

The later is the most desirable I think, as I doubt such behaviour would be desirable in production code, and why re-invent the wheel with AOP. Something like TPTP for Eclipse should be able to give a dump of all function calls and even timings. The output's probably going to be in some binary format, but that may be ok given that it's likely to be massive. – CurtainDog Jan 13 '11 at 07:13
I won't attach any code to these functions, for that's not my code, and that will need a lot of work. AspectJ may work. But what a "profilers" is, also, what a tool-based approach is, can you give an example or an link. That will be appreciate. Thanks in advance. – user435657 Jan 13 '11 at 07:47
@CurtainDog: Thanks a lot. Indeed I need one of languages related solution. – user435657 Jan 13 '11 at 07:50
@user435657 - what's your intention? A profiler (like [TPTP](http://www.eclipse.org/tptp/)) always comes with a report viewer, they are *designed* to support analysis tasks. You don't have to write a single line of code - just start the application from the profiler and it records all method calls. – Andreas Dolk Jan 13 '11 at 08:06

score 2 · Answer 3 · answered Jan 13 '11 at 06:58

2

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

answered Jan 13 '11 at 06:58

卢声远 Shengyuan Lu

31,208
22
85
130

你好！Should I append aditional code to those functions if using aspectJ. – user435657 Jan 13 '11 at 07:52
No need to write additional code in Java. Write log code in aspectJ, then mix up aspectJ code to Java byte code, the process is called 'wave'. An simple example: http://www.javaworld.com/javaworld/jw-03-2002/jw-0301-aspect2.html?page=2 – 卢声远 Shengyuan Lu Jan 13 '11 at 08:16

score 0 · Answer 4 · answered Jan 13 '11 at 07:12

0

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()");
}

answered Jan 13 '11 at 07:12

Feras Odeh

9,136
20
77
121

Sorry that I mean get ride of suppling any addition code to log/record that the function has been called. – user435657 Jan 13 '11 at 07:38

Java, how to trace functions called

4 Answers4

Linked