APM: What It Is, Metrics, and How It Works

What Is APM in Development

APM (Application Performance Monitoring) is the discipline of application performance management, covering the collection, visualization, and analysis of software operation data. Unlike point monitoring of individual metrics (CPU, memory), APM provides a holistic picture: how the application behaves from the user’s perspective, how its components interact, and where bottlenecks occur.

The APM concept emerged in the 2010s with the transition from monolithic applications to microservice architecture. When the number of services exceeded 10–15 units, traditional monitoring methods stopped working — it was impossible to determine which specific service caused a slowdown across the entire request. APM solutions solved this problem through distributed tracing and automatic service map construction.

According to Grand View Research (2024), the APM market is valued at $8.2 billion USD and is growing at 11.5% annually. Key drivers include cloud migration, the growing number of microservices, and increasing requirements for user experience quality in mobile applications and web services.

Three Pillars of APM: Metrics, Tracing, Logs

Modern APM is built on three types of data that together form a complete picture of the application’s state. Metrics are numerical aggregates: response time, request count, error rate. They answer the question “what is happening” and allow configuring alerts based on threshold values.

Tracing as the Link

Tracing (distributed tracing) answers the question “why is this happening.” Each incoming request is traced through all microservices, databases, and external calls. The APM system combines metrics and tracing: if the response time metric has increased, the developer navigates to the traces dashboard and sees the exact request that caused the slowdown, broken down by each service.

Logging for Depth

Logs provide context — a specific error message, variable value, call stack. Modern APM platforms (Datadog, New Relic, Grafana) link logs with traces through a common trace_id, allowing navigation from a metric graph to a specific request log. According to Datadog (2025), correlating logs with traces reduces the average incident diagnostic time from 45 to 12 minutes.

APM Architecture: Agents and Collectors

The classic APM architecture consists of three levels: agent, collector, and backend. An agent is a library embedded into the application or running alongside it (sidecar). The agent intercepts incoming and outgoing calls, collects runtime data, and sends it to the collector over a secure channel.

How the APM Agent Works

An APM agent for Java can connect via javaagent at the JVM level, automatically instrumenting all HTTP requests, database calls, message queues, and external APIs. For mobile platforms, the agent connects as an SDK and collects metrics from the device. The New Relic Agent for Android, for example, automatically tracks all network requests via OkHttp, HTTP clients, and WebView.

import com.newrelic.agent.android.NewRelic;

public class MainApplication extends Application {
    public void onCreate() {
        super.onCreate();
        NewRelic.withApplicationToken("YOUR_TOKEN")
            .start(this);
    }
}

This code initializes the New Relic Agent in an Android application. After launch, the agent automatically collects network request metrics, errors, ANRs, and UI performance data without additional instrumentation of each screen. The agent runs in a background thread and does not affect the main application interface performance.

Collector and Backend

The collector receives data from thousands of agents, aggregates metrics, performs trace sampling, and stores data in long-term storage with hot and cold storage capabilities. The APM backend provides dashboards, alerts, service maps, and an API for integration with external systems (Slack, PagerDuty, Jira, ServiceNow). Datadog processes over 10 million data points per second through its collectors, located in 20+ world regions for minimal transmission latency.

Apdex Score and SLA Monitoring

Apdex (Application Performance Index) is an open standard for measuring user satisfaction with application response time. The Apdex value is calculated using the formula: (number of satisfied users + number of tolerating users / 2) / total number of users. The result is a number from 0 to 1, where 1 means all users are satisfied.

Apdex thresholds are set individually for each application. For mobile applications, a typical satisfaction threshold is a response time of up to 1.5 seconds, tolerating up to 4.5 seconds. Anything exceeding 4.5 seconds is considered unacceptable. An Apdex score of 0.94 and above is considered excellent for a production environment.

Apdex is used not only as a quality metric but also as a threshold for alerts. If the Apdex drops below 0.85 for 10 minutes, the APM system sends a notification to the on-call team. This is a more balanced approach than relying on absolute response time values, which can fluctuate depending on the time of day and load.

APM for Mobile Applications

Mobile APM has its own specifics: the application runs on the user’s device, which may be in different network conditions, have varying amounts of free memory and OS versions. Mobile APM must account for all these factors and provide a breakdown of metrics by device models, OS versions, regions, and network carriers.

Data Collection from the Device

Mobile APM agents collect metrics on the device and send them to the server in batches at 1–5 minute intervals. This minimizes the impact on the user’s traffic. In case of connection loss, data is saved in a local cache and sent on the next connection. Firebase Performance and Dynatrace Mobile support automatic retransmission upon network loss.

Key Mobile Metrics

Specific metrics are added to standard APM metrics in mobile development: cold start time, FPS during scrolling, memory consumption, ANR frequency (Android), and watchdog termination count (iOS). New Relic Mobile additionally tracks map views, cache usage percentage, and rendering time of specific ViewControllers.

import NewRelic

class ProfileViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        NewRelic.startInteraction(withName: "ProfileView")
    }

    override func viewDidDisappear(animated: Bool) {
        super.viewDidDisappear(animated)
        NewRelic.stopCurrentInteraction()
    }
}

The Swift code creates an interaction trace for the user profile screen. New Relic will automatically measure data loading time, UI rendering, and all network requests performed while this screen is displayed.

Comparison of Popular APM Platforms

The APM market features dozens of solutions that differ in monitoring depth, cost, and supported platforms. Datadog APM leads in integrating metrics, traces, and logs in a single interface. New Relic offers the most detailed tracing for mobile platforms. Dynatrace uses the Davis AI engine for automatic root cause detection.

The choice of APM platform depends on team size, technology stack, and budget. For startups, Firebase Performance combined with Grafana for the backend is optimal. For enterprise projects with high SLA requirements — Datadog or Dynatrace with a full set of observability tools and AI-powered root cause analysis.