Module 4 — Applications: builtin application metrics, web and mobile RUM and synthetic

Builtin application metrics for Dynatrace Managed: 23 entries for Apdex, Core Web Vitals, errors, mobile crashes and synthetic, with metric selector.
Module 4 — Applications : les métriques application builtin, RUM web, mobile et synthétique

Module 4 of the Dynatrace Managed metrics course: builtin application metrics for web and mobile RUM (Apdex, user actions, Core Web Vitals, errors, crashes) and for synthetic monitors, in 23 entries with the exact key, unit, use case and a ready-to-paste selector.

Learning path: Dynatrace Managed metrics training · Module 4/7 · Type: reference · Platform: Dynatrace Managed (classic metrics)

In this module:

  • a summary table of the 23 keys, to keep at hand
  • one entry per metric: what it measures, when to use it, the pitfall to avoid
  • a metric selector per entry, testable in Data Explorer

The previous modules look at the system from the inside: hosts, services, databases. This module looks from the user’s side. RUM measures what real visitors experience in their browser or mobile app; synthetic monitoring replays a journey at a fixed interval, even at night when nobody logs in. Together, they provide the SLIs closest to what customers feel.

Everything below applies to Dynatrace Managed: builtin:apps.* and builtin:synthetic.* keys, metric selector, Metrics API v2 and Data Explorer. There is no Grail or DQL here. On Dynatrace SaaS with Grail, RUM and synthetic use different keys; they are covered in the SaaS metrics course.

This module extends module 3 on services: a slow user action is often read alongside the service it calls. For the setup, see RUM and Core Web Vitals and HTTP and browser synthetic monitoring.

Builtin application metrics in one table

Every key, unit and aggregation below comes from the official list of Dynatrace Managed built-in metrics. The “Scope” column reflects the documentation label ([web], [mobile, custom], [browser monitor], [HTTP monitor]); exact dimensions are listed in each metric’s descriptor. An empty unit means a unitless score.

Key Unit Aggregations Scope What it measures
builtin:apps.web.apdex.userType (score) avg Web Apdex of user actions, by user type
builtin:apps.web.actionCount.load.browser Count value Web Number of load actions, by browser
builtin:apps.web.actionDuration.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Duration of load actions
builtin:apps.web.actionDuration.xhr.browser Millisecond avg, count, max, median, min, percentile, sum Web Duration of XHR actions
builtin:apps.web.visuallyComplete.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Time to fully render the viewport
builtin:apps.web.largestContentfulPaint.load.browser Millisecond avg, count, max, median, min, percentile, sum Web Largest Contentful Paint (LCP)
builtin:apps.web.cumulativeLayoutShift.load.browser (score) avg, count, max, median, min, percentile, sum Web Cumulative Layout Shift (CLS)
builtin:apps.web.interactionToNextPaint Millisecond count, max, median, min, percentile Web Interaction to Next Paint (INP)
builtin:apps.web.activeSessions Count value Web Estimated active sessions
builtin:apps.web.bouncedSessionRatio Percent (%) value Web Bounce rate
builtin:apps.web.countOfErrors Count value Web Detected errors, by type and origin
builtin:apps.web.jsErrorsDuringUa Count value Web JavaScript errors during a user action
builtin:apps.web.percentageOfUserActionsAffectedByErrors Percent (%) value Web % of user actions affected by an error
builtin:apps.other.apdex.osAndVersion (score) value Mobile, custom Apdex by OS and app version
builtin:apps.other.uaDuration.osAndVersion Microsecond avg, count, max, median, min, percentile, sum Mobile, custom Duration of user actions
builtin:apps.other.crashCount.osAndVersion Count value Mobile, custom Detected crashes, by OS and version
builtin:apps.other.crashFreeUsersRate.os Percent (%) value Mobile, custom Estimated % of crash-free users
builtin:synthetic.browser.availability.location.total Percent (%) avg Browser monitor Availability rate, by location
builtin:synthetic.browser.failure Count value Browser monitor Failed executions
builtin:synthetic.browser.totalDuration Millisecond avg, count, max, median, min, percentile, sum Browser monitor Total duration of an execution’s actions
builtin:synthetic.http.availability.location.total Percent (%) avg HTTP monitor Availability rate, by location
builtin:synthetic.http.duration.geo Millisecond avg, count, max, min, sum HTTP monitor Summed duration of requests, by location
builtin:synthetic.http.statusCode Count value HTTP monitor Executions by HTTP status code
Excerpt from the Dynatrace Managed documentation: builtin:apps.web, apps.other and synthetic keys with their name, unit and aggregations

