Instrumentation of Distributed .NET Applications for Performance Analysis under Load

Modern web- & enterprise-applications are usually divided into multiple tiers to improve maintainability. These tiers are commonly distributed over multiple servers to increase performance and availability. However, this so-called n-tier architecture makes finding failures and analyzing performance a challenging problem.

While profilers and debuggers can be useful for these tasks on a 1-tier system, they are mostly useless for distributed applications because of the excessive overhead and the lack of recognition of correlating events on multiple tiers.

The objective of this diploma thesis is the development of a tool that instruments the IL code of a distributed .NET application in such a way that performance and failure information about the application is collected and forwarded to a central server for evaluation while the application is under load. More precisely, this performance and failure information includes:

  • Performance related information: response times, execution times, throughput
  • Method related information: parameters, arguments, return values
  • Communication related information: RPC information

With the collected information it should be possible to track execution paths (the way a request traverses across multiple tiers) and get an overall picture of the application's dynamic behaviour.

The tool has to be integrated in JLoadTrace, a performance analysis tool for distributed applications developed by dynaTrace software GmbH.

The system to be developed will consist basically of these parts:

  • Agent: The agent is running within each separate process of the application under introspection and is responsible for the transmission of the collected information to the central analysis. In addition, it transmits the application's IL code on load-time to the transformer for on-the-fly instrumentation. Furthermore, it is important that the agent's overhead doesn't exceed a limit of 10%.
  • Sensors: Sensors are placed into the observed system by IL code instrumentation. They collect information about performance, methods and communication and transmit it to the agent.
  • Transformer: The transformer receives the IL code of the observed application and instruments it by placing the sensors. These instrumentations are based on a predefined or user-defined rule set. Finally, the modified IL code is sent back to the application and is used instead of the original code.
  • Injection Framework: To get access to the observed system, a framework for the injection of the agent is required. This framework takes care that the agent is injected before the observed application is started and without the need for any source code.

Advisor: Dipl.-Ing. Thomas Kotzmann
Student: Christian Schwarzbauer
Start of project: April 2005