The Call Graph and Slow Calls & Errors > Hot Spots views provide the code-level detail needed to direct developers to the relevant class, method, and source-code line.

The Call Graph presents the instrumented execution sequence for a transaction snapshot. It shows invoked classes and methods, execution timing, parent-child relationships, and—where available from the runtime and debugging metadata—the associated source line number. This enables a developer to trace the request path and identify precisely where application time was consumed.

The Hot Spots view summarizes the methods that contributed most significantly to transaction latency or errors. Rather than requiring the analyst to inspect every branch of the call graph, it highlights expensive methods and provides class, method, timing, and source-location context for rapid code remediation.

Data Collectors display captured arguments, return values, headers, or other contextual data. DB and Remote Services Calls focuses on exit calls and downstream dependencies. Servers presents infrastructure context, while More contains supplementary snapshot information.

Relevant CAAPA Study Guide topics include Transaction Snapshots, Call Graph Analysis, Slow Calls and Errors, Hot Spots, Method Execution Time, and Code-Level Diagnostics.

The Performance Analyst should open the Business Transactions view and enable Show Trends. This presents historical behavior for individual Business Transactions, making it possible to identify which transactions experienced a decline in calls per minute and when the change began. The analyst can compare workload patterns across transactions and correlate the decrease with changes in response time, errors, transaction activity, or application usage.

The Top Business Transactions by Load widget emphasizes the highest-volume transactions for the selected period, but it may not clearly expose transactions whose volume has sharply declined. Plotting application-level Calls/min in the Metric Browser confirms that total workload decreased but does not immediately identify the affected Business Transactions. The Application Flow Map focuses on tier and dependency relationships, while Transaction Score summarizes transaction performance classifications rather than workload trends.

The Show Trends capability is therefore the most direct method for examining historical transaction behavior and isolating the Business Transactions responsible for the workload change.

Relevant CAAPA Study Guide topics include Business Transaction Monitoring, Show Trends, Calls per Minute, Workload Analysis, Historical Comparison, and Application Performance Troubleshooting.

The Performance Analyst should enable Split Transaction using request data. This capability allows a single Custom Match rule to dynamically divide one base transaction into multiple business transactions according to values contained in the incoming HTTP request. For example, the rule can identify the base transaction as menu and append a request-derived value such as salads or entree, producing distinct transactions named menu.salads and menu.entree.

This approach avoids maintaining separate match rules for every menu category and scales automatically as additional request values are introduced.

An HTTP Request Data Collector captures request attributes for visibility within transaction snapshots but does not itself split or rename business transactions. A Method Invocation Data Collector captures method parameters, return values, or invoked-object data and is also unrelated to transaction splitting. Split Transaction using JSON is appropriate only when the required discriminator must specifically be extracted from a JSON payload.

Relevant CAAPA topics include Business Transaction Detection, Custom Match Rules, Transaction Naming, Request-Based Splitting, and Data Collectors.

The Live Preview option in a Business Transaction Discovery Session in AppDynamics allows a user to verify the effectiveness of newly configured Transaction Discovery Rules. This feature provides real-time feedback on how these rules identify and categorize business transactions, enabling users to adjust and fine-tune the rules to ensure accurate and meaningful transaction monitoring.

A relative metric path with a wildcard is used when a metric condition must be evaluated across multiple comparable entities, such as hardware resources, JVM memory pools, nodes, or other dynamically named metric branches.

A relative path is resolved in the context of each entity selected by the health rule or metric evaluation scope. Adding a wildcard allows AppDynamics to match multiple child metric paths rather than requiring one fixed, fully qualified metric location. This is particularly useful when memory-pool names, hardware instances, or resource identifiers differ between nodes or runtime environments.

An absolute metric path points to one exact location in the metric hierarchy and is therefore better suited to a single, explicitly identified metric. Although wildcard matching can be supported in metric configurations, the correct approach for evaluating equivalent metrics across multiple scoped entities is the relative-path model.