How to read an entry

Each entry follows the same order: what the metric measures, a concrete use case, a pitfall, then a selector. Selectors split by dt.entity.application for web, dt.entity.synthetic_test for browser monitors and dt.entity.http_check for HTTP monitors, using only documented transformations (splitBy, sort, limit, aggregations, percentile). Thresholds mentioned are reference points to calibrate on your own history, not official values, unless stated otherwise.

Web applications: experience and performance

builtin:apps.web.apdex.userType

Apdex score from 0 to 1 computed on user actions, splittable by user type (real, synthetic, robot). It is the summary indicator of experience: it combines satisfied, tolerating and frustrated users according to the thresholds configured in the application. Use case: a “real users Apdex” SLO per application. Pitfall: without filtering on user type, robots and synthetic traffic mix with real traffic.

builtin:apps.web.apdex.userType:splitBy("dt.entity.application"):avg:sort(value(avg,ascending)):limit(10)

builtin:apps.web.actionCount.load.browser

Number of page load actions, split by browser. It is traffic seen from the client, the counterpart of service throughput. Use case: a sudden drop while services respond normally often points to a CDN, DNS or RUM JavaScript injection problem. Pitfall: XHR and custom actions have their own keys; a single-page application generates few “load” actions.

builtin:apps.web.actionCount.load.browser:splitBy("dt.entity.application"):sum

builtin:apps.web.actionDuration.load.browser

Duration of load actions, from click to end of loading. Use case: track the 90th percentile per application rather than the average, which hides the slow tail. Pitfall: this duration includes the client network and rendering; an increase does not necessarily come from the back end.

builtin:apps.web.actionDuration.load.browser:splitBy("dt.entity.application"):percentile(90)

builtin:apps.web.actionDuration.xhr.browser

Duration of XHR actions, the asynchronous calls triggered by a click in an already loaded page. For a single-page application, it is often the main performance metric. Use case: correlate an increase with the response time of the called service (module 3). Pitfall: badly grouped background calls can inflate or distort the measurement.

builtin:apps.web.actionDuration.xhr.browser:splitBy("dt.entity.application"):percentile(90)

builtin:apps.web.visuallyComplete.load.browser

Time needed for the viewport content to be fully rendered. A Dynatrace-specific metric, it matches the “page is ready” perception. Use case: compare before and after a front-end release. Pitfall: an endless carousel or animation can delay the value without bothering users.

builtin:apps.web.visuallyComplete.load.browser:splitBy("dt.entity.application"):median

builtin:apps.web.largestContentfulPaint.load.browser

Time to render the largest element in the viewport, one of the Core Web Vitals. Google rates an LCP of 2.5 s or less at the 75th percentile as “good”; that reference comes from web.dev, not from Dynatrace. Use case: track LCP on landing pages, which matter for search ranking. Pitfall: computed only for load actions and for browsers that expose the API.

builtin:apps.web.largestContentfulPaint.load.browser:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.cumulativeLayoutShift.load.browser

Unitless score of unexpected shifts of visible elements during loading. Use case: detect a banner or ad inserted without reserved space, which makes users click the wrong thing. Pitfall: it is a score, not a duration; do not put it on the same axis as millisecond metrics.

builtin:apps.web.cumulativeLayoutShift.load.browser:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.interactionToNextPaint

Interaction to Next Paint: delay between an interaction (click, typing) and the next paint. The responsiveness Core Web Vital that replaces First Input Delay. Use case: spot heavy JavaScript that freezes the interface. Pitfall: the documentation does not list the avg aggregation for this key; use median or percentile.

builtin:apps.web.interactionToNextPaint:splitBy("dt.entity.application"):percentile(75)

builtin:apps.web.activeSessions

