500-420 Questions and Answers

A remote services call and a tier-to-tier request are examples of outbound backend or dependency calls made while processing a Business Transaction.

A remote services call occurs when application code invokes an external HTTP service, web service, messaging destination, or another remote system. AppDynamics detects the associated exit point and reports metrics such as call count, response time, and errors. When the remote destination is not instrumented, it is typically represented as a backend or remote service on the application flow map.

A tier-to-tier request occurs when one monitored application tier calls another instrumented tier. AppDynamics correlates the outbound exit call with the downstream entry point, producing cross-tier transaction visibility and showing how much downstream processing contributes to total response time.

An asynchronous request represents an execution or thread-handoff pattern and does not inherently constitute a backend call; it may execute entirely within the same tier. A browser request is an inbound entry-point request from an end user, not an outbound dependency invocation.

Relevant CAAPA Study Guide topics include Backend Detection, Exit Calls, Remote Services, Cross-Tier Correlation, Tier-to-Tier Calls, Business Transaction Flow Maps, and Asynchronous Transaction Tracking.

An Information Point custom metric can be configured with the roll-up types Average and Sum. The selected roll-up determines how values reported by repeated executions of the monitored class and method are aggregated during each metric reporting interval.

Average calculates the mean of all collected values within the interval. This is appropriate for measurements such as average item-processing time, average order value, or another numeric value where typical behavior is the primary concern.

Sum adds all collected values reported during the interval. It is appropriate for cumulative business or operational measurements, such as the total number of items processed, total transaction value, or total quantity handled by the instrumented method.

Max is not one of the configurable Information Point roll-up choices in this context. Although maximum values can appear in other AppDynamics metric-analysis scenarios, they are not selected as an Information Point custom-metric roll-up type. Count is represented separately through invocation-frequency metrics such as Calls per Minute rather than as the configured roll-up method for the collected numeric value.

Relevant CAAPA Study Guide topics include Information Points, Custom Metrics, Metric Aggregation, Average Roll-Up, Sum Roll-Up, Method Invocation Monitoring, and Calls per Minute.

By default, an active health rule violation displayed on the Health Rules Violations page is updated at 30-minute intervals after the initial violation event is triggered. AppDynamics first evaluates the health-rule condition against the configured critical or warning criteria. When the condition remains true for the configured evaluation and wait period, the Controller opens a health rule violation event.

While that violation remains active, AppDynamics periodically updates its displayed status and associated event information. The default continuation-update interval is 30 minutes. The violation is subsequently closed when the monitored metric no longer satisfies the violation criteria for the required duration.

The wait time after violation determines how long a condition must persist before AppDynamics opens the violation; it does not define the ongoing update frequency. The page is also not limited to updating only when a new violation starts, nor must an existing violation close before updated information can be recorded.

Relevant CAAPA Study Guide topics include Health Rule Evaluation, Warning and Critical Conditions, Wait Time After Violation, Health Rule Violation Events, Violation Lifecycle, and Controller Event Updates.

Information Points in AppDynamics are custom metrics that track specific data within your applications, such as method invocations or the value of method arguments. These metrics can be utilized in various features of AppDynamics, most notably in " Alerting " and " Custom Dashboards. " Alerting allows you to set up notifications based on the thresholds set for Information Points, ensuring that teams are promptly informed about significant changes or anomalies. Custom Dashboards enable the visualization of Information Points metrics alongside other key performance indicators, providing a comprehensive view of application health and performance tailored to specific needs.

The Tiers and Nodes – Health tab provides a consolidated health representation for the selected server or node. It summarizes underlying infrastructure-resource behavior into a single health-oriented value or status, incorporating indicators associated with processor utilization, memory consumption, disk activity, and network I/O. This enables the Performance Analyst to identify an unhealthy or resource-constrained node quickly without first examining each hardware metric independently.

The Hardware tab is used for deeper analysis of the individual resource categories. It presents separate CPU, memory, disk, and network measurements, allowing the analyst to determine which specific resource is responsible after the Health view indicates degradation.

The Application Dashboard focuses on overall application behavior, Business Transactions, tiers, backends, and application flow rather than providing one aggregated server-resource value. The Metric Browser offers detailed time-series access to individual infrastructure metrics, but it requires manual navigation and comparison rather than presenting the consolidated server-health visualization.

Relevant CAAPA Study Guide topics include Tiers and Nodes Dashboard, Node Health, Server Resource Monitoring, Hardware Metrics, CPU and Memory Utilization, Disk and Network I/O, and Infrastructure-to-Application Correlation.

To identify if automatic remediation actions have been taken for a health rule violation in AppDynamics, a Performance Analyst should expand the " Description " field of the health rule violation event. This section will provide details on the actions executed as part of the automatic remediation process. These details help analysts understand the steps taken by the system to mitigate the issue without manual intervention.

HTTP Request and Custom Actions are the two action types designed to integrate AppDynamics policy events with external alerting or event-management platforms.

An HTTP Request action sends an outbound request to a configured third-party endpoint when a policy is triggered. The analyst can specify the URL, HTTP method, authentication, headers, and event payload. This is commonly used with webhook-enabled alerting, incident-management, automation, and collaboration systems.

A Custom Action extends the Controller’s standard action framework through a custom action module. It is appropriate when the external platform requires specialized processing, a proprietary protocol, payload transformation, or integration logic that cannot be handled by a standard HTTP request.

Notifications primarily deliver native email or SMS messages. Diagnostics initiate troubleshooting activities such as diagnostic sessions or thread dumps, while Remediation performs corrective operations. Issue Tracking System Integrations are specifically intended for creating or updating work items in supported issue-management platforms rather than providing a general alerting integration mechanism.

Relevant CAAPA topics include Health Rules, Policies, Policy Actions, HTTP Request Actions, Custom Actions, Webhook Integration, and Third-Party Event Management.

The permission to enable snapshot archiving in AppDynamics typically falls under advanced operational capabilities, such as those categorized under " Agent Advanced Operation. " This permission allows users to archive transaction snapshots for long-term storage and analysis, which is essential for historical performance analysis and auditing purposes.

AppDynamics dashboard metadata is archived in JSON format. JSON preserves the dashboard’s structural and configuration information, including widget definitions, layout, metric references, display settings, data sources, labels, and other properties required to reconstruct the dashboard.

This format is appropriate because dashboard metadata is hierarchical configuration data rather than a flat report. A JSON archive can retain nested relationships among dashboard objects and can be exported, stored in source control, transferred between compatible Controller environments, or used as part of backup and migration procedures.

PDF is intended for rendering a visual report and does not preserve editable dashboard configuration. CSV and XLSX are tabular formats suitable for exporting metric or report data, but they cannot accurately represent the complete object structure and layout of a custom dashboard.

Therefore, when the objective is to archive the dashboard definition itself rather than merely capture its displayed output, JSON is the correct format.

Relevant CAAPA Study Guide topics include Custom Dashboards, Dashboard Import and Export, Metadata Archiving, JSON Configuration, Controller Migration, and Dashboard Backup Procedures.

Controller-level custom dashboards in AppDynamics have the flexibility to provide views that aggregate and compare data from different applications on the same Controller, as well as offer a customized view of applications, servers, and database performance data. This capability enables a holistic view of the IT environment, facilitating cross-application insights and the ability to correlate performance across different layers of the technology stack. Such dashboards are invaluable for understanding overarching trends, pinpointing systemic issues, and driving informed decision-making across multiple applications and infrastructure components.

The Business Transaction Discovery feature in AppDynamics allows users to identify new and potential business transactions directly within the Business Transaction Dashboard. This feature aids in the continuous monitoring and adaptation of the application ' s transaction tracking to changing business needs, ensuring comprehensive visibility. Users can also preview these identified transactions, assessing their relevance and impact on the application ' s performance before deciding to monitor them as official business transactions.

In Cisco AppDynamics, the transaction threshold configurations are typically found under the " Overview " tab. This is where you can view the health rule violations and performance baselines that are associated with transaction snapshots, which can include the configured transaction thresholds. These thresholds set the acceptable performance limits for transactions, and when these limits are exceeded, it may trigger health rule violations that are visible on the Overview tab.

AppDynamics health-rule criteria provide two supported methods for evaluating multiple conditions: All of the following conditions are met and Any of the following conditions are met.

Selecting All applies logical AND behavior. Every configured condition must evaluate as true during the health rule’s evaluation period before AppDynamics generates the warning or critical violation. For the outage scenario, this is the appropriate selection when the alert must occur only when several symptoms—such as elevated response time, increased errors, and high CPU utilization—happen together.

Selecting Any applies logical OR behavior. AppDynamics creates the violation when at least one configured condition becomes true. This is useful when several independent symptoms can indicate the same operational problem.

Although “And” and “Or” describe the underlying logical concepts, they are not the named values presented for multi-condition health-rule evaluation in this context. The interface uses All and Any.

Relevant CAAPA Study Guide topics include Health Rule Conditions, Warning and Critical Criteria, Condition Evaluation Logic, Evaluation Time, Violation Wait Time, and Policy Triggering.

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.

With Business Transaction Lock Down enabled, AppDynamics prevents automatically discovered traffic from registering additional Business Transactions. Newly observed requests that do not match an existing registered transaction are generally aggregated under the tier’s All Other Traffic transaction, protecting the Controller from uncontrolled Business Transaction growth.

To monitor the new web service as an explicitly named, unique Business Transaction, the Performance Analyst should create a Custom Transaction Match Rule. The rule can identify the service by its Web Service Name and Operation Name, providing deterministic matching and naming independently of automatic transaction discovery. Custom rules are the appropriate mechanism for intentionally introducing important transactions while maintaining lockdown governance.

Changing the automatic discovery rule does not overcome the purpose of lockdown because new automatically discovered transactions remain restricted. Live Preview assists with validating detection-rule behavior but is not the persistent configuration that defines the transaction. All Other Traffic provides aggregated visibility into unregistered traffic; it does not replace a precise custom detection rule.

Relevant CAAPA Study Guide topics include Business Transaction Lock Down, Custom Match Rules, Web-Service Entry Points, Transaction Naming, Automatic Discovery, and All Other Traffic.

To plot Host CPU and GC (Garbage Collection) Time Spent in a single view, the " JMX tab under ' Tiers and Nodes ' " and the " Metrics Browser " are the appropriate methods. The JMX tab provides access to Java Management Extensions (JMX) metrics, including those related to GC time. The Metrics Browser allows for the customization and aggregation of various metrics, including Host CPU usage and GC metrics, enabling a combined view of these critical performance indicators.

A Business Transaction must be defined when a discovered entry point initiates one or more asynchronous activities. The Business Transaction establishes the logical monitoring context for the original user request and enables AppDynamics to associate subsequently spawned asynchronous work with that request.

When asynchronous processing occurs, execution may continue on different threads, task executors, queues, or callback mechanisms after the initiating thread has completed or moved on. AppDynamics propagates the Business Transaction correlation context across these asynchronous boundaries so the resulting activity can be represented as part of the same end-to-end transaction. This allows the analyst to evaluate total response time, asynchronous segments, downstream calls, errors, and call-graph execution in the proper transaction context.

A Custom Endpoint is not required merely because asynchronous work is spawned. Asynchronous metrics and endpoint metrics are measurements generated from monitoring; they do not establish the identity or correlation boundary of the request.

Relevant CAAPA Study Guide topics include Business Transaction Discovery, Entry Points, Asynchronous Transaction Tracking, Thread Handoffs, Transaction Correlation, Call Graphs, and End-to-End Transaction Visibility.

In an elastic environment where virtual machines are frequently provisioned and terminated, the Performance Analyst should enable node-name reuse by using -Dappdynamics.agent.reuse.nodeName together with -Dappdynamics.agent.reuse.nodeName.prefix.

The reuse setting allows an Application Agent to register against an available historical node identity rather than continually creating a new node record each time a replacement virtual machine starts. The prefix groups reusable node names for a particular tier, service, or deployment pool, ensuring that agents select node identities from the correct logical set. This prevents excessive node proliferation in the Controller and preserves cleaner historical monitoring for short-lived infrastructure.

A typical configuration enables reuse and supplies a stable prefix, for example:

-Dappdynamics.agent.reuse.nodeName=true

-Dappdynamics.agent.reuse.nodeName.prefix=checkout-node

Proxy properties only control Controller connectivity through an HTTP proxy. Node metadata and a fixed node name do not provide controlled reuse across an automatically scaling pool.

Relevant CAAPA Study Guide topics include Dynamic and Elastic Environments, Node Name Reuse, Application Agent Registration, Tier and Node Configuration, and Controller Node Management.

AppDynamics supports HTTP data collectors and method invocation data collectors for enriching transaction snapshots with contextual diagnostic information.

An HTTP data collector captures selected request details associated with a Business Transaction, including URL or URI information, query or form parameters, HTTP headers, and cookies. These values help analysts distinguish transaction variants, correlate user input with application behavior, and identify request-specific causes of latency or errors. Sensitive values should be filtered or excluded through data-collection configuration.

A method invocation data collector captures information from instrumented application methods. Depending on configuration and agent support, it can collect method arguments, object properties, local or instance data, and return values. This provides code-level context when examining transaction snapshots and call graphs.

URN, URI, and SNMP are not separate AppDynamics transaction data-collector categories in this context. URI-related values are handled under HTTP request data collection, while SNMP belongs to network-management protocols rather than Application Agent transaction diagnostics.

Relevant CAAPA topics include Transaction Data Collectors, HTTP Request Data Collection, Method Invocation Data Collection, Transaction Snapshots, Sensitive Data Filtering, and Business Transaction Diagnostics.

When creating a new database collector in AppDynamics, the essential pieces of information required include the " Database hostname/IP address, " " Database Type, " and " Port number. " These details are crucial for establishing a connection to the database and ensuring accurate monitoring. The hostname/IP address identifies the server where the database is hosted, the Database Type specifies the database management system (e.g., MySQL, Oracle), and the Port number is necessary for network communication with the database server.

The Metric Explorer in AppDynamics allows Performance Analysts to define and visualize Key Performance Indicators (KPIs) from a selection of metrics. By accessing the Transaction Analytics data set, analysts can create custom dashboards that focus on the metrics they ' ve determined to be critical KPIs for their application ' s performance.

An Information Point is created to gather application-specific business and performance metrics from a selected class and method. It enables AppDynamics to monitor code that represents a meaningful business activity even when that method is not a Business Transaction entry point. Typical examples include tracking order value, number of items processed, cache access frequency, payment amounts, or invocations of a critical internal service.

Information Points can report measurements such as calls per minute, average response time, errors per minute, and configured custom numeric values. These metrics can then be displayed in the Metric Browser, compared against baselines, incorporated into dashboards, and evaluated by health rules.

Information Points are not limited to a particular Business Transaction, making option B too restrictive. Collecting fields specifically for Analytics queries is generally handled through transaction analytics and data collectors. Memory-leak troubleshooting instead uses memory diagnostics, object-instance tracking, heap analysis, and leak-detection capabilities.

Relevant CAAPA Study Guide topics include Information Points, Method-Level Monitoring, Business Metrics, Custom Metrics, Metric Roll-Ups, Dynamic Baselines, Health Rules, and Application Instrumentation.

When new business transactions are not appearing on the Business Transaction Dashboard after deploying new code, developers should verify that there are no exclusion rules in place on the tier where the new code was deployed. Additionally, it is crucial to ensure that the Auto Discovery feature for servlets is enabled for Java agents, as this allows AppDynamics to automatically detect and name business transactions based on incoming requests to servlets. Both of these checks are necessary to ensure that new business transactions can be discovered and monitored.

When an application team requests an increase in the Application Business Transaction limit for visibility purposes, it ' s crucial for the Performance Analyst to focus on the transactions that are currently exceeding the limit and understand why. This approach helps in identifying whether the limit is being reached due to genuinely essential transactions or if there are redundant, irrelevant, or improperly defined transactions contributing to the limit breach. By analyzing and rationalizing the transactions, the analyst can ensure that only valuable transactions are monitored, optimizing resource usage and maintaining effective observability without necessarily increasing the limit.

The Live Preview option allows a Performance Analyst to stream entry points detected in the application while a Business Transaction Discovery Session is active. As representative traffic executes, the Application Agent reports candidate entry points in near real time, helping the analyst identify application activity that automatic Business Transaction detection may not already recognize.

This capability is especially useful for proprietary frameworks, background processes, scheduled jobs, and other nonstandard execution paths. The analyst can observe the entry-point activity, determine which class and method represent the start of a meaningful transaction, and then use that information to configure an appropriate Custom Match Rule.

Live Preview does not provide streaming application or agent logs. Searching and browsing classes and methods is a related Discovery Session capability, but it is distinct from the Live Preview function. Likewise, rule validation can be performed after defining detection criteria, but the primary purpose of Live Preview is to expose active entry points as they occur.

Relevant CAAPA Study Guide topics include Business Transaction Discovery Sessions, Live Preview, Entry-Point Detection, Class and Method Browsing, Custom Match Rules, and Nonstandard Framework Instrumentation.

To determine if a given Java class is visible in AppDynamics, the " Preview Business transactions " feature in a Business Transaction Discovery Session can be used. This feature allows users to validate and preview the detection of business transactions, which includes ensuring that specific Java classes and methods are being correctly identified and monitored by AppDynamics.

The Metric Browser provides the authoritative metric hierarchy and can generate the REST URL corresponding to a selected Service Endpoint metric. A Performance Analyst first navigates to a representative Service Endpoint and metric, then copies the generated REST URL. The metric path in that URL can be modified with supported wildcard expressions to return matching metrics for all captured Service Endpoints or services within the application.

This method avoids manually constructing an unfamiliar metric path and ensures that the application identifier, metric hierarchy, time-range parameters, and REST endpoint syntax are correct. Wildcards allow the analyst to query multiple Service Endpoint names, tiers, or metric branches in one request.

Direct access to the Controller’s underlying database is unsupported and bypasses the Controller API model. The Applications browser is useful for interactive analysis but does not itself provide the most direct REST-query construction workflow. “Consumed Endpoints” is not the required location for enumerating all Service Endpoint metrics through the REST interface.

Relevant CAAPA Study Guide topics include Metric Browser, Service Endpoint Metrics, Metric Data REST API, Metric Paths, Wildcard Queries, and REST URL Generation.

When configuring Automatic Cleanup of stale Business Transactions, the " minutes since creation " option is often paired with the " Number of Calls " metric. This setting ensures that business transactions that have not been called within a certain timeframe and have had a negligible number of calls are automatically cleaned up, helping to maintain an organized and relevant set of business transactions in the monitoring system.

AppDynamics supports the creation of custom baselines, allowing a Performance Analyst to define expected metric behavior over a selected historical period and recurring time pattern. Custom baselines are useful when the standard daily, weekly, or trend-based baselines do not accurately represent the application’s operating schedule, seasonal demand, or business cycle.

