The Experience Score rates your users' experience based on how Dynatrace classifies user events. By default, it scores user actions by their duration. Add OpenPipeline processors to align the score with how your team defines a good experience—for example, to give business-critical user actions a higher weight, classify web user actions by Core Web Vitals, or count crashes as frustrating.
The score formula is fixed, but you control everything that feeds into it through OpenPipeline processors:
experience.level field count toward the score.experience.level, either satisfied, tolerating, or frustrated.experience.weight.The default classification comes from the Experience Score calculation pre-processing in the built-in RUM Agent ingest source. Because ingest source pre-processing runs before data is routed to a pipeline, any processor that you add to a user events pipeline overrides the experience.level or experience.weight set during pre-processing. Events that your processors don't match keep their default classification.
You can't edit or duplicate the Experience Score calculation pre-processing. To change the classification, set up your own processor in a user events pipeline. Within a pipeline, processors run in order, so a processor further down the pipeline overrides the values that an earlier processor set for the same event.
To add a processor
Go to
Settings > Process and contextualize > OpenPipeline > User events > Pipelines.
Select the pipeline that processes your RUM events, or create a new one by selecting Pipeline and entering a name.
Go to Processing > Add > DQL.
Define the processor:
Weight checkout user actions.fieldsAdd statement that sets experience.level, experience.weight, or both.For ready-to-use definitions, see Examples.
Select Save.
To verify the result, run the following query in
Notebooks after new user events have been ingested. The query shows how many events each combination of level and weight applies to.
fetch user.events| filter isNotNull(experience.level)//| filter frontend.name == "FRONTEND-NAME" // Optional: filter to a specific frontend| summarize events = count(), by: {experience.level, experience.weight}
Processor changes apply only to user events ingested after you save. Existing events and sessions keep their classification.
By default, every user action has the same experience.weight, so a slow product listing and a slow payment step lower the score equally. To make a frustrating experience on a payment page lower the score more than elsewhere, give the related user actions a higher weight.
Matching condition:
characteristics.has_user_action == true and matchesValue(page.url.path, "*/checkout*")
DQL processor definition:
fieldsAdd experience.weight = 3
This processor only overrides the weight. The duration-based experience.level from the Experience Score calculation pre-processing stays as it is.
Duration alone is a coarse signal. For web frontends, you can classify user actions by Core Web Vitals instead, so that a page that loads quickly but shifts its layout or reacts slowly to input still counts as a poor experience.
Matching condition:
characteristics.has_user_action == trueand isNotNull(web_vitals.largest_contentful_paint)and isNotNull(web_vitals.cumulative_layout_shift)and isNotNull(web_vitals.interaction_to_next_paint)
DQL processor definition:
fieldsAdd experience.level = if(web_vitals.largest_contentful_paint <= 2500000000and web_vitals.cumulative_layout_shift <= 0.1and web_vitals.interaction_to_next_paint <= 200000000,"satisfied",else: if(web_vitals.largest_contentful_paint <= 4000000000and web_vitals.cumulative_layout_shift <= 0.25and web_vitals.interaction_to_next_paint <= 500000000,"tolerating",else: "frustrated"))
The matching condition requires all three Core Web Vitals, because the processor compares all of them. User actions that lack any of these values keep their default duration-based classification.
Web Vitals durations are reported in nanoseconds—for example, 2500000000 is 2.5 seconds. Adjust the thresholds to the targets that fit your frontend.
A crash terminates the application, so it's one of the most frustrating experiences a user can have. To include crashes in the score, add a processor that classifies crash events as frustrating and gives them a high weight.
Matching condition:
characteristics.has_crash == true
DQL processor definition:
fieldsAdd experience.level = "frustrated",experience.weight = 50
Each crash then counts as an additional scored event, next to the user actions of the same session and frontend. The high weight makes crashes dominate the score even when they're rare.
By default, a user action is classified only by its duration, so a fast user action whose requests fail still counts as satisfied. To treat user actions with HTTP 5xx errors as frustrating on web and mobile frontends, regardless of their duration, add a processor that reclassifies them.
Matching condition:
characteristics.has_user_action == true and error.http_5xx_count > 0
DQL processor definition:
fieldsAdd experience.level = "frustrated",experience.weight = 4
The weight of 4 makes a user action with a server error lower the score more than an ordinary slow user action, which keeps a weight of 1.
Analyze the Experience Score per frontend to spot regressions over time, or per session to find the sessions worth investigating. Run the queries below in
Notebooks.
To chart the Experience Score of each frontend over time, derive it from the dt.frontend.experience.weight metric. Add a by dimension such as browser.name, device.type, or geo.country.iso_code to find out which user segments have a worse experience.
timeseries {satisfied = sum(dt.frontend.experience.weight, filter: experience.level == "satisfied"),tolerating = sum(dt.frontend.experience.weight, filter: experience.level == "tolerating"),total = sum(dt.frontend.experience.weight)}, by: {frontend.name}//| filter frontend.name == "FRONTEND-NAME" // Optional: filter to a specific frontend| fieldsAdd experience_score = (satisfied[] + tolerating[] / 2) / total[]| fieldsRemove satisfied, tolerating, total
To find sessions below a score threshold, query experience.score on user sessions. A threshold covers several adjacent bands at once—for example, experience.score < 0.7 returns all sessions in the poor and unacceptable bands.
fetch user.sessions//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend| filter experience.score < 0.7| fields start_time, dt.rum.session.id, frontend.name, experience.score, experience.score.band| sort experience.score asc
To find sessions in a specific band, filter by experience.score.band. The band values are lowercase: excellent, good, fair, poor, and unacceptable.
fetch user.sessions//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend| filter experience.score.band == "unacceptable"| fields start_time, dt.rum.session.id, frontend.name, experience.score| sort experience.score asc
To compare how sessions are distributed across the Experience Score bands, use the following example.
fetch user.sessions//| filter in("FRONTEND-NAME", frontend.name) // Optional: filter to sessions that include a specific frontend| filter isNotNull(experience.score.band)| summarize sessions = count(), by: {experience.score.band}
To filter sessions by Experience Score without DQL, use
Users & Sessions.