Estimated number of active sessions, those where the user is confirmed to still be present. The documentation states the estimate relies on the HyperLogLog algorithm. Use case: know how many users an incident affects right now, a figure expected in any incident communication. Pitfall: approximate value; do not reconcile it to the unit with a marketing tool.

builtin:apps.web.activeSessions:splitBy("dt.entity.application"):max

builtin:apps.web.bouncedSessionRatio

Percentage of sessions limited to a single page and a single web request. Use case: a sudden rise after a release can reveal a broken home page that technical metrics miss. Pitfall: bounce rate depends heavily on page type; an information page naturally has a high rate.

builtin:apps.web.bouncedSessionRatio:splitBy("dt.entity.application"):avg

builtin:apps.web.countOfErrors

Number of detected errors, splittable by user type, error type and origin. Use case: separate JavaScript errors from request errors to know which team to call. Pitfall: a noisy third-party script (ads, chat) can dominate the counter; filter on origin before alerting.

builtin:apps.web.countOfErrors:splitBy("dt.entity.application"):sum:sort(value(sum,descending)):limit(10)

builtin:apps.web.jsErrorsDuringUa

JavaScript errors that occurred during a user action. Its twin builtin:apps.web.jsErrorsWithoutUa counts those between two actions. Use case: errors during an action directly affect a click, so they are more urgent. Pitfall: a raw counter grows with traffic; relate it to the number of actions.

builtin:apps.web.jsErrorsDuringUa:splitBy("dt.entity.application"):sum

builtin:apps.web.percentageOfUserActionsAffectedByErrors

Percentage of user actions with at least one detected error. Already normalised by traffic, it makes a good client-side error SLI. Use case: an SLO such as “fewer than X % of actions with errors”, X set from your history. Pitfall: an error with no visible impact counts as much as a blank page.

builtin:apps.web.percentageOfUserActionsAffectedByErrors:splitBy("dt.entity.application"):avg

Mobile and custom applications

builtin:apps.other.apdex.osAndVersion

Apdex of user actions in a mobile or custom application, by OS and app version. Use case: check that a new store release does not degrade experience before widening a staged rollout. Pitfall: old versions keep few users; their Apdex varies strongly on a small sample.

builtin:apps.other.apdex.osAndVersion:splitBy():avg

builtin:apps.other.uaDuration.osAndVersion

Duration of mobile user actions, by OS and version. Use case: compare the 90th percentile between two app versions. Pitfall: the unit is the microsecond, not the millisecond as for web; check the axis before concluding there is a regression.

builtin:apps.other.uaDuration.osAndVersion:splitBy():percentile(90)

builtin:apps.other.crashCount.osAndVersion

Number of detected crashes, by OS and version. Use case: a version that concentrates crashes right after release justifies freezing the rollout. Pitfall: an absolute counter follows the number of users; prefer the crash-free user rate for comparisons.

builtin:apps.other.crashCount.osAndVersion:splitBy():sum

builtin:apps.other.crashFreeUsersRate.os

Estimated percentage of unique users not affected by a crash, by OS (HyperLogLog estimate according to the documentation). It is the most readable mobile stability SLI for a product team. Use case: track a stability objective per iOS and Android platform. Pitfall: estimated value, unreliable for an application with a very small audience.

builtin:apps.other.crashFreeUsersRate.os:splitBy():avg

Browser and HTTP synthetic monitors

builtin:synthetic.browser.availability.location.total

Availability rate of browser monitors, by location. Use case: availability SLI of a critical journey (login, checkout), measured even without real traffic. The …totalWoMaintenanceWindow variant excludes maintenance windows, useful for an SLA report. Pitfall: a single failing location lowers the average; look at the per-location split before escalating.

builtin:synthetic.browser.availability.location.total:splitBy("dt.entity.synthetic_test"):avg

builtin:synthetic.browser.failure

Number of failed executions of a browser monitor. Divided by builtin:synthetic.browser.total, it gives a failure rate. Use case: alert on several consecutive failures rather than one, often caused by a network glitch at the location. Pitfall: a script broken by a UI change fails too; check the details before blaming production.

