Learn
Real User Monitoring

Real User Monitoring (RUM)

Real User Monitoring tells you how your frontend performs for the people using it, and gives you the evidence to explain one bad experience. In Traceway that is Web Vitals and browser metrics, dashboards, release comparisons, SLOs, alerts, errors, sessions and replay in one workflow, built on OpenTelemetry.

A successful API request does not tell you whether a page loaded slowly, a button froze or content shifted under a user's pointer. RUM measures those browser experiences on every visit. Session replay is the investigation layer: use it to understand a recorded journey after metrics show where to look.

Two ideas make it different from a replay tool with charts attached:

  • Every visit is measured, almost nothing is uploaded. Performance numbers are aggregated on the device into histograms, so a session costs one small payload whether it had three interactions or three thousand.
  • The detail waits on the device. Clicks, requests, console lines and the replay sit in a ring buffer in the browser. They leave only when something goes wrong, or when you ask for them. A healthy session uploads no breadcrumbs and no replay.

Setting up an app? RUM Best Practices explains what metrics, sessions, exceptions and logs each represent, which one to use for what, and how to identify users and find their sessions.

What you get

CapabilityWhat it covers
Web VitalsLCP, INP, CLS, FCP and TTFB per page load, plus INP and CLS per view so single-page-app route changes are measured too
Page and route timingPage load, DOM ready, transfer size, how long a route change takes to settle, long tasks and total blocking time
RequestsDuration and failure rate of fetch and XHR by host, with the W3C traceparent header that joins a browser request to its backend trace
Who is affectedPage views, sessions, browser profiles per day, and profiles affected by an error, a poor vital, a rage click or a failed request, counted on the device so no id is sent
What is behind a slow valueThe element behind a poor LCP, INP or CLS, the script behind main-thread time, and a link to a session that experienced it
SegmentsRelease, environment, route, browser, OS, form factor, device class, network type, country, and two dimensions of your own
Web Performance dashboardAssigned when the project is created: percentiles, rating shares and breakdowns, before you build a chart
Release regression alertsA new release compared with the earlier one, adjusted for device mix and gated on sample size
Frontend SLOsAn error budget on a web vital, a route or crash-free sessions, per release or device
Errors with contextSource-mapped issues with the 10 minutes of clicks, requests and console lines before them, and a 30 second replay clip
Sessions and replayEvery session listed and searchable by attribute; DOM replay with inputs masked by default
Recording triggersRecord the journeys you choose: a click sequence, three failed requests in a minute, a log line that repeats
Capture on demandAsk one user's browser, one device or one session for its recent history and a live stream, from the dashboard
Remote controlChange what a release, a browser or a share of traffic sends without shipping a build, including a kill switch
Your own metricsmetric() and count() for the numbers only your app knows

How it works

RUM architecture. In the browser, instrumentation produces every measurement. Each number goes to a device aggregator that keeps one histogram per metric and dimension set and always uploads it to the metrics endpoint, where payloads are merged in memory, written every 10 seconds and stored as histograms per minute that feed the Web Performance dashboard, SLOs and alerts. Each event goes to the telemetry router, which streams it, puts it in the ring buffer (the last 10 minutes or 2 MB, surviving page loads) or drops it; a trigger engine sees every record and flushes the buffer. Streamed and flushed records reach the OTLP logs and traces endpoints and the telemetry store that the session and issue pages read. DOM changes go to a replay buffer whose clip or stream reaches the recordings endpoint, replay files and the replay player. An OpAMP client polls for collection rules and captures edited on the Data Collection page.

Every measurement in the browser has two outputs:

  1. The number goes into an aggregate on the device, shown in blue. Aggregates always travel. They are what dashboards, SLOs and alerts read, so those cover every session, not only the ones that had a problem.
  2. The event goes through the telemetry router, which looks up its signal's mode: stream it now, buffer it on the device, or drop it. Buffered events and the replay, shown in orange, travel only when a trigger or a capture opens the buffer.

