Trace Distributed Applications from Client to Backend

Distributed Tracing - Client to Backend

While profilers and monitoring tools are limited to a probability tree of a single JVM/CLR/JS code, dynaTrace follows each request throughout the entire distributed application using PurePath tracing to provide true, 100% accurate, context between tiers.

For the first time, you can easily capture the dynamic behavior of your application, eliminating guesswork. PurePath follows user clicks, server requests, and batch-job start points across all tiers - including Web browsers, rich clients, servers, clusters, service and message buses - to database and backends. PurePath automatically follows transactions across remoting technologies including Web services, HTTP, RMI, T3, EJB, WCF, XHR, and across messaging technologies including JMS, MQ, MSMQ, HTTP/XML (see Supported systems). And for proprietary remoting technologies, including plain TCP/IP, dynaTrace provides an agent development kit (ADK) for full extensibility.

In addition, PurePath even traces through heterogeneous environments, including Java, .NET, C/C++, and others. And 3rd party libraries, including closed and open source frameworks, are traced without the need to touch any Java or .NET source-code.

Along these distributed PurePaths, dynaTrace automatically collects relevant code level root-cause information for:

Performance analysis: performance metrics like response time, CPU, synchronization, stall times, method invocations, remote calls, database calls, backend calls, API calls, memory allocations.
Data driven behavior analysis: information like method arguments, user input metrics, message content, SQL statements and bind values, HTTP requests and headers, URLs, Web service endpoints.
Error analysis: log messages with severity, exceptions, failed database statements, HTTP error response codes.

Transaction Pure Drill Down

Why is a pure transactional approach required? Imagine an averaged call tree such as that provided by a Profiler or other diagnostics tool. You have transaction types A and B concurrently traversing the application in a test environment, and now you need to understand what the hotspot is for transaction type A? There’s no chance with a pre-calculated probability tree approach that cannot change dimensions. To solve this problem, and many others, dynaTrace invented the PurePath.

PurePath uniquely enables multi-dimensional slice and dice, drill-downs and drill-ups across a number of transactional dimensions. For analyzing any selected transaction type, such as a particular Web request, user click, Web service call, message arrival or transaction that raised an alert, you can drill down to the root-cause as low as the code-level via an easy to use context menu. This drill-down enables you to analyze, for the first time, everything in the context of a transaction type or even in context of a single transaction execution.

The same drill-down analysis is true for Web service, remoting calls, messaging, method invocations, exceptions, log information, memory allocations, application dependencies, API breakdown, components, GUI invocations and directory lookups. And down at the method and code level, you can perform further drill-downs with the integrated decompiler or IDE integration (Eclipse & Visual Studio).

dynaTrace also automatically detects functional errors based on log messages, exceptions or HTTP response codes. To assess a functional error, both a root-cause and impact analysis are needed. This is where not only the drill-down to the individual affected transaction (PurePath) is helpful, but also the drill-up to understand which transaction type identified by URL, service name or component name is related to this technical problem.

Watch a video: Transactions In Action

Services Interaction and Hot-Spots

Service and Message based architectures, including dedicated Service and Message Bus products, help to decouple services from each other. At the same time, the use of indirections such as facades hide dependencies and turns diagnostics into an even bigger challenge. How many calls and from whom interact with this service? Are these 20 calls all part of one transaction or are they single calls from 20 different transactions? Which service and tier shows the hotspot? What if I move a service to a different container or machine, what’s the impact? These are just a few examples of the myriad of questions that come up in such distributed environments.

To keep you in control of your increasingly complicated architectural environment dynaTrace follows synchronous as well as asynchronous transactions through distributed applications. PurePath Technology traces:

Service based architectures built on remoting, messaging and Web service stacks.
Service and message bus systems such as Oracle ESB, Tibco, WebSphere MQ, and ActiveVOS.
Worker-thread and worker-process pools, and custom request and message routers.

Visualizations and ADM

The dynaTrace transaction flow analyzer visualizes the actual interactions and dependencies between your services and creates a Transaction Flow Map. The dependency model builds up automatically based on the actual executed transactions, and is therefore more accurate than network oriented solutions that have to guess which input belongs to which output of a service. Dependencies are important for impact analysis as well as root-cause analysis. And in virtualized and cloud environments, due to their frequent changes, an accurate real-time dependency view is needed more than ever.

