---
title: "Data reference"
description: "Every resource and record attribute, span, view event and exception the browser SDK sends, what EZGH adds, and the generated ezgh_rum_* metrics with their buckets, labels and PromQL recipes."
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.ezghcloud.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Data reference

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](/observability/rum/configuration#name-views), such as `/users/:id` |
| `url.path`, `url.query` | The page's path and [redacted](/observability/rum/privacy#urls) 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`](/observability/rum/configuration#tracing-to-your-apis) |

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](/observability/rum/source-maps#debug-ids) |
| `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](/observability/rum/issues#how-errors-are-grouped) |
| `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](/observability/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](/observability/metrics).

| 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](/observability/rum/limits#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_name` keeps at most 500 names per environment and application each hour; views past
  that, and names over 128 bytes, are counted as `view_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

```promql
# 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:

```sh
# 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
```

IP geolocation by [DB-IP](https://db-ip.com), licensed under
[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

Source: https://docs.ezghcloud.com/observability/rum/data-reference/index.mdx
