Features

dynaTrace Diagnostics is a comprehensive, extensible application performance management solution offering advanced features in the following areas:

• Diagnostics
• Development and test
• Monitoring
• Technologies
• Deployment

Diagnostics

Records and visually maps, 7x24 in production, the precise runtime execution path – PurePath – of each and every discrete transaction across heterogeneous and distributed application components down to code-level imparting only minimal performance overhead.

The PurePath contain not only pure performance metrics (e.g., response times, CPU usage), but also contextual information (e.g., memory usage, method arguments, exceptions, log events, IO usage, SQL calls, synchronization delays, etc.) in order to enable a precise root-cause analysis.

PurePath Technology thus helps you rapidly find the answers to the questions which are most relevant to resolving performance problems (e.g., performance bottlenecks, functional errors, memory leaks, synchronisation and configuration problems, etc.) under load:

• Which component is causing the problem (WHERE)?
• What is the root-cause of the problem (WHY)?

More information about our unique PurePath Technology ...

Analyze all performance monitoring and diagnosis data (even entire PurePaths) in real-time and instantly diagnose performance problems down to the offending line of code. You also have the option to store Diagnostics Session for offline analysis, so you have complete time flexibility to diagnose and resolve performance problems in the manner that best suits you and your unique workflow.

Capture and export Diagnosis Sessions on demand and route them to the responsible group for detailed offline diagnosis and rapid resolution.

As a developer you can then import and interactively analyze previously recorded Diagnostics Sessions to fully reconstruct application hotspots on your local workstation. This enables rapid root-cause isolation without requiring access to the production system. In fact, the system from which the session recording originates can be halfway around the world – the session package includes everything you need to quickly find and resolve problems on your local machine, regardless of your location.

This intuitive way to route performance problems and to diagnose them offline significantly improves collaboration between Development and QA/Operations, which in turn significantly reduces your mean-time-to-repair.

Analyze problem scenarios efficiently using the following two different diagnosis procedures:

• Outside-In: From the end-user perspective (e.g., poor response time) down to the method-level to analyze the root cause of end-user visible performance issues.
• Inside-Out: From the code perspective (e.g., exception, slow running method) up to reveal the affected business transaction(s) and the root cause of the exception.

Both diagnosis procedures allow you to go back in time and analyze the individual PurePaths that have experienced the problems in order to find out what caused them.

Isolate the component that is causing the performance problem (WHERE) based on response time and CPU usage data.

Determine if thread synchronization and locking issues are causing scalability problems in your applications under high concurrent usage load. E.g., you may find that while CPU utilization is low, I/O traffic is low and the network is unsaturated, certain transactions or components exhibit very slow response times. These symptoms often indicate a potential synchronization issue, which is traditionally very difficult to pinpoint because they depend on dynamic application behaviour under load. Now, simply recreate the synchronization problem offline with dynaTrace Diagnostics and analyze how much time is lost due to synchronization, even differentiated between blocking and waiting time.

Analyze the performance of the remote calls in your application and find out whether network bandwidth, latency issues or simply application components being too "chatty" is causing a bottleneck. E.g., you may discover that your Web service calls simply transfer too many objects over the wire, thus causing a latency issue.

Correlate SQL queries to your application’s back-end database with your end-to-end execution paths to analyze whether the architecture of your application’s data access layer is causing a performance bottleneck. Most often, it is not a single inefficient SQL query that is causing a bottleneck, but rather the total number of SQL queries that are executed by a single transaction initiated by end users or software clients.

Analyze what has caused a single event such as a response time violation (e.g., SLA breach), an application exception or a log entry, and reveal the affected transaction(s).

Analyze and tune the overall memory consumption of your application across entire virtual machines or even alongside a specific PurePath. Uncover any memory leaks that may cause stability problems using Selective Memory Dumps that diagnose only those memory allocations that are of interest or concern. E.g., you may determine that a specific “Purchase” transaction has allocated 50,000 "Product" objects and thus is causing a memory bottleneck, or that another specific transaction is not freeing up its allocated objects and is thus causing a memory leak that results in a long-term, cumulative stability issue.

Analyze the impact of configuration changes or application updates to the in-depth performance of your application components down to method-level. Simply select the Diagnostics Sessions you want to compare and analyze the performance delta between them (multi-session diffing) to see if performance has improved or has declined.

Capture, store and analyze basic virtual machine (Java VM, .NET CLR) system metrics such as memory pools, garbage collection events, etc. to determine overall system health and its impact on the target application.

Analyze extended application server resource metrics such as connection pools, thread pools, active sessions, queue length, etc. provided through standard application server monitoring interfaces such as IBM PMI, JMX, and Windows PerfMon/WMI to determine whether a performance issues is caused by the application server itself or its configuration (as opposed to the application the application server is hosting).

Precisely track down the root cause of performance and stability issues deep within the application source code at runtime – even under a high concurrent user load, such as that usually present in load testing and production environments.

