Try it free

Upgrade Real User Monitoring

  • Latest Dynatrace
  • Explanation

If you already monitor your web and mobile frontends with Real User Monitoring Classic, upgrading to Real User Monitoring touches every layer of your setup, from how RUM captures and processes your data to the measurements, analysis, and operations you build on top of it. Work through this upgrade guide with its sub-pages to complete the upgrade.

Why upgrade?

Real User Monitoring (RUM) gives you capabilities that RUM Classic cannot provide.

Capture more

  • All HTTP requests: RUM captures every request with full W3C timing data. RUM Classic was selective.
  • Better single-page app coverage: Web frontends use view-based analysis to track soft navigations and virtual page transitions in SPAs, giving you accurate performance and behavior data that Classic's action-based model missed.
  • Richer mobile signals: Mobile monitoring adds ANR detection and mobile-specific vitals like app start duration for a more complete picture of native app health.
  • Early Access User interactions: RUM captures clicks, taps, scrolls, gestures, and other UI signals as a dedicated event class. RUM Classic only recorded these as part of a user action tied to a network request.

Retain and enrich data your way

  • OpenPipeline: Enrich, filter, and transform frontend data at ingest. Extract custom metrics without changing your instrumentation.
  • Preview Extended retention: Retain RUM data far beyond Classic's 35-day default, configurable up to years, enabling trend analysis, compliance, and fraud investigation.

Analyze with platform-grade tools

  • DQL: Query user events and sessions on the fly; correlate frontend behavior with backend traces, infrastructure metrics, and logs in a single query, including backends monitored with OpenTelemetry.
  • Purpose-built apps: Experience Vitals Experience Vitals, Users & Sessions Users & Sessions, and Error Inspector Error Inspector provide task-oriented workflows for performance monitoring, user complaint resolution, and error investigation.
  • Dashboards Dashboards, Notebooks Notebooks, Workflows Workflows: Use your RUM data anywhere on the Dynatrace platform without exporting or bridging data.
  • Agentic AI and MCP: RUM data stored in Grail is accessible via the Dynatrace MCP server, enabling AI agents to query user events and sessions in natural language and drive automated frontend investigations.

Govern access precisely

  • Record-level access control: Restrict data access by fields like frontend.name or dt.security_context using Grail IAM policies. RUM Classic had no equivalent fine-grained control.
  • Primary Grail tags: Segment and organize RUM data across apps, dashboards, notebooks, and workflows using primary Grail tags, a structured tagging model with no Classic equivalent for RUM.

Get up to speed on key concepts before upgrading

RUM isn't a new interface on top of RUM Classic data. It captures, stores, and queries frontend data differently. That's why your dashboards, metrics, queries, and alerts don't carry over one-to-one.

The following sections summarize the most noteworthy new concepts, each with a short note on how it differs from RUM Classic and a link to the details. Knowing these concepts before you start helps you understand what changes in each upgrade step and why.

Data model

Frontend

A frontend represents one end-user interface and carries its configuration, data grouping, and access scope. Classic called this an application. See RUM frontends.

User event

Everything RUM captures, such as page loads, requests, errors, and user interactions, is stored as a user event in the user.events table. In Classic, the user action was the central record and everything else hung off it. See RUM data model.

Characteristics

Every event carries characteristics fields that describe what it contains, for example, a navigation, a request, an error, or a user interaction. One event can have several characteristics at once, so you find the events you need by filtering on these fields rather than on a single event type. See RUM data model.

User action

A user action represents a significant frontend operation and its downstream effects. It starts with a trigger, such as a user interaction, a page load or navigation, an app start, or a call to the Dynatrace API, and covers the requests and other events that result from it. Those events stay separate but remain linked to their user action, so to see everything an action caused, you bring the action and its related events together in your analysis. See RUM data model.

User session

Sessions land in the user.sessions table with no cap on the events they hold. Classic split a session after 200 user actions, so expect your RUM session counts to differ from your Classic counts. See RUM data model.

Event and session properties

Custom key-value pairs enrich events and sessions with business context. These properties have their own configuration and don't inherit the Classic one. See RUM data model.

Pages, views, and navigations

Web A page covers one document lifecycle, from one full page load to the next, and a view covers the content between two navigations. Each soft navigation in a single-page app starts a new view with its own summary, and the page summary covers all views of that document. Classic recognized only full page navigations. See Pages, views, and navigations.

Views, navigations, and app starts

Mobile Each visit to a screen is a view with its own summary, and transitions between views are navigation events. App starts are classified as cold, warm, or hot. Classic surfaced all three as autogenerated Loading … actions. See Concepts for mobile frontends.

Instrumentation and infrastructure

Side-by-side operation

RUM runs alongside Classic, which has to stay active, and your frontends send both beacon formats to the same endpoint. Most settings are shared, so a change on one side shows up on the other. See Upgrade data capturing.

W3C trace context

Frontend-backend linking relies on the traceparent and tracestate headers. Classic used x-dtc and x-dynatrace, so you need new pass-through and CORS rules. See Frontend-backend linking.