However, a custom baseline cannot be directly tagged or bound to an individual dashboard widget. Dashboard widgets can visualize metrics and, depending on the widget type, may display standard comparison or baseline-related information, but they do not provide a mechanism for associating a specifically named custom baseline with that widget.

Custom baselines are primarily applied in monitoring and evaluation contexts such as health-rule conditions, where current metric values can be compared against expected behavior using defined baseline criteria and standard deviations. Therefore, the baseline itself can be created and used for performance evaluation, but the analyst’s attempt to attach it directly to a dashboard widget is unsupported.

Relevant CAAPA Study Guide topics include Dynamic Baselines, Custom Baseline Configuration, Health Rule Conditions, Baseline Evaluation, Metric Visualization, and Custom Dashboard Widget Limitations.

Development Level Monitoring is intended for controlled development or diagnostic environments where maximum transaction visibility is more important than minimizing agent overhead. In this mode, the agent captures full call graphs, providing method-level execution detail rather than the reduced or partial call-graph collection associated with normal production monitoring.

The agent also attempts to collect a transaction snapshot for every transaction. “Attempts” is the critical distinction: snapshot creation remains subject to agent safeguards, resource constraints, transaction behavior, and collection limits. Therefore, Development Level Monitoring does not provide an absolute guarantee that every transaction will produce a retained snapshot, making option F incorrect.

Development mode additionally collects more detailed exit-call information for calls to backend systems, improving analysis of downstream databases, services, and other remote dependencies.

The agent does not ignore dev-mode-suspend-cpm. This property is a protective calls-per-minute threshold that can suspend development-mode collection when transaction volume becomes excessive. Relevant CAAPA Study Guide topics include Agent Configuration, Monitoring Levels, Transaction Snapshots, Call Graph Collection, Exit Calls, and Development-Mode Performance Safeguards.

The database host must be reachable from the Database Agent host. The AppDynamics Database Agent normally runs as a standalone process and connects remotely to monitored database instances. Before installation and configuration, the agent host therefore requires network connectivity to each target database over the appropriate database listener port.

This prerequisite includes successful hostname or IP resolution, routing, firewall access, and permission for the agent host to establish a TCP connection to the database service. The Database Agent also requires valid monitoring credentials with the database-specific permissions needed to collect performance statistics, sessions, waits, queries, and other diagnostic data.

Reviewing frequently used primary keys is a database-design activity and is unrelated to agent installation. Adjusting tcp_max_syn_backlog is an operating-system network-tuning task, not a standard Database Agent prerequisite. Dropping system-table keys would be unnecessary and potentially damaging; AppDynamics monitoring does not require destructive changes to database system objects.

Relevant CAAPA Study Guide topics include Database Visibility Architecture, Database Agent Deployment, Network Connectivity Requirements, Database Collector Configuration, Listener Ports, and Monitoring User Permissions.

The Transaction Score view presents the calculated percentage of Business Transaction executions classified by performance category, including normal, slow, very slow, stalled, and error transactions. AppDynamics determines these classifications by comparing each transaction’s response time with the configured slow and very slow thresholds, which may be based on dynamic baselines or static threshold values.

The resulting Transaction Score provides a concise, application-level indication of user-impacting performance. A rising percentage of slow, very slow, or stalled transactions quickly shows that a greater portion of the workload is experiencing degradation, even when overall average response time appears acceptable.

The Slow Responses troubleshooting view is used to investigate individual slow transaction instances and snapshots rather than calculate the overall percentage distribution. The Business Transactions view lists transaction-level metrics and trends but does not provide the same summarized scoring visualization. The Metric Browser displays raw and aggregated metrics but requires manual selection and interpretation.

Relevant CAAPA Study Guide topics include Transaction Score, Business Transaction Performance Classification, Slow and Very Slow Thresholds, Stalled Transactions, Dynamic Baselines, Transaction Snapshots, and Application Health Analysis.