Map individual call traces (PurePaths including all their rich context information such as HTTP attributes, method level arguments, etc.) to dedicated Business Transactions to enable rapid detection of business-level impact. E.g., you may want to find out who is affected by a particular problem, or trace and diagnose all transactions of a certain user, or track so called "conversations" or "composite transactions" spanning several screens or web pages (for example, from "start purchase" to "select product" to "go to cart" to "credit card authorization" and finally "submit order"). Additionally, you may want to diagnose the behaviour of "generic" components (such as from dispatcher servlet called) for a specific use case while disregarding all other, nor-relevant uses cases (or transactions).

Export data from any diagnosis view into to easily portable formats such as PDF, HTML or Excel (CSV).

<< Back to Feature Comparison Chart

Development and Testing

Decompile the byte-code of the target application to easily view and analyze the implementation of certain application methods. This way, you can even directly analyze 3rd party software components for which direct access to source-code is not available.

Accelerate problem resolution through directly accessing the source-code of classes and methods you have identified as being a bottleneck in your favourite IDE (e.g., Eclipse) without hassle. Simply select the code to be reworked in dynaTrace Diagnostics and bring it up in your IDE for advanced editing just with a simple mouse click.

Integrate dynaTrace Diagnostics with your test automation tools through its open command line and JMX APIs. Automatically create Diagnosis Sessions of your target application during an automated test run. Easily analyze the performance delta between various test runs (multi-session diffing) to understand if performance has been improved or has been declined.

Rapidly diagnose and resolve performance issues that you have identified in your load test and production environments through dynaTrace Diagnostics’ HTTP-tag integration with your load testing and synthetic monitoring tools.

dynaTrace Diagnostics can integrate with virtually all commercial and open source load testing and synthetic monitor tools. Borland Software, for example, is shipping its SilkPerformer load testing product with an out-of-the-box integration with dynaTrace Diagnostics.

<< Back to Feature Comparison Chart

Monitoring

Get more out of your monitoring and diagnosis data through forward- and backward-looking long range analysis, which is based on historical performance data stored in the Diagnostics Repository. For every system/application you monitor you can perform the following types of analyses:

• High-level performance analysis
  Determine the performance of your applications from a bird’s eye view. Heat field will also indicate if individual problems have occurred, while the average performance is still OK.
• Availability analysis
  Determine your application’s uptime
• Service-level fulfillment analysis
  Determine your application’s service-level fulfillment
• Trend analysis
  Recognize performance trends before end-users start to experience problems (e.g., for capacity planning, avoiding application downtime, etc.)
• Historical incident analysis
  Review all incidents that have occurred within your system/application and review linked PurePaths that have been stored for the incident (also see Alerting)

A system is comprised of one or more VMs (e.g., Servlet/Swing + EJBs + JDBC) that can be covered by a single PurePath. A system is usually equal to a target application, but may also include more than one target applications if they are hosted all on the same application server (VMs). You can store and manage multiple configurations per system.

Subscribe any deep-diagnostics data your KnowledgeSensors™ are capturing as a 7x24 monitor and chart them long term over time in your performance charts.

Use a single Diagnostics Client to connect to multiple Diagnostics Servers to easily monitor and diagnose more applications than those supported by just a single Diagnostics Server.

Monitor and diagnose the performance of each and every individual transaction 7x24. Continuous measurement and diagnosis is guaranteed through

• dynaTrace Diagnostics' lightweight agent technology at negligible CPU overheads and flat memory usage of only a few megabytes
• Graceful recovery of the dynaTrace Diagnostics Agent to Diagnostics Server connection in the event of unplanned downtime or system failure (e.g. power outages) as soon as the Diagnostics Server comes back online

Alert on incidents (e.g., SLA/threshold violation, exception) using customizable notifications/actions while efficiently avoiding false alarms by ignoring outliers. dynaTrace Diagnostics can simply log notifications and display them on the screen, send notifications via e-mails to selected user groups or to external systems through JMX and custom adapters. Additionally, you can automatically store just those PurePaths that triggered the incident or the entire Diagnostics Sessions including all PurePaths that have been recorded around the time the incident occurred, allowing you to not only diagnose the incident’s root cause in a single transaction, but also consider potential interference between several transactions. Moreover, you can also execute plug-able actions on incident triggers such as calling a Web service or a command line tool (e.g., to automatically enter a trouble ticket into an issue tracking system).

Integrate dynaTrace Diagnostics seamlessly into your Enterprise Management System either via JMX or through pluggable custom adapters. This way you can notify your EMS system when dynaTrace Diagnostics raises an alert or even read dynaTrace Diagnostics results data through a data polling mechanism. To seamlessly integrate dynaTrace Diagnostics into your automated build-and-test systems you can also automate the capturing of monitoring and diagnostics data through a built-in JMX automation API.

<< Back to Feature Comparison Chart

Technologies

