TracingClassLoader

A ClassLoader that instruments classes on load-time with tracing output statements.

Download sources for version 2.0, upgraded to work with Jakarta BCEL 20050813 (older version used

This is a ClassLoader that can add trace output around methods of classes without modifying the classes on disk. It is one of a series of experiments I intend to perform in the field of AOP.

The ClassLoader is initialized with a ClassMethodFilter, which is queried to determine which classes and methods list should be instrumented. In any case, the ClassLoader will not try to redefine classes in packages starting with java.* (this is not possible), nor will it instrument constructors (because the way I add instrumentation will not work with constructors, which are validated with special rules).

The instrumentation is really basic for now. While entering a method it outputs:

``thread''``method name''(``arguments'')

``thread''``this''.``method name''(``arguments'')

``thread''``method name''==>``return value''

``thread''``method name''==>(void)

``thread''``method name''==>threw exception ``exception''

This is sample output from a small run:

The utility name.dsouflis.aop.tracing.Trace is an application runner that uses a TracingClassLoader to run a class. It takes two arguments, the first being a comma-separated list of classes to trace, and the second being the class to run. It is used like this:

java name.dsouflis.aop.tracing.JavaWrapper ``class to instrument,...'' ``class to run'' ``arguments...''

The utility name.dsouflis.aop.tracing.AddTracing is a utility that uses internal methods of TracingClassLoader to instrument a class. The class image on disk is modified, and one can inspect it with javap or BCEL's listclass. If you run it more than once, or trace the resulting class, things will probably look very messy. It is used like this:

java name.dsouflis.aop.tracing.AddTracing ``class to instrument''

The supplied aopclsuite.jar and bcel.jar must be in the CLASSPATH.

How the instrumentation works

All methods that are instrumented have their names changed to "hidden$name", and new methods are created to take their place. The new methods call the hidden ones and take care of the output before and after the call. As an example, consider the following class: