Audit Java: system to detect exceptions thrown / caught (aop?)

Due to checked exceptions, we can have some problems in production having all exceptions caught in the right place and logged correctly.

I wonder if there is some opensource tool to help with auditing these problem开发者_Go百科s.

For example, is there some AOP tool that would intercept all exceptions thrown and see if they are re-thrown, wrapped or logged? This would help identify the bad catches.

If you've decided that you would like to take the AOP route, the Spring Framework provides an easy to use AOP framework. Essentially, like much of Spring, you would use a combination of a xml config file and some java code to define the AOP functionality you are looking for.

In your case, I believe you would be looking to define an 'After Throwing Advice', in which you would of course have access to the exception thrown.

A good place to start in terms of documentation is the AOP Chapter in the Spring docs: http://static.springsource.org/spring/docs/2.5.x/reference/aop.html

Oh, and I believe all Spring projects are open source as well =)

I know the question asks for an open source solution. I don't know of one but if the option is there then DynaTrace does exactly what you want. Good luck on your search.

There are tools such as FindBugs, PMD and Checkstyle which can identify some common Exception handling issues. I'm never seen a tool that specifically analyses your exception handling, if anyone knows I'll be interested!

I had this exact question, and I attempted to write something myself, and due to AOP nested proxying and lack of ability to use instrumenation / weaving, I gave up and just did a wide find and replace

One of he tools I did find back then for was AppSight by BMC software, but it's high cost was an issue

IntelliJ's Inspector can check code for many problems as you write it:

http://www.jetbrains.com/idea/documentation/inspections.jsp

But your problem sounds like it's more about education than technology. You need to educate your team on what proper exception handling means, when it should be done, etc. Tools will help, but not putting them into the code is the first place is better.

We use Spring aspects for our production systems to do logging, tracing, performance calculations, etc. Before, after, and exception advice work wonders - they keep the code in one place and give declarative flexibility as to where they are applied.

Just one caution: aspects aren't free. They add cost to each method you apply them to, so don't just pile them on. Moderation in all things is the key.

I didn't though about that yet but one solution, if you do not need to detect exceptions thrown on production envirionment, is to attach to your Java application a custom debugger that can be triggered whenever an exception is raised.

This french blog article talk about how to do it: http://blog.xebia.fr/2011/12/12/legacy-code-gestion-des-exceptions-avec-jpda/

Here is the code:

Run with debug: Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n

Connect to the JVM:

public static VirtualMachine connect(String port) throws IOException, IllegalConnectorArgumentsException {
        AttachingConnector connector = null;
        VirtualMachineManager vmManager = Bootstrap.virtualMachineManager();
        for (Connector aconnector : vmManager.allConnectors()) {
            if ("com.sun.jdi.SocketAttach".equals(aconnector.name())) {
  connector = (AttachingConnector) aconnector;
  break;
     }
 }
 Map<String, Connector.Argument> args = connector.defaultArguments();
        Connector.Argument pidArgument = args.get("port");
        pidArgument.setValue(port);
        return connector.attach(args);
 }

Create your breakpoints. Exemple:

public static void createExceptionBreakPoint(VirtualMachine vm) {
        EventRequestManager erm = vm.eventRequestManager();
        List<ReferenceType> referenceTypes = vm.classesByName("java.lang.Throwable");
        for (ReferenceType refType : referenceTypes){
  ExceptionRequest exceptionRequest = erm.createExceptionRequest(refType, true, true);
  exceptionRequest.setEnabled(true);
 }
}

And then handle the exceptions:

public static void handleExceptionEvent(ExceptionEvent exceptionEvent) throws Exception {
        ObjectReference remoteException = exceptionEvent.exception();
        ThreadReference thread = exceptionEvent.thread();
        List<Value> paramList = new ArrayList<Value>(1);
        paramList.add(dumpFileName);
        //crer un printStream dans la JVM cible
        ObjectReference printStreamRef = printStreamClassType.newInstance(thread, printStreamConstructor, paramList,
            ObjectReference.INVOKE_SINGLE_THREADED);
    ReferenceType remoteType = remoteException.referenceType();
    Method printStackTrace = (Method) remoteType.methodsByName("printStackTrace").get(1);
    paramList.clear();
    paramList.add(printStreamRef);
    remoteException.invokeMethod(thread, printStackTrace, paramList, ObjectReference.INVOKE_SINGLE_THREADED);
    Scanner scanner = new Scanner(new File(dumpFileName.value()));
    while (scanner.hasNextLine()){
  System.out.println(scanner.nextLine());
 }
}

A bit heavy but it works, now how to catch the exceptions that are logged and the others?