For the first time, you can get a virtual slice of your distributed application fully analyzed and visualized, no matter what executes in parallel, because analysis is performed on each request individually. The visualization lets you identify hot-spots immediately, and via a drill-down to an even more detailed cross-tier performance breakdown (aka Agent breakdown), you can analyze how distributed multi-tier transactions spend resources in each tier. This allows you to spot not only high response times, but also tiers that have high CPU utilization or perform excessive database operations. In addition the Transaction Flow Map provides hop count and latency timing between tiers, as well as pinpoints problems coming from outbound as well as inbound calls to and from external systems. Because it's fully interactive, continue from the Transaction Flow Map visualization with any further drill-down to code level and problem resolution.

To analyze the dynamic behavior of individual transactions, dynaTrace automatically provides a UML Sequence Diagram, where you get the visual representation of the entire execution flow at the granularity of tiers and components down to methods. Not only is this diagram invaluable in understanding transaction flow and dependencies, but its fully interactive and 100% accurate. The more complex your application, the more invaluable this view.

Related: Supported systems

Backend & External Services

When integrating applications, services and backend systems it is hard to predict proper access patterns. Therefore capacity planning as well as root-cause analysis is challenging. For example, a customer application may use your Web services inappropriately, not only causing high chattiness, but with a ripple affect across multiple tiers including impact to your backend databases. Database utilization may climb, CPU utilization may spike, or CICS/IMS transactions may slow.

Using the Transaction Flow Analyzer and its drill-down capability to understand dependencies, understand the chattiness of certain calls coming from internal or external systems. Understand calls to messaging, transaction gateways, 3rd party apps and application integration servers. Also follow hot-spots upstream to understand the source of problems - up to the entry point, call type, 3rd party application and/or business transaction. Transaction pure visualization, contextual correlation, and drill-down/drill-up interactivity provide a powerful system for backend and external service diagnostics.

Cloud and Virtualization

Is it the virtualization or the application? This is a common question when diagnosing problems in virtualized environments where applications and services share hardware resources. And with the even higher automation level for clouds, whether public, private or both, their increasingly dynamic nature makes it that much harder to get to the answer. Dynamic instances are created and shutdown on the fly by applications or other management solutions. There are no dedicated host names, and tracking dependencies becomes even harder as virtual machines get moved around automatically by the virtualization infrastructure.

dynaTrace transaction tracing brings unparalleled visibility into virtualized and cloud environments, such as VMware, Amazon EC2, Microsoft Azure, IBM LPAR, Xen and others. With dynaTrace, you diagnose easily in environments that keep changing both in terms of capacity and topology. PurePath adapts automatically to these configuration changes allowing you to stay on top of dependencies with real-time transaction flow analysis, even when instances come and go in a virtual or cloud environment. CPU utilization alone is not a measure for performance. Isolating response time problems requires knowledge of the response times of every tier, component and service involved in your transaction. dynaTrace, with its PurePath technology, does just that - it traces every single transaction across your virtualized application landscape helping to zero in on real problems fast. No more guesswork – with dynaTrace, you can quickly determine whether your application consumes too much CPU, waits on the network or simply executes too many database statements.

As resources are shared between multiple VMs, an allocation that can even change at runtime, monitoring can no longer rely on the application and guests view alone to diagnose performance problems. dynaTrace monitors the whole stack starting at the application right down to your virtualization infrastructure. By correlating transaction performance with virtualization metrics for you, you can answer the question whether your network latency is due to virtualization or not.

Unlike the built in “high resolution timers” found in JVMs or CLRs, dynaTrace virtualization agent technology ensures performance measurements are accurate and not skewed so that you accurately know where your distributed transactions spend their time.

Business Transaction Diagnostics

dynaTrace's transactional diagnostics power increases when coupled with Business Transaction Management (BTM). Drill-downs are then directly possible from transactions that have been classified by business criterion such as tenant identifier, service level violation, transaction identifier, or payload based information. This enables you to go directly from “complaint received” to root-cause analyzed and resolved. Without this, one would be lost in the dark of averages and probability trees.

Furthermore BTM capabilities enable a new way of diagnosis by filtering transactions based on information that has been captured at any tier of a multi-tier transaction trace. For example, it allows capturing only those multi-tier transaction traces that contain a certain exception at the backend payment service. dynaTrace transaction-pure BTM allows for finer-grained SLAs, more insightful monitoring, and the fastest path to problem resolution of any performance management system on the market.