A third channel, OpAMP, carries your collection rules from the dashboard to each browser. The SDK is built on the OpenTelemetry Browser SIG instrumentations and speaks standard OTLP/HTTP, so the records are ordinary OpenTelemetry logs, spans and metrics.

Numbers: aggregated on the device

One observation, for example an INP of 184 ms on /checkout/:id for release 4.2 on an Android phone, increments a bucket of a histogram cell on the device. The device uploads one small payload of standard OTLP delta histograms when the page is hidden, at session end and every 5 minutes. At ingest, payloads from every device are merged bucket by bucket in memory and written as one batch every 10 seconds. Storage holds one row per metric, dimension set and minute, rolled up to hours and days, so rows grow with dimensions and not with users. Reads merge the buckets first and then compute p75, rating shares, SLO good and total, and release comparisons.

Nobody charts one phone. The question is always about a population: "p75 INP of release 4.2 on Android". So the browser never sends one row per measurement. It keeps a histogram per metric and set of dimensions, and an observation increments a bucket. The page uploads one small payload when it is hidden, at session end, and every five minutes for long sessions.

The consequences are the reason to build it this way:

  • Cost follows dimensions, not traffic. A stored row is one metric, one combination of dimensions and one minute. A million users on the same release, route and device class merge into the same rows as a hundred.
  • Percentiles stay correct. Buckets from every device add up, and a percentile is read from the merged buckets. Traceway never averages percentiles. Buckets are about 9% wide.
  • Metric dimensions group visits. Built-in dimensions use route templates such as /orders/:id and omit user, session and device IDs. A retained exemplar carries a session ID so you can open the visit behind a poor measurement. "Users affected" is counted by the device itself, once per browser profile per day.
  • Every session counts. Because metrics do not depend on replay or on an error happening, a fast release and a slow one are compared on all of their traffic.
  • A dying page still reports. A payload sent while the page is closing is kept in the browser and sent once more on the next page load; the server recognizes the duplicate.

Names, dimensions, sampling and limits are on Client Metrics.

Detail: the ring buffer

The ring buffer on the device. Breadcrumbs (navigation, clicks, requests, console lines) are held for the last 10 minutes or 2 MB, the oldest evicted first; rrweb replay segments are held in memory up to 8 MB. Nothing from them leaves the device while the session is healthy: only session start and end and the performance aggregates travel. Three things open the buffer: an error (built in), a trigger you define such as three failed requests in a minute or a click sequence, and a capture started from the dashboard. A flush uploads up to 10 minutes of breadcrumbs and a 30 second replay clip under one session id; Traceway shows what led up to the issue and links each request to its backend trace. What stays is saved once when the page is hidden and restored by the next page of the session.

Most sessions are fine, and nobody will ever open their console lines. Uploading them anyway is what makes always-on recording expensive and what puts the most personal data on a server. So the SDK keeps the detail where it was produced:

  • A breadcrumb ring buffer holds the newest clicks, navigations, requests, console lines and app events: the last 10 minutes or 2 MB, whichever is reached first. When the budget is exceeded the oldest entries go first.
  • A replay buffer holds rrweb segments in memory, up to 8 MB, with inputs masked by default. rrweb is only loaded when replay is not switched off.
  • It survives page loads. The buffer is written to IndexedDB once when the page is hidden or unloads (never on a timer, since serializing it would be a long task on a phone), and the next page of the same session restores it under the same limits. A checkout that fails on its third page still has the first two. Replay stays in memory.

Three things open the buffer:

WhatWhenWhat is uploaded
An errorBuilt in. An uncaught error, an unhandled rejection or captureExceptionUp to 10 minutes of breadcrumbs and a 30 second replay clip, attached to the issue
Your triggerA sequence you define in the dashboard: "three failed requests within a minute", "payment failed was logged", "clicked Pay, then left the page"The window and replay the trigger asks for, tagged with the trigger's name
A captureYou click Capture on a session or an issue, or target a user or deviceThe recent history of that browser, then a live stream for up to 24 hours