Queries

Grail tables and DQL

You query user.events and user.sessions with DQL, and a single query can join frontend data with traces, logs, and metrics. USQL works only with Classic, so you need to rebuild every USQL query in DQL. See Dynatrace Query Language, Monitor web performance with DQL, and Analyze user behavior with DQL.

Built-in metrics and metric extraction

RUM ships built-in metrics under the dt.frontend prefix. Classic built-in metrics have functional replacements rather than one-to-one equivalents, see Built-in RUM metrics and Upgrade from classic RUM metrics to Grail. For custom metrics, you set up extraction from user events or user sessions in OpenPipeline.

Buckets and retention

A bucket sets the retention, storage tier, and query scope for the RUM data you route into it. Classic came with a fixed session retention you couldn't change. See Manage buckets for RUM.

Record-level permissions

Grail IAM policies grant read access record by record, based on values the records carry, such as which frontend the data came from. Classic had no comparable fine-grained control, and management zones were the closest equivalent. See RUM permissions and Segments.

Analysis

Purpose-built apps

Experience Vitals Experience Vitals, Users & Sessions Users & Sessions, and Error Inspector Error Inspector each cover one job: frontend health, session analysis, and error investigation. All three cover web and mobile frontends together, and you can take any analysis further in Notebooks Notebooks or Dashboards Dashboards.

Health alerts

Health alerts watch key frontend metrics and raise problems from anomalies, and you choose the anomaly detection analyzer per alert. Classic relied on application-level problem detection sensitivity. See Health alerts for frontends.

The rest of the platform

Dashboards Dashboards, Notebooks Notebooks, Workflows Workflows, Davis, and the Dynatrace MCP server read the RUM tables directly. Classic data needed an export or the REST API to be used anywhere else. See Analyze and alert with RUM.

Before you begin

Make sure that you meet the prerequisites, check which of your frontends are in scope, and assess how ready your RUM Classic setup is for the upgrade.

Prerequisites

Before starting the upgrade, ensure the following are in place.

DPS license

RUM requires a Dynatrace Platform Subscription (DPS) license. If you are on a Classic license, contact your Dynatrace account team before proceeding.

When upgrading an existing frontend to RUM, Dynatrace protects you from double billing—Dynatrace charges you for ingested user sessions based on Dynatrace Classic and for the maximum number of properties configured in either Dynatrace Classic or Latest Dynatrace, not the sum of both.

Permissions

Permission areaWhat you need
SettingsWrite access to builtin:rum* schemas to configure frontends and instrumentation. Also builtin:health-experience.frontend-alert to manage health alerts.
Data accessstorage:user.events:read, storage:user.sessions:read, storage:metrics:read, storage:smartscape:read
App accessapp-engine:apps:run for Experience Vitals Experience Vitals, Users & Sessions Users & Sessions, and Error Inspector Error Inspector

For a complete permissions reference, see RUM permissions.

Scope

You don't have to upgrade all your frontends at once. You can enable RUM on individual frontends and upgrade the rest at your own pace.

This upgrade guide covers the following frontend types:

Frontend typeCoverage
Web frontendsFully covered: browser-based monitoring via RUM JavaScript auto-injected by OneAgent or instrumented via manual insertion.
Mobile: Android, iOS, React Native, Flutter, .NET MAUIFully covered: native monitoring via the bundled RUM library for each platform.

Currently unsupported and out-of-scope cases

The following are not covered by this upgrade guide. If your setup includes them, do not proceed with the upgrade for those frontends.

  • Custom Applications: This frontend type is currently not supported on Latest Dynatrace. Continue monitoring these frontends with RUM Classic.
  • Cordova: This framework is currently not supported on Latest Dynatrace. Continue monitoring these frontends with RUM Classic.

For all unsupported cases, contact your Dynatrace account team for roadmap guidance.

Check your upgrade readiness

Before starting, use the Check your upgrade readiness dashboard to inventory your existing RUM Classic setup (frontends, instrumentation, settings, and agent versions) and identify any scope covered by the unsupported cases above. To open the dashboard, go to Dashboards Dashboards > All dashboards > Ready-made and select Check your upgrade readiness.

Upgrade your RUM setup

Follow the steps below to upgrade your RUM setup.

01Upgrade data capturing
  • How-to guide
  • Learn how to upgrade data capturing when you move from RUM Classic to RUM, and which infrastructure requirements to take care of.
02Upgrade data processing
  • How-to guide
  • Learn how to migrate user action naming, page naming, custom metrics, error detection, and symbolication when you upgrade from RUM Classic to RUM.
03Upgrade your permissions and segmentation configuration
  • How-to guide
  • Learn how to upgrade your permissions and segmentation configuration when you move from RUM Classic to RUM.
04Recreate measurements, analysis, and operations
  • How-to guide
  • Learn how to recreate your measurements, analysis, alerting, and data export workflows in RUM after you move from RUM Classic.

Related topics

  • Upgrade to Latest Dynatrace
Related tags
Digital Experience