Using Spring AOP to log swallowed exceptions

One example of bad programming style is to catch exceptions and then silently do nothing with - them, aka "swallowing" exceptions - which looks something like this:

...
preWork();

try {
doWork();
} catch (Exception e) {
// FIXME
// Dunno what to do with this exception...
}

postWork();
...

If this is your own code then you should fix it (and then severly punish yourself!). If it is someone elses code - for example a third party lib - and you have to use it then it can be very frustrating to have your code die silently; it makes code so much more difficult to debug.

(As a side note, exception swallowing is probably more common in Java because of a feature of the language - typed exceptions. But I've seen swallowed exception code in plently of other C++-like languages.)

I recently had such a problem when I was enhancing a Spring MVC application that used Tiles to lay out pages. Tiles often swallows exceptions. gggrrr.

What to do? It would take a fair amount of effort to fix exception handling in the Tiles code and also a fair amount of effort to step through the application code with a debugger.

Fortunately, Spring - the ultimate software hammer - provided the base infrastructure for a simple solution:

• Use ThrowsAdvice AOP advice to intercept an exception thrown from the application code, log the exception at ERROR level, and let the exception flow continue.
  

Step 1: Create a ThrowsAdvice to that will intercept and log an exception

package robertmaldon.util;

import java.lang.reflect.Method;

import java.io.PrintWriter;
import java.io.StringWriter;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.springframework.aop.ThrowsAdvice;

public final class LogThrowsAdvice implements ThrowsAdvice {
 private Log logger = LogFactory.getLog(this.getClass());

 public void afterThrowing(Method method, Object[] args,
                           Object target, Exception ex) throws Throwable {
     logger.error("Intercepted exception of type ["
                  + ex.getClass().getName()
                  + "] thrown by target class ["
                  + target.getClass().getName()
                  + "] and method [" + method.toString() + "]");

     logger.error(getStackTrace(ex));

     // Rethrow the exception in case something else downstream can
     // handle it.
     throw ex;
 }

 private String getStackTrace(Exception ex) {
     try {
         StringWriter sw = new StringWriter();
         PrintWriter pw = new PrintWriter(sw);
         ex.printStackTrace(pw);

         return sw.toString();
     } catch (Exception e) {
         return e.toString();
     }
 }
}

Step 2: Create the bean definition for the ThrowsAdvice and configure an autoproxy to wire the advice to your application code.

<!-- Bean definitions for your application code -->
<bean id="petStoreController1" .../>
<bean id="petStoreController2" .../>

<!-- Define the ThrowsAdvice bean -->
<bean id="logThrowsAdvice" class="robertmaldon.util.LogThrowsAdvice" />

<!-- Wire the advice to the application code -->
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames"><value>petStoreController*</value></property>
<property name="interceptorNames">
 <list>
   <value>logThrowsAdvice</value>
 </list>
</property>
</bean>

Step 3: There is no step 3!

Very simple, very easy.

This approach is good for development, but may introduce too much overhead for production.