Triggers run in the browser and see every record, including those of a signal that is switched off. You can trigger on a 1 second main-thread freeze on a device that otherwise uploads no long tasks at all.

The buffer is bounded so a page is never harmed by its own monitoring: identical errors within a second are suppressed, a client accepts at most 60 errors a minute, error clips have a 5 second cooldown and a limit of 20 per session, and a session uploads at most 50 MiB or 10,000 diagnostic events. Failed uploads are retried from the browser's storage for up to 24 hours.

The modes, triggers and captures are set from the Data Collection page in the sidebar of a browser project: see Remote SDK Config. The ring buffer, triggers and captures need browser SDK 2.0 or later.

Start with Web Performance

Create a React, Vue, Svelte or jQuery project. Traceway assigns Web Performance immediately, before the first upload. Connect your browser SDK and let it collect traffic; an empty chart on a new project means there is no matching data yet. The aggregated metrics need browser SDK 2.0 or later (@tracewayapp/frontend, or the React, Vue, Svelte or jQuery wrapper of the same version); an app on the legacy 1.x SDK sends none, see the migration guide.

Web Performance with real browser telemetry from a controlled storefront demo

The dashboard brings together:

  • Loading: LCP, FCP, TTFB and page-load timing.
  • Interaction and stability: INP, CLS, route timings, blocking time and long tasks.
  • Impact: requests, page views, sessions and affected browser profiles.
  • Context: release, route, device, OS, country, element and script breakdowns where available.

Use p75 to track Web Vitals and p95 to inspect the tail. Read observation volume alongside a percentile. A few slow samples deserve investigation, but are different evidence from a regression across thousands of observed interactions.

Name your routes so the breakdown reads the way your app is built: setRoute("/orders/:id"), or the router helpers of the framework packages (useTracewayRoute in React, trackRouter in Vue, trackRoute in Svelte). Without a name, path segments that look like ids are replaced with :id.

Find the population that changed

Start with a release comparison, then narrow by OS or country. Use a breakdown table for routes, device form factors or other dimensions. A healthy aggregate can conceal a poor phone experience; a changing mix of devices can also move a percentile without a code regression.

The same dashboard narrowed to the slow demo release on Android

Metric Threshold alerts detect a bad current experience. Release Regression alerts compare a sufficiently observed new release with an earlier one. The default comparison can adjust for device and OS mix; Compare Within compares matching segments. Minimum-count gates and percentile confidence intervals use effective sample size, so one heavily weighted observation cannot pretend to be thousands of independent measurements. See client metrics.

Make performance an objective

An SLO answers a different question from a chart: what share of observed experiences should meet our promise over time?

For example, select browser.web_vital.inp, Every observation, ≤ 200 ms, and choose the target and rolling window for your application. Each estimated good interaction contributes to the numerator; all observed interactions contribute to the denominator. One SLO per release or device gives each population its own budget.

Fast and intentionally slow releases with separate frontend SLOs

The demo's fast release meets its objective and the intentionally slow release breaches it. This makes the decision concrete: which release changed, which population suffered, and how much budget remains? Use multi-window burn-rate alerts for sustained budget consumption. Keep a separate crash-free-session objective for reliability; a fast interaction does not prove a session was error-free.

A breached frontend SLO and its error budget

A page with no interaction has no INP sample, not a zero-millisecond interaction. Missing telemetry is not success. Histogram threshold counts and sampled totals are estimates, and a distribution SLO cannot count an unobserved event as a failure. SLO setup and semantics →

Follow the signal into a session

Open Slow sessions on a distribution widget. When an exemplar was retained, it links a poor observation to its session and may name the responsible element. Inspect the session's timeline, errors and network activity, then watch replay if a recording was captured.

A slow interaction opened in its session investigation

