Browser data is OpenTelemetry: spans, log records (view events and exceptions) and metrics
generated from them. Attributes follow OpenTelemetry’s semantic conventions where they exist, and
ezgh.rum.* otherwise.
Resource attributes
One resource per page load:
| Attribute | Value |
|---|---|
service.name |
The application, unless your page sets one |
ezgh.metadata.application, ezgh.metadata.environment |
The client token’s application and environment, whatever the page sets |
service.version |
The release you passed to init |
telemetry.sdk.name, telemetry.sdk.language, telemetry.sdk.version |
ezgh-rum, webjs and the SDK’s version |
user_agent.original |
The User-Agent string |
browser.name, browser.version, os.name |
Such as Chrome, 129, Windows |
device.type |
desktop, mobile or tablet |
On every span and log record
| Attribute | Value |
|---|---|
session.id |
The session’s random ID (32 hex characters) |
ezgh.rum.view.id, ezgh.rum.view.name |
The view’s random ID, and its name, such as /users/:id |
url.path, url.query |
The page’s path and redacted query |
user.id |
Only after setUser({ id }) |
geo.country.iso_code, ezgh.rum.geo.region, geo.locality.name |
Added by EZGH from the user’s IP address: the country code (FR), the region’s name (Île-de-France) and the city. Location attributes sent by the page are replaced |
| Your attributes | From setAttributes |
Spans
Span (name) |
Kind | Starts | Ends | Children and attributes |
|---|---|---|---|---|
documentLoad |
Internal | Navigation start | The load event, then the next paint |
Phase children dns, connect, tls, request, response and domProcessing, from Navigation Timing. With trackResources, a child per resource loaded, with ezgh.rum.resource.type |
routeChange |
Internal | pushState, replaceState or popstate |
When no tracked request has been pending for 100 ms, then the next paint (at most 30 s) | ezgh.rum.route.from, ezgh.rum.route.to |
interaction |
Internal | A click, Enter or Space, or a form submit that starts a request within 100 ms, or addAction |
As routeChange |
ezgh.rum.action.name: the element’s data-ezgh-action, else its aria-label, else its tag and ID, never its text |
HTTP <method> |
Client | A fetch or XMLHttpRequest call |
The response’s end | A child of the interaction, route change or page load in progress. http.request.method, url.full (redacted), http.response.status_code, server.address. traceparent is added only for allowedTracingUrls |
Requests to the SDK’s own endpoint or tunnel aren’t tracked.
Events
Events are log records, named by their event.name attribute.
Views
An ezgh.rum.view record, severity INFO, is sent when a view ends: at the next route change,
or when the page is hidden. A view whose page is shown again and hidden again sends another.
| Attribute | Value |
|---|---|
ezgh.rum.view.duration_ms |
How long the view was shown |
ezgh.rum.view.loading_ms |
Until its documentLoad or routeChange span ended |
ezgh.rum.view.update |
0 for a view’s first event, then 1, 2, … for each one after the page is shown again |
ezgh.rum.view.final |
false while the view may send again |
ezgh.rum.vitals.lcp, .inp, .cls, .fcp, .ttfb |
The view’s latest Web Vitals, in milliseconds (CLS has no unit) |
ezgh.rum.view.errors, .requests, .long_tasks, .actions |
Counts since the view’s previous event |
Exceptions
An exception record, severity ERROR, for each uncaught error, unhandled rejection, framework
error boundary or handler, and captureException, with the trace and span IDs of the span in
progress:
| Attribute | Value |
|---|---|
exception.type, exception.message |
Such as TypeError and Cannot read properties of undefined (reading 'price') |
exception.stacktrace |
The stack trace, symbolicated by EZGH when it has the source maps |
ezgh.rum.error.source |
uncaught, unhandledrejection, boundary (a framework’s error boundary or handler) or manual (captureException) |
ezgh.rum.debug_ids |
JSON: each script in the stack and its debug ID |
ezgh.rum.breadcrumbs |
JSON: the last 50 breadcrumbs, oldest first, at most 16 KB |
ezgh.rum.error.suppressed |
How many identical errors before this one weren’t sent (the same error is sent at most 10 times a minute per page) |
ezgh.rum.fingerprint.override |
The fingerprint passed to captureException |
ezgh.rum.react.component_stack, ezgh.rum.vue.info |
From the React error boundary and Vue’s error handler |
Added by EZGH:
| Attribute | Value |
|---|---|
ezgh.rum.stacktrace.minified |
The stack trace as the browser sent it |
ezgh.rum.stacktrace.frames |
JSON: the frames, innermost first, each with function, file, line, column, inApp, scriptUrl, mapped and context (the source lines around it) |
ezgh.rum.fingerprint |
The fingerprint |
ezgh.rum.issue.id |
The issue’s ID |
ezgh.rum.symbolication |
ok (every frame of your code mapped), partial, missing (no maps) or failed |
Exceptions that plain OpenTelemetry web instrumentation records as span events (named
exception) are also stored as exception records, grouped into issues, and not billed twice.
Generated metrics
Browsers send no metrics. EZGH generates these series from the view events and errors it stores, the way it generates span metrics. They’re written every 15 seconds and are free: they aren’t counted as ingested or stored bytes. Query them with PromQL like any metric.
| PromQL name | Type | From |
|---|---|---|
ezgh_rum_vitals_lcp_milliseconds_bucket, _sum, _count |
Histogram, ms | Largest Contentful Paint of each view |
ezgh_rum_vitals_fcp_milliseconds_bucket, _sum, _count |
Histogram, ms | First Contentful Paint |
ezgh_rum_vitals_ttfb_milliseconds_bucket, _sum, _count |
Histogram, ms | Time to First Byte |
ezgh_rum_vitals_inp_milliseconds_bucket, _sum, _count |
Histogram, ms | Interaction to Next Paint |
ezgh_rum_vitals_cls_bucket, _sum, _count |
Histogram, no unit | Cumulative Layout Shift |
ezgh_rum_views_total |
Counter | Views |
ezgh_rum_errors_total |
Counter | Errors, after spike protection: dropped errors aren’t counted |
ezgh_rum_long_tasks_total |
Counter | Long tasks |
Buckets (le) include Google’s good and poor thresholds as bounds, so the share of good views
is exact:
| Vital | Bounds | Good, poor |
|---|---|---|
| LCP | 100, 250, 500, 1000, 1500, 2000, 2500, 3000, 4000, 5000, 6000, 8000, 10000, 15000, 20000 ms | ≤ 2500, > 4000 |
| FCP | 100, 250, 500, 1000, 1500, 1800, 2000, 2500, 3000, 4000, 5000, 6000, 8000, 10000, 15000, 20000 ms | ≤ 1800, > 3000 |
| TTFB | 50, 100, 200, 400, 600, 800, 1200, 1800, 2500, 4000, 8000 ms | ≤ 800, > 1800 |
| INP | 16, 32, 50, 75, 100, 150, 200, 300, 400, 500, 750, 1000, 2000, 5000 ms | ≤ 200, > 500 |
| CLS | 0.01, 0.025, 0.05, 0.1, 0.15, 0.25, 0.4, 0.6, 1, 2 | ≤ 0.1, > 0.25 |
le values are written as "2500" and "0.1", and "+Inf".
Labels:
| Label | Value |
|---|---|
view_name |
The view’s name, or __other__ past the caps below |
browser_name |
Such as Chrome; other for a value that doesn’t look like a browser name |
device_type |
desktop, mobile or tablet; other otherwise |
service_version |
The release |
environment, application |
The token’s environment and application |
- Country isn’t a label: it would multiply the series about 200 times. The Performance page’s country breakdown reads the view events instead.
view_namekeeps at most 500 names per environment and application each hour; views past that, and names over 128 bytes, are counted asview_name="__other__".- An environment has up to 20,000 RUM series, apart from its span metrics. Past that, new series
are counted with
view_name="__other__".
Each view counts once. Vitals and ezgh_rum_views_total come only from a view’s first event
(ezgh.rum.view.update 0). The counts on later events are increments since the view’s previous
event, so long tasks and errors are never counted twice. Data stored in hot placement, the
default, is counted; a beacon that arrives late counts when it arrives.
Recipes
# p75 LCP by view
histogram_quantile(0.75, sum by (le, view_name) (rate(ezgh_rum_vitals_lcp_milliseconds_bucket{application="storefront"}[5m])))
# Share of views with good LCP (2.5 s or less)
sum(rate(ezgh_rum_vitals_lcp_milliseconds_bucket{application="storefront", le="2500"}[1h]))
/ sum(rate(ezgh_rum_vitals_lcp_milliseconds_count{application="storefront"}[1h]))
# Errors per view, by view
sum by (view_name) (rate(ezgh_rum_errors_total{application="storefront"}[5m]))
/ sum by (view_name) (rate(ezgh_rum_views_total{application="storefront"}[5m]))
# p75 INP by browser
histogram_quantile(0.75, sum by (le, browser_name) (rate(ezgh_rum_vitals_inp_milliseconds_bucket{environment="production"}[1h])))Searching RUM data
Browser data is in the environment’s logs and traces, so every search works on it:
# One issue's errors
ezgh obs search --environment production --attr ezgh.rum.issue.id=adeb358d-aceb-73fa-8beb-3267aaeb30d4
# Everything one session logged (its views and errors)
ezgh obs search --environment production --attr session.id=3a342eb03b3430433c3431d63d343369
# Page loads slower than 4 seconds
ezgh obs traces search --dataset production --name documentLoad --min-duration 4s