Pre-build KnowledgeSensorsPacks^TM for Java technologies that capture all relevant performance and contextual information deep within source code of the target application at runtime.
More informationen about systems that are supported out-of-the-box ... .

Additionally, you can easily create new custom KnowledgeSensorPacks™ in order to more precisely diagnose problems in software components that do not implement any standard interfaces.

Pre-build KnowledgeSensorsPacks for .NET technologies that capture all relevant performance and contextual information deep within source code of the target application at runtime.
More informationen about systems that are supported out-of-the-box ... .

Additionally, you can easily create new custom KnowledgeSensorPacks™ in order to more precisely diagnose problems in software components that do not implement any standard interfaces.

Monitor and diagnose single transactions across multiple logical and physical servers, even those which reside on different platforms such as Java and .NET. To diagnose performance issues in such heterogeneous transactions you need only analyze a single coherent PurePath.

Support for monitoring and diagnosing applications that display and process data encoded in Unicode

Support for monitoring and diagnosing Java and .NET applications running on the following distributed computing environments:

• Microsoft Windows
• Linux
• Sun Solaris
• IBM AIX

Support for monitoring and diagnosing Java applications running on the following mainframe system:

• IBM z/OS
• IBM z/Linux

<< Back to Feature Comparison Chart

Deployment

dynaTrace Diagnostics is made to be used across the software application lifecycle, which significantly improves collaboration and closes the knowledge gap between development, QA and Operations. Simply exchange KnowledgeSensorPacks - including their configuration - to quickly instruct QA or Operations which application components should be monitored (granularity). Plus, QA and Operations can simply export Diagnostics Sessions on demand to route them to the responsible development group for detailed offline diagnosis and rapid resolution.

dynaTrace Diagnostics gathers PurePath information for all transactions during 7x24 operations through KnowledgeSensors, which are deployed into the target application through Diagnostics Agents that run locally on the system under diagnosis (SUD). All calculations are done on the Diagnostics Server, which enables overhead to be sustained at a very low level of only 3-5%. This makes dynaTrace Diagnostics ideally suited for usage in load test and production environments.

Monitor and diagnose your Java and .NET applications using lightweight byte-code instrumentation without changing the source code of your target application. This also allows you to monitor and diagnose 3rd party software components for which access to source code is not available.

Automatically discover the software components and APIs used by the target application to quickly present out-of-the-box diagnosis results and to enable intuitive customization of the monitoring depth trough the dynaTrace Diagnostics Visual Class Browser.

Simply browse your application’s package structure using the point-and-click Visual Class Browser and select those packages, classes and methods you wish to monitor and diagnose using custom KnowledgeSensors. This way you can easily and precisely diagnose problems in software components that do not implement any standard interfaces such as Servlet, EJB, JDBC, ASP.NET, ADO.NET, etc.
Moreover, simply refine and deepen the instrumentation of your system under diagnosis (SUD) just as needed through the built-in Sensor Placement Wizard.

Adapt the granularity of your code-level monitoring to ever-changing diagnostic requirements on-the-fly without restarting the target application - activate or deactivate sensors through Hot Sensor Configuration. Using Hot Sensor Placement simply upload completely new KnowledgeSensors via the Diagnostics Agents to your target application in order to monitor on a more granular level.
(Note: Hot Sensor Placement is available for Java 1.5 and above.)

Additionally, distribute and manage all your Diagnostics Agents from a central location. Configuration changes are automatically propagated to the remote Diagnostics Agents in real-time to quickly and easily adapt the depth and granularity of captured diagnostics data on the fly.

Run your Diagnostics Client, Diagnostics Agents and Diagnostics Server from different machines to minimize overhead on your target application and to ensure maximum scalability such as needed in load test and production environments. Additionally, you can use a single Diagnostics Client to connect to various different Diagnostics Server installations, which simplifies deployment of dynaTrace Diagnostics in particular for large installations significantly.

Control how your employees may use dynaTrace Diagnostics using its built-in role and permission systems. Standard roles include Guest, User, Power User and Administrator privileges, with each role having different pre-defined access permissions to the functionality of dynaTrace Diagnostics. Additionally, you may define your own custom roles system on a very fine granular level.

Authenticate user access either against a built-in user management database or against your enterprise-wide LDAP directory store such as Microsoft Active Directory.

A Diagnostic Agent is attached to a specific virtual machine (JVM or .NET CLR) that runs (a component of) your target application. The Diagnostics Agent then deploys the KnowledgeSensors that collects the in-depth performance information from your target application.
Thus, you need to deploy a Diagnostics Agent for every virtual machine that is running an application component you want to diagnose.

In case a 3^rd party (e.g., an outsourcer or a consulting client) is responsible for resolving a performance problem simply forward them the Diagnostics Sessions of the performance problem you have recorded during testing or in production. This will allow them to recreate the performance problems using the free dynaTrace Diagnostics Explorer on their local workstation, thus enabling them to rapidly resolve the issue.

<< Back to Feature Comparison Chart