Each request in the timeline links to its trace, where the browser's request sits above the backend work it caused: the browser SDK sends the W3C traceparent header, so both sides share one trace id. See distributed tracing.

Replay does not need to record every session for metrics to work. Its availability depends on your SDK version and Data Collection settings. Review masking and consent before enabling collection. Sessions and replay → · SDK recording controls →

Record specific user journeys

Build click, hover, navigation and log sequences through the recording trigger editor. A completed sequence requests replay and adds a filterable reason to the session. Multiple triggers can explain the same recording, and their historical names and sequences remain available after a rule changes.

When one customer reports a problem you cannot reproduce, start a capture instead: target their user.id, their device or their open session, and the browser uploads what its ring buffer holds on its next check-in, then streams everything until the capture ends. See captures.

Measure what only your app knows

The browser SDK takes your own numbers into the same pipeline, aggregated on the device like the built-in ones:

import { metric, count, setMetricDimension } from "@tracewayapp/frontend";
 
metric("checkout.render", 412, { step: "payment" }); // a distribution: p75, p95, good ratio
count("search.empty_result");                         // a counter
setMetricDimension("plan", "pro");                    // on every metric this page sends

A project can have 50 custom metric names, each with two dimensions, and two global custom.<key> dimensions on every metric. Use them for a plan, a tenant tier or an experiment arm, never for an id. See client metrics.

Query and build your own charts

Use a line chart for the trend, a Rating Bar for good / needs improvement / poor shares, and a Breakdown Table for a whole-window comparison. Create metric sources with stable tag filters and a group-by dimension. Save reusable definitions through Dashboards as code.

For an API query, use an authenticated account token with access to the project, not its public ingest token. Send POST /api/metrics/query?projectId=PROJECT_UUID with UTC timestamps for your chosen range:

{
  "queries": [
    { "name": "browser.web_vital.inp", "aggregation": "p75", "groupBy": "service.version" },
    { "name": "browser.web_vital.inp", "aggregation": "count", "groupBy": "service.version" },
    { "name": "browser.web_vital.inp", "aggregation": "good_ratio", "threshold": 200, "groupBy": "service.version" }
  ],
  "from": "2026-11-16T00:00:00Z",
  "to": "2026-11-17T00:00:00Z",
  "wholeRange": true
}

wholeRange merges the window before calculating each result. Never average a series of p75 values to get the window's p75. Query good_ratio is a fraction from 0 to 1; notification-rule thresholds use percentages from 0 to 100. Use count for distribution observations and sum for delta counters such as page views. Counter count counts stored points, not events.

Use tagFilters to restrict an environment or population. For a trend, omit wholeRange and choose intervalMinutes, such as 15. Inspect response errors and truncation information before interpreting an empty result as healthy. Metric names, dimensions, sampling and limits →

Privacy and control

  • Built-in metric dimensions omit identifiers. Slow-session exemplars can include a session ID and the element associated with the measurement.
  • Replay masks inputs by default, and the detail of a healthy session never leaves the device.
  • The app sets the outer limits. What init() switches off (sessionRecording: false, captureLogs: false, ...) cannot be switched on from the server.
  • No code runs from the server. Collection rules are data: modes, numbers and matchers with a fixed set of operators.
  • A kill switch turns a broken release or browser version off without a deploy.

Why this workflow helps

Prioritize with context. Combine experience quality with volume and affected users, rather than treating every slow value as equally urgent. Browser-profile counts are not globally deduplicated people; across days they represent user-days.

Agree on a measurable promise. Product and engineering can discuss a specific population, threshold and budget. Choose objectives from your users' needs and history rather than adopting a universal target.

Keep diagnosis connected. A release comparison narrows the problem, a session provides individual context, and replay and source-mapped errors help explain the failure. Each layer answers the next question.

Screenshots use a controlled storefront demo and real browser visits. Release 0.2.0 was deliberately slowed to demonstrate the workflow; these results are not a customer benchmark or a claim of production-scale validation.