The Metric Browser supports hierarchical metric navigation, and wildcard-capable paths are used where dynamic or repeated entity structures must be addressed. Relevant CAAPA Study Guide topics include Metric Browser, Relative and Absolute Metric Paths, Wildcard Metric Selection, Health Rule Conditions, Hardware Resource Metrics, and JVM Memory Pool Monitoring.

The Performance Analyst should use Compare Against Baseline. This flow-map function provides an immediate comparison between current application behavior and the established historical baseline for the selected time range. It helps identify whether response time, load, call volume, or dependency behavior has deviated from what AppDynamics considers normal.

In the exhibit, the yellow downstream applications indicate a warning state, even though the blue flow lines suggest that the current calls themselves are not showing an obvious critical condition. Comparing the current flow map against baseline allows the analyst to determine whether those downstream dependencies are performing worse than their customary levels and whether the tier’s dependency pattern has changed.

Correlation Analysis is intended to identify statistical relationships among metrics rather than provide a direct historical flow-map comparison. Health Rule Violations show triggered conditions but do not provide the fastest visual comparison with prior performance. Metric Browser Baselines can expose baseline values for individual metrics, but require more manual investigation.

Relevant CAAPA topics include Application Flow Maps, Dynamic Baselines, Compare Against Baseline, Dependency Analysis, and Health-State Interpretation.

If the Average Response Time is increasing after the release of a new marketing offer, seeing an increase in Calls per Minute could quickly help the Performance Analyst determine that users may not be critically impacted. This increase may indicate that despite the higher average response time, more users are engaging with the application, possibly due to interest generated by the marketing offer. It suggests that the system is handling more load, which could be a factor in the increased response time.

The Tiers and Nodes > Memory tab provides the appropriate JVM-level view for confirming suspected heap growth over a selected timeframe. The analyst should compare Heap Utilization (%) with Heap Current Usage (MB) versus Max (MB) and observe the effect of major garbage-collection events.

A potential memory leak is indicated when heap usage rises progressively and fails to return to a stable lower level after garbage collection. The important pattern is not simply high memory utilization, but an increasing post-garbage-collection baseline over time. The exhibit shows current heap usage gradually increasing relative to the maximum heap allocation, which warrants further memory diagnostics.

Hardware-resource memory metrics represent operating-system memory and do not isolate JVM heap behavior. Swap usage can indicate host memory pressure but cannot confirm an application heap leak. JMX metrics may expose heap values, but the dedicated Memory tab provides the quickest correlated visualization for heap utilization, maximum heap, current usage, and garbage collection.

Relevant CAAPA topics include JVM Memory Monitoring, Heap Utilization, Garbage Collection, Tiers and Nodes Memory View, Memory Leak Detection, and Object Instance Tracking.

AppDynamics initiates transaction snapshot collection when a Business Transaction is classified as slow, very slow, stalled, or erroneous, subject to the configured snapshot thresholds and agent collection limits. These snapshots preserve detailed diagnostic context, including call graphs, exit calls, errors, and participating tiers, allowing analysts to isolate the code path or downstream dependency responsible for degraded user experience.

AppDynamics also captures snapshots through periodic snapshot collection. Periodic collection samples transactions at configured intervals even when their performance is normal. This provides representative diagnostic evidence and enables comparison between healthy and problematic executions without requiring every transaction to violate a performance threshold.

A sudden increase in Calls per Minute does not, by itself, constitute a standard snapshot trigger. Workload surges may influence application performance, but snapshots begin only when an applicable collection mechanism or diagnostic condition is satisfied. An “asynchronous session” is also not a standard snapshot-start condition; asynchronous processing can be included within a correlated snapshot after collection has already been initiated.

Relevant CAAPA Study Guide topics include Transaction Snapshots, User Experience Classification, Slow and Error Transactions, Periodic Snapshot Collection, Call Graphs, and Snapshot Collection Thresholds.

In AppDynamics, you can create health rules to monitor various metrics and set up actions based on the thresholds defined for these metrics. For monitoring Java container thread counts, you can set a health rule based on Node Health - specifically on thread pools - to trigger when the thread count exceeds a specific value. The Notification Action can then be configured to send an email to the development team whenever this threshold is breached.