Auditoría Java: sistema para detectar excepciones lanzadas/atrapadas (¿aop?)

Question

Debido a excepciones comprobadas, podemos tener algunos problemas en la producción con todas las excepciones atrapadas en el lugar correcto y registradas correctamente.

Me pregunto si hay alguna herramienta de código abierto para ayudar a auditar estos problemas.

Por ejemplo, ¿hay alguna herramienta AOP que intercepte todas las excepciones lanzadas y vea si se vuelven a lanzar, envuelven o registran? Esto ayudaría a identificar las malas capturas.

Answer 1

Sé que el pregunta pregunta por una solución de código abierto. No sé de uno pero si la opción está allí, entonces DynaTrace hace exactamente lo que quiere. Buena suerte en tu búsqueda.

Answer 2

Existen herramientas como FindBugs, PMD y Checkstyle que pueden identificar algunos problemas comunes de manejo de excepciones. Nunca he visto una herramienta que analice específicamente el manejo de excepciones, ¡si alguien sabe que me interesará!

Answer 3

Si ha decidido que desea tomar la ruta AOP, Spring Framework proporciona un marco AOP fácil de usar. Básicamente, como gran parte de Spring, usaría una combinación de un archivo de configuración xml y un código java para definir la funcionalidad AOP que está buscando.

En su caso, creo que usted buscaría definir un 'Asesoramiento después de tirar', en el que, por supuesto, tendría acceso a la excepción lanzada.

Un buen punto de partida en cuanto a la documentación es el capítulo AOP en la documentación de la primavera: http://static.springsource.org/spring/docs/2.5.x/reference/aop.html

Ah, y creo que todos los proyectos de primavera son de código abierto, así =)

Answer 4

Tenía esta pregunta exacta, y me trataron de escribir algo a mí mismo, y debido a AOP proxy anidada y la falta de capacidad para usar instrumenation/tejer, me di por vencido y acaba de hacer una gran buscar y reemplazar

Uno de he herramientas que he encontrado en ese entonces para era AppSight por el software de BMC, pero de alto costo era un problema

Answer 5

inspector de IntelliJ puede comprobar el código para muchos problemas a medida que lo escribe:

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

Pero su problema parece ser que se trata más de educación que de tecnología. Necesita educar a su equipo sobre lo que significa el manejo adecuado de excepciones, cuándo debe hacerse, etc. Las herramientas lo ayudarán, pero no ponerlas en el código es que el primer lugar es mejor.

Utilizamos los aspectos de Spring para que nuestros sistemas de producción realicen operaciones de registro, seguimiento, cálculos de rendimiento, etc. Las recomendaciones previas, posteriores y excepcionales funcionan de maravilla: mantienen el código en un lugar y brindan flexibilidad declarativa en cuanto a dónde se aplican .

Solo una advertencia: los aspectos no son gratuitos. Añaden un costo a cada método al que los aplique, así que no los amontone. La moderación en todas las cosas es la clave.

Answer 6

no lo hice a pesar de eso todavía, pero una solución, si no es necesario para detectar las excepciones lanzadas en envirionment producción, es unir a la aplicación Java un depurador personalizado que puede ser activado cada vez que se produce una excepción .

Este artículo de blog francés habla de cómo hacerlo: http://blog.xebia.fr/2011/12/12/legacy-code-gestion-des-exceptions-avec-jpda/

Aquí está el código:

Ejecutar con depuración: Xdebug -Xrunjdwp: transport = dt_socket, dirección = 8000, = y servidor , suspender = n

Conecta con la 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); 
} 

Crear los puntos de interrupción. Ejemplo:

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

Y luego manejar las excepciones:

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

un poco pesado pero funciona, ahora cómo atrapar las excepciones que se registran y los demás?