Injecting Better Logging Into a Binary .class Using Javassist

have you ever been struck by a completely useless exception message somewhere from the depths of a 3rd party application or library you had to use in your code? have you ever wanted the bloody nameless programmer to have written a truly informative and helpful error message so that you wouldn’t need to spend hours trying to figure out what was the problem that would have been easily discovered if only more context information available at the moment when the exception occured was included in its error message? have you wondered how only you could inject the necessary logging into the spot? read on to get the answer.

recently i was testing my extension to saba, a monstrous j2ee learning management system, and got an exception from a saba class saying that the expected and actual data types of a custom attribute don’t match.  the problem was that i had no idea which one of the 10s of custom attributes could be the cause and i even wasn’t sure which object’s attributes i should check. it would be so much easier if the "nameless bloody saba programmer" (no offense ) included the attribute’s name and preferably also its actual & expected data types and the actual and new values. how could i insert there logging of these properties? needless to say that i had to use java 1.4 (no agents…) and couldn’t afford more than modifying this single class file (i.e. no additional libraries etc.) because the changes i could do to the development environment where the application ran were limited.

of course the easiest would have been to decomile the class, add the loging before the exception is thrown, recompile it and replace it on the server. but not only is decompiling illegal here, it also sometimes simply doesn’t work. fortunatelly there is another solution – jboss javassist is a byte code manipulation library that supports not only runtime manipulation but also post-comilation time manipulation, i.e. you can modify and save the class and use it to replace the original file. there are quite a few byte code manipulation libraries but javassist has the great advantage that you don’t need to know much about bytecode, you can simply pass a string with java statements that should be inserted before/after/… method call or into a new catch statement. there is a nice tutorial that describes it (see part 4.1, inserting source text at the beginning/end of a method body):

addcatch() inserts a code fragment into a method body so that the code fragment is executed when the method body
throws an exception and the control returns to the caller. in the source text representing the inserted code fragment,
the exception value is referred to with the special variable $e.

for example, this program:

classpool pool = classpool.getdefault();
ctclass compiledclass = pool.get("mypackage.myclass");
ctmethod m = compiledclass.getdeclaredmethod("myexceptionthrowingmethod");
ctclass etype = classpool.getdefault().get("java.io.ioexception");
m.addcatch("{ system.out.println($e); throw $e; }", etype);

translates the method body represented by m into something like this:

try {
the original method body
}
catch (java.io.ioexception e) {
system.out.println(e);
throw e;
}

note that the inserted code fragment must end with a throw or return statement.

you can use $e to access the exception, $0 to access "this", $1 to access the 1st parameter of the method etc. at the end you just call compiledclass.writefile(); and use the modified mypackage/myclass.class to replace the original class in the application.

lovely, isn’t it?

from http://theholyjava.wordpress.com/2008/10/02/injecting-better-logging-into-a-bi/