Home » Solutions » Virtualization Performance Management

Virtualization Performance Management
for Business Critical Applications

The advent of virtualization and cloud computing have introduced great new opportunities for companies to lower IT infrastructure costs. Services can be launched and stopped as needed based on load demand and quality of service requirements. Physical servers can be virtualized to increase utilization of scare hardware resources.

However, the virtualization of services and infrastructure leads to increased complexity of applications and their environments as well as decreased transparency. This directly results in applications whose performance inside the virtual machine can no longer be managed using traditional tools. The most pressing problems are the

• Lack of accurate response time metrics and SLA measurements on transaction, application and infrastructure level due to time-keeping issues most prevalent in virtualized environments that restrict CPU time to a certain level or run more than a single virtual machine per CPU core (over provisioning)
• Inability to understand if a problem is caused by the application or the configuration of the virtual environment as infrastructure metrics cannot be correlated with accurate response time metrics
• Lack of automated discovery – both of the dynamic infrastructure, and how applications are mapped into the infrastructure – because virtual machines and services are dynamically provisioned within a cluster based on demand
• Inability to continuously record root-cause diagnostics data of application problems 24x7 for every single distinct transaction, whose route and behavior constantly shifts due to dynamic VM provisioning and resource sharing
• Inability to manage the interdependencies between application architecture and production environments, as software architects must now consider the production environment when designing applications, planning how to validate their design decisions well before production rollout

Thus, many business stakeholders and owners of business-critical applications throw up red flags and slow down your virtualization projects for mission-critical applications. What they demand is assurance of application performance before they will consent to “their application” being virtualized.

dynaTrace provides a new virtualization-aware Continuous APM approach across the entire software lifecycle that provides the visibility and transparency needed to assure application performance and scalability in these highly dynamic environments.

Accurate response time and SLA fulfillment measurements

dynaTrace is first to accurately measure application response and CPU time metrics for each individual business transaction down to software component and method level, allowing you to reliably monitor SLA fulfillment of individual services and their responses. dynaTrace achieves this through measuring the real elapsed time using VMWare’s high resolution timer (near native-CPU resolution), as opposed to the rather coarse-grained timers of the guest OS itself that also provides inaccurate timings after virtual machine suspension (time keeping issue).

Accurate performance measurements also allow you to reliably compare application performance between physical and virtualized deployments. This way, you can easily validate that your application’s architecture is ready to be virtualized, and ensure virtualization overhead remains within an acceptable range.

Easily triage between application and virtualization issues

dynaTrace enables you to easily differentiate between issues that root from inside the application itself (e.g. inefficient code), or from the Hypervisor and the configuration of the virtualized environment (e.g., storage bottlenecks resulting in low I/O throughout or CPU bottlenecks resulting in virtual machine suspension). Simply correlate accurate real-world transaction performance metrics with virtualized infrastructure metrics such as Hypervisor suspension times or disk I/O.

Automatically discover virtualized servers and how they map to services and applications

When virtual servers are dynamically provisioned, dynaTrace automatically adapts and manages their performance without any human interaction. The dynaTrace Agents and Collectors deployed with the individual virtual machines automatically record transaction traces and performance monitoring data from the virtualized services, application containers, guest OS and hypervisor. Dashboards that present all of this information based on the needs of the audience (e.g. business, operations, system architects, etc) automatically adapt to services and cluster nodes that have been added to or removed from the virtualized cluster.

This approach requires significantly fewer management and configuration resources as it is automatically deployed with the virtualized OS and their services itself – especially important in on-demand infrastructures such as clouds that continuously adapt to changing load demands with starting and stopping service nodes. To continue requiring laborious manual configuration would lead to unmanageably high operational costs.

Continuously trace every single application transaction 24x7 at code-level

dynaTrace PurePath Technology enables you to continuously trace transactions 24x7 through virtualized distributed service chains down to code-level. As no two transactions necessarily take the same path under the same conditions in such dynamic environments, the connection between symptom and root cause is very difficult, often impossible to determine. That means transaction tracing that only activates on incident after problem occurrence provides little if no value. Aggregated call trees also do not reveal a problem’s root cause as they only detect general execution time problems, but miss outliers, data-driven and architectural issues and only produce a guesstimate of what might have happened across the application.

Manage interdependencies between application architecture and production environments

dynaTrace manages application performance across the lifecycle, enabling you to verify your application’s dynamic runtime behaviour in a virtualized environment early on during development, e.g. with every build during continuous integration and load tests. Additionally, software architects can analyze performance data and service dependencies from production environments down to component and method level, enabling them to take the lessons learned about dynamic production application behaviour back to development to improve their virtualization-aware application architectures.