500-420 Sample Questions Answers

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.

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.

A snapshot flow map presents execution-specific timing information that helps explain why AppDynamics captured that particular transaction instance. The relevant metrics are Thread Blocking Time, Execution Time, and Asynchronous Activity Processing Time.

Execution Time shows the elapsed processing time for the transaction segment and helps determine whether the request exceeded slow or very slow transaction thresholds. Thread Blocking Time identifies time during which the executing thread was blocked or waiting, potentially because of lock contention, synchronization, resource availability, or another thread-related delay. A substantial blocking value can explain why an otherwise ordinary code path produced a slow snapshot.

Asynchronous Activity Processing Time represents time consumed by asynchronous work associated with the transaction, such as executor tasks, callbacks, or background processing correlated with the originating request. Excessive asynchronous processing can materially increase end-to-end completion time and trigger snapshot collection.

Tier Response Time and Node Response Time are aggregated performance metrics across multiple transactions. They provide useful operational context but do not directly describe the timing characteristics of one captured transaction execution.

Relevant CAAPA Study Guide topics include Transaction Snapshots, Snapshot Flow Maps, Execution Time, Thread Blocking, Asynchronous Transaction Tracking, and Slow Transaction Diagnostics.

A method invocation data collector is used because the required business value exists inside the Java application’s Checkout class rather than in the HTTP request.

The Performance Analyst configures the collector against the appropriate class and method, then identifies the value through a method argument, return value, object field, or getter chain. AppDynamics captures that checkout value when the configured method executes and associates it with the corresponding Business Transaction data. The collected value can subsequently be used for business analysis and aggregation, allowing stakeholders to report total or running checkout value over a selected time period.

A dashboard widget can visualize or aggregate data that AppDynamics already collects, but it cannot independently extract a value from Java code. An HTTP data collector is appropriate only when the required value is contained in request parameters, headers, cookies, session attributes, or other HTTP data. A REST export retrieves existing Controller data and therefore does not solve the initial instrumentation requirement.

Relevant CAAPA Study Guide topics include Method Invocation Data Collectors, Java Class and Method Instrumentation, Getter Chains, Business Data Collection, Transaction Analytics, and Custom Dashboard Visualization.

Business Transaction Discovery Sessions are supported for Java and .NET applications. These sessions help a Performance Analyst identify candidate transaction entry points when automatic discovery does not detect a proprietary framework, background process, scheduled task, or other nonstandard execution path.

During a discovery session, the Application Agent observes executed application code and allows the analyst to browse relevant classes and methods. The selected method can then be used to create or refine a Custom Match Rule, establishing a new Business Transaction entry point with appropriate naming and scope.

Java and .NET agents provide the runtime instrumentation and class-method visibility required for this workflow. C++, PHP, and Node.js applications have their own supported monitoring and transaction-detection capabilities, but they do not use the Business Transaction Discovery Session feature referenced in this question.

Discovery sessions should be run for a controlled period while representative application traffic exercises the target code path. The resulting class and method information can then be reviewed before creating a permanent transaction detection rule.

Relevant CAAPA Study Guide topics include Business Transaction Discovery Sessions, Java Agent, .NET Agent, Class and Method Browsing, Custom Match Rules, Entry-Point Detection, and Transaction Naming.

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.

The " Method Invocation Data Collector " is specifically designed to capture code-level data such as method arguments, variables, and return values. This type of data collector enables deep visibility into the execution of methods within transactions, providing valuable insights into the application ' s behavior and performance. This detailed level of monitoring is essential for diagnosing complex issues and understanding the inner workings of business transactions.

The Application Flow – Grid View and Application Flow Map provide the fastest dashboard-level methods for demonstrating that a backend dependency is contributing to degraded application performance.

In Grid View, the analyst can locate the backend and review dependency-specific indicators such as average response time, calls per minute, errors, and calls made by upstream tiers. Comparing these values across relevant time ranges makes it straightforward to show that backend latency rose at the same time as application response time.

The Application Flow Map provides the same dependency context visually. Selecting the backend exposes its performance metrics and relationship to the calling tier, allowing the analyst to compare current behavior with an earlier timeframe or baseline and demonstrate the backend’s contribution to end-to-end latency.

Top Business Transactions focuses primarily on transaction-level performance rather than direct backend comparison. Transaction Snapshots provide detailed evidence for individual executions, but they are less suitable for a rapid dashboard-level comparison across timeframes.

Relevant CAAPA topics include Application Dashboard, Flow Map Analysis, Grid View, Backend Performance, Dependency Response Time, and Time-Range Comparison.

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.

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 " Application Health Report " is a built-in scheduled report in AppDynamics that includes vital metrics such as load, response time, and error graphs. This report provides a comprehensive overview of the application ' s health and performance, making it an essential tool for Performance Analysts to regularly review and share with stakeholders to ensure the application meets performance standards and user expectations.

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 Transaction Score tab within the Application Dashboard is designed to display performance trends across various metrics including Snapshots, Average Response Time, and Events. It gives a comprehensive view of the transaction performance, providing a score that reflects the health and reliability of transactions over time.

To share snapshot details from the snapshot window in AppDynamics, the options to " Download PDF " and " Export " are typically used. " Download PDF " allows users to generate a PDF report of the snapshot details, providing a convenient and portable format for sharing and review. The " Export " option enables the extraction of snapshot data in various formats (e.g., CSV, XML), facilitating further analysis or sharing with other tools and stakeholders.

In environments where virtual machines are frequently created and destroyed, using the agent configuration properties -Dappdynamics.agent.reuse.nodeName and -Dappdynamics.agent.reuse.nodeName.prefix can be beneficial. These settings allow AppDynamics agents to reuse node names for newly created instances, facilitating consistent monitoring and tracking across dynamic environments. This approach helps maintain clarity in application topology and ensures that performance data remains coherent even as the underlying infrastructure changes.

When a Performance Analyst drills into a call graph, AppDynamics exposes method-level execution details that identify where transaction processing time was consumed. The method name identifies the specific application method invoked within the transaction execution path. Method time in milliseconds shows how much time was attributed to that method, enabling the analyst to isolate expensive code paths, compare parent and child execution time, and determine whether latency originates in application code or a downstream dependency.

The call graph can also display Service Endpoints encountered during transaction processing. Service Endpoints represent independently monitored application services or methods and help the analyst understand how internal service execution contributes to the overall Business Transaction response time.

The Business Transaction name and user-experience classification—such as normal, slow, very slow, stalled, or error—are transaction-snapshot context rather than method-level call-graph drill-down data. They describe the transaction as a whole, while the call graph focuses on the execution sequence and timing of instrumented methods and service interactions.

Relevant CAAPA Study Guide topics include Transaction Snapshots, Call Graph Analysis, Method Execution Time, Service Endpoints, Code-Level Diagnostics, and Business Transaction Troubleshooting.

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.

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.

A Scope is used to apply Transaction Detection Rules selectively to one or more tiers that perform the same or a related application function. Scoping allows a Performance Analyst to avoid applying a custom match rule or exclude rule across the entire application when the relevant entry point, framework, class, method, or request pattern exists only within particular tiers.

For example, several web-service tiers may use the same transaction naming convention or custom entry-point logic. The analyst can group those tiers within a scope and associate the transaction detection rule with that scope. This provides consistent detection behavior while preventing the rule from affecting unrelated application tiers.

Scopes are not primarily defined for individual nodes because nodes inherit transaction detection behavior from their tier-level configuration. They are also not used for backends, which are identified through exit-point and backend detection configuration. Transaction Detection Rule scopes remain within the context of a single monitored application and are not used to distribute one rule across multiple applications.

Relevant CAAPA Study Guide topics include Transaction Detection, Rule Scopes, Tier-Level Instrumentation, Custom Match Rules, Exclude Rules, Entry-Point Detection, and Application Agent Configuration.

Business Transaction Discovery Sessions allow a Performance Analyst to browse the application’s classes and methods while identifying suitable entry points for custom Business Transaction detection. The discovery process observes application execution and exposes loaded or invoked code structures, enabling the analyst to locate the class and method that represent the beginning of a meaningful transaction.

Browsing classes helps narrow the search to the relevant package or application component. After selecting a class, the analyst can inspect its methods and choose the appropriate method as the transaction entry point. This is particularly useful when automatic discovery does not recognize a proprietary framework, background process, scheduled task, or other nonstandard execution path.

Database Calls are analyzed as exit calls or backend activity rather than browsed as transaction entry-point code. JMX MBeans are accessed through JMX monitoring and metric configuration tools. Memory Objects are examined through memory diagnostics, object instance tracking, or leak-detection functions, not Business Transaction Discovery Sessions.

Relevant CAAPA Study Guide topics include Business Transaction Discovery Sessions, Class and Method Browsing, Custom Match Rules, Entry-Point Configuration, Automatic Discovery, and Application Agent Instrumentation.

By default, AppDynamics allows a maximum of 200 registered Business Transactions per application and 50 Business Transactions per node.

The application-level limit controls the total number of unique Business Transactions that can be registered across all tiers and nodes belonging to the application. The node-level limit restricts how many transactions a single Application Agent can independently discover and register. These safeguards prevent uncontrolled Business Transaction growth, excessive metric creation, and unnecessary Controller resource consumption.

When either limit is reached, newly discovered requests are not registered as individual Business Transactions. Instead, they are typically grouped into an All Other Traffic category for the affected tier or entry-point type. Important transactions can still be prioritized by creating Custom Match Rules, excluding low-value traffic, refining transaction naming, or adjusting registration limits where operationally justified.

The application limit is not 100 or 300 by default, and the node limit is not 75 or 200.

Relevant CAAPA Study Guide topics include Business Transaction Registration Limits, Application and Node Limits, All Other Traffic, Automatic Transaction Discovery, Custom Match Rules, Exclude Rules, and Business Transaction Lock Down.

To view all captured endpoints by service using the REST interface in AppDynamics, a Performance Analyst would navigate to the Metric Browser and proceed to the " Consumed Endpoints " section. From there, drilling down on specific endpoints within the Metric Browser allows the analyst to explore the services associated with each endpoint. This method enables detailed analysis of endpoint metrics, facilitating the monitoring and optimization of service performance.

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.

Excluding the Business Transaction from the Business Transaction Dashboard removes it from the displayed transaction list even while traffic continues to execute. Exclusion is specifically intended to suppress unwanted or low-value transactions from normal Business Transaction visibility and prevent them from consuming monitored transaction capacity.

Deleting the Business Transaction alone would not reliably keep it absent. Because the transaction has continuous load, the Application Agent could rediscover and register it again, causing it to reappear. Enabling Business Transaction Lock Down prevents newly discovered transactions from being registered, but it does not automatically remove Business Transactions that were already registered before lockdown was enabled.

Deleting a Custom Match Rule also does not directly remove the existing registered Business Transaction. The transaction might remain registered, or automatic transaction discovery could continue detecting the same entry point.

Therefore, the action that directly explains why the continuously active transaction stopped appearing is that it was excluded from the Business Transaction Dashboard.

Relevant CAAPA topics include Business Transaction Exclusion, Transaction Registration, Automatic Rediscovery, Business Transaction Lock Down, Custom Match Rules, and Dashboard Visibility.

When Business Transaction Lock Down is enabled in AppDynamics, no new business transactions will be automatically discovered to avoid uncontrolled growth in the number of business transactions. To track a new service as a unique Business Transaction, one needs to create a Custom Match Rule that specifies the criteria for identifying the business transaction. In this case, the Custom Match Rule should be based on the Web Service Name and Operation Name which are the distinguishing characteristics of the new service. This allows for the precise identification and monitoring of the service within the AppDynamics platform.

The Application Agent supports a default maximum of 50 Service Endpoints per entry point type. An entry point type represents the technology or execution mechanism through which the monitored request enters the application, such as a servlet, web service, message listener, or asynchronous processing framework.

This limit prevents excessive endpoint registration and metric creation at both the Agent and Controller layers. When Service Endpoint detection rules identify more endpoints than the configured threshold for a particular entry point type, the Agent restricts registration to the permitted maximum. The limit can be governed through the relevant Agent node-property configuration, but the standard tested value is 50.

The asynchronous-worker-thread options are too narrowly scoped and do not describe the general Service Endpoint registration limit. Likewise, 25 endpoints per entry point type is not the standard default Application Agent threshold.

This distinction is important because Service Endpoints generate independent performance metrics while remaining subordinate to the associated Business Transaction. Relevant CAAPA Study Guide topics include Service Endpoint Detection, Agent and Controller Limits, Entry Point Types, Agent Node Properties, Metric Registration, and Business Transaction Visibility.

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.

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 Performance Analyst should first investigate the Business Transactions exceeding the configured limit and determine why so many unique transactions are being registered. Business Transaction limits protect the Controller from excessive metric creation, unnecessary cardinality, and degraded monitoring performance.