builtin:synthetic.browser.failure:splitBy("dt.entity.synthetic_test"):sum

builtin:synthetic.browser.totalDuration

Duration of all actions in an execution, per monitor. Use case: a stable baseline, free of client network variability, to detect a performance regression at deployment. Pitfall: adding a step to the script lengthens the duration; annotate those changes on your charts.

builtin:synthetic.browser.totalDuration:splitBy("dt.entity.synthetic_test"):avg

builtin:synthetic.http.availability.location.total

Availability rate of HTTP monitors, by location. Lighter than browser monitors, they watch APIs and health endpoints at high frequency. Use case: availability SLI of a public API. Pitfall: an HTTP monitor validates a response, not a page render; it does not replace a browser monitor for a journey.

builtin:synthetic.http.availability.location.total:splitBy("dt.entity.http_check"):avg

builtin:synthetic.http.duration.geo

Summed duration of all requests in an HTTP monitor, by location. Neighbouring keys …dns.geo, …tcpConnectTime.geo, …tlsHandshakeTime.geo and …timeToFirstByte.geo break that time down. Use case: an increase limited to one location points to the network rather than the application. Pitfall: no median or percentile is documented for this key.

builtin:synthetic.http.duration.geo:splitBy("dt.entity.http_check"):max

builtin:synthetic.http.statusCode

Number of executions per HTTP status code, by location. Use case: tell a 503 (service unavailable) from a 401 (expired token in the monitor), two very different incidents. Pitfall: a 200 does not guarantee correct content; add a validation rule in the monitor.

builtin:synthetic.http.statusCode:splitBy("dt.entity.http_check"):sum

How to check that it works

  1. Open Data Explorer, switch to Code mode and paste a selector from an entry: a chart should appear within seconds.
  2. If the response is empty, read the descriptor: GET /api/v2/metrics/builtin:apps.web.apdex.userType with a token carrying the metrics.read scope. It lists unit, aggregations and dimensions.
  3. For web RUM, check that the application is detected and that the RUM JavaScript is injected into pages (browser network tab).
  4. For synthetic, check that the monitor is enabled and that a location (public or private, synthetic ActiveGate) is assigned to it.
curl -s -H "Authorization: Api-Token $DT_TOKEN" \
  "https://managed.example.com/e/ENV-ID/api/v2/metrics/query?metricSelector=builtin:synthetic.http.availability.location.total:avg&from=now-24h"

Good practices

  • Combine RUM and synthetic: RUM tells you what users experience, synthetic tells you whether the service answers when nobody uses it.
  • Percentiles rather than averages for durations: the average hides the slowest users.
  • Filter out robots and synthetic traffic from real-experience SLOs using the user type.

Frequently asked questions

Why do mobile keys start with apps.other?

In Dynatrace Managed, mobile and custom applications share the builtin:apps.other.* family, labelled [mobile, custom] in the documentation. Only a few keys, such as builtin:apps.mobile.sessionCount, have a dedicated prefix.

Are Dynatrace Core Web Vitals the same as Google’s?

They measure the same phenomena (LCP, CLS, INP) for your real users, but on your population and your browsers. The figures can therefore differ from Google’s reports, which rely on another sample.

Do these keys work on Dynatrace SaaS?

In the SaaS classic interface, yes. On Grail, RUM and synthetic expose other keys queried with DQL; the SaaS metrics course covers them.

With these 23 entries, you have the user-side SLIs: experience, responsiveness, errors, mobile stability and synthetic availability. The next module goes back down to processes, runtimes and containers.

← Module 3: services · Course overview · Module 5: processes and containers →

span.observer is an independent community blog, not affiliated with Dynatrace LLC. This module is an annotated selection: the reference remains the official documentation for your Dynatrace Managed version, where every key, unit and aggregation should be checked.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Module 3 — Services : 20 métriques service builtin de Dynatrace Managed

Module 3 — Builtin service metrics in Dynatrace Managed: 20 keys for requests, errors, databases

Next Post
Module 5 — Processus et conteneurs : les métriques processus builtin, runtimes et Kubernetes

Module 5 — Processes and containers: builtin process metrics, runtimes and Kubernetes

Related Posts