JEXIN Overview

Jexin implements error simulation using exception injection. Exception injection means a method call is intercepted and a user defined exception is thrown by Jexin to simulate some error. For example, say there is a method called sendMessage that sends a message to a JMS queue. A Jexin user could configure sendMessage to throw an exception when it is called to simulate the queue being unavailable. Jexin uses Java annotations and aspects to identify methods that allow exceptions to be injected. The actual exception to be injected (if any) is determined at runtime using the Jexin web application.

Jexin supports several views of stack traces including side-by-side comparison and merging of traces from different threads/JVMs into a single trace. This also makes Jexin a useful debugging tool. Jexin does not run tests; it monitors the application and injects exceptions. The tests may be run manually or using a testing framework.

Jexin includes a web application and client jar. The web application is packaged as a WAR file and should function in any web container (Tomcat 6 was used for testing). Only one server instance is needed to work with several applications and/or environments. The web application supports Firefox and Internet Explorer. The client jar is included in the application(s) under test. Using Jexin in the application under test consists of annotating methods and creating the trace server. The Traceable annotation determines which methods are included in the Jexin stack traces and developer recommendations regarding exceptions likely to occur within the method. The TraceServer communicates with the Jexin web application. The TraceServer may be easily configured using Spring or configured directly in code.

Main Features:

• Exceptions are injected based on stack trace analysis. I don't usually want to throw an exception every time method x is called, only when method x is called in the context of a particular call stack. For example, I don't want to throw a StaleObjectStateException every time my dao.update() method is called, only when it is called in the context of a particular call stack.
• Exceptions to be injected are selected at runtime from a simple dropdown with developer recommended likely exceptions highlighted.
• There is no requirement for the user to have network connectivity to the application being monitored. The Jexin user and application being monitored are both clients of the Jexin web app so they never have to communicate directly.
• Supports side-by-side stack trace comparisons to analyze the difference in call stacks for repeated executions of a test or to compare the path of the successful execution with the execution after an exception has been injected.
• Allows you to merge stack traces from separate threads and/or JVMs into a single trace. This is particularly useful in messaging type applications where you want to view the progress of a message as it moves from application to application. Its also very helpful when you are having concurrency issues. If you use web services, this feature allows you to integrate the stack trace from a web service call into the caller and view/compare them as a single trace.
• Finally, JEXIN is open source and free!