A high transaction count is often caused by overly granular transaction naming, dynamic URL segments, request parameters, identifiers, or automatic discovery rules that create a separate Business Transaction for each variation. The analyst should review All Other Traffic, transaction detection rules, naming rules, and the entry points generating excessive registrations. Low-value traffic such as health checks, static resources, or framework-generated requests can be excluded, while related requests can be grouped or split more deliberately through Custom Match Rules.

Increasing the limit without correcting the underlying detection behavior may only postpone the problem and increase Controller resource consumption. The limit should be raised only after the transaction model has been validated and a genuine business requirement remains.

Relevant CAAPA Study Guide topics include Business Transaction Limits, All Other Traffic, Transaction Detection Rules, Custom Match Rules, Exclude Rules, Transaction Naming, and Metric Cardinality Management.

AppDynamics supports scheduled delivery of Application Health, Controller Audit, and Custom Dashboard reports.

An Application Health report summarizes the operational condition of monitored applications over a selected reporting period. It can include health-rule violations, Business Transaction performance, errors, response-time behavior, and application availability, making it suitable for recurring operational reviews.

A Controller Audit report provides a record of administrative and configuration activity performed in the Controller. It is useful for governance, security review, compliance verification, and tracking changes made by users or administrators.

A Custom Dashboard report captures the widgets and visualizations configured on a selected custom dashboard. It can be generated periodically and emailed to stakeholders who need recurring application, infrastructure, or business-performance summaries without manually opening the Controller.

Ad Hoc Data describes manually selected or temporary analysis rather than a standard schedulable report type. Error Trends may appear as a dashboard visualization or metric analysis, but it is not a distinct scheduled-report category. Tier List is an application inventory view rather than a report designed for periodic email delivery.

Relevant CAAPA Study Guide topics include Reports, Report Scheduling, Email Distribution, Application Health Reports, Controller Audit Reports, Custom Dashboards, and Role-Based Reporting.

AppDynamics imposes a limit on the number of Service Endpoints that can be registered per node to ensure manageable performance and overhead. The limit per node is set to 100 Service Endpoints, which is a balance between providing detailed monitoring and maintaining application performance.

The Slow Response Times option under the Troubleshooting menu provides access to transaction snapshots associated with application performance degradation. From this view, a Performance Analyst can examine individual transaction executions classified as slow, very slow, stalled, or otherwise relevant to response-time analysis.

Transaction snapshots provide detailed diagnostic information such as the Business Transaction name, participating tiers and nodes, execution timeline, call graph, method timings, database calls, remote service calls, errors, and data-collector values. This allows the analyst to determine whether latency originates in application code, a database query, an external service, thread contention, or another downstream dependency.

Health Rule Violations displays warning and critical events generated by health rules, but it is not the primary transaction-snapshot browsing view. War Rooms provide a collaborative troubleshooting workspace for incidents. “Slow and Error Transactions” describes transaction classifications or filtering concepts, but the applicable option under the Troubleshooting menu is Slow Response Times.

Relevant CAAPA Study Guide topics include Troubleshooting Slow Response Times, Transaction Snapshots, User Experience Classification, Call Graph Analysis, Database and Remote Service Calls, and Root-Cause Analysis.

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 supported programming-language options are Go, C/C++, and C#. AppDynamics provides monitoring capabilities for applications built with these languages through language-specific agents, supported runtime instrumentation, or application-monitoring SDKs.

C# is monitored through the AppDynamics .NET Agent, which instruments supported .NET and .NET Framework applications to discover Business Transactions, collect call graphs, monitor exceptions, and correlate downstream service calls. C/C++ applications can be monitored using the AppDynamics C/C++ SDK and associated application instrumentation capabilities, enabling custom Business Transaction definition, exit-call tracking, and distributed transaction correlation. Go applications are supported through AppDynamics monitoring components designed for Go-based services, allowing transaction visibility and correlation within distributed application environments.

Perl is not listed as a standard AppDynamics APM language-agent platform. React is a JavaScript user-interface library rather than a programming language; browser-side React applications are typically observed through Browser Real User Monitoring. iOS Family describes a mobile platform, not a programming language, and is addressed through Mobile Real User Monitoring.

Relevant CAAPA topics include Application Agent Platforms, .NET Agent, C/C++ SDK, Go Application Monitoring, Business Transaction Instrumentation, and Real User Monitoring.