Curso: Métricas de Dynatrace SaaS · Módulo 4/7 — métricas RUM de Grail y monitorización sintética · Formato: fichas de referencia · Plataforma: Dynatrace SaaS (Grail, DQL)
En este módulo: 21 claves (13 dt.frontend.*, 8 dt.synthetic.*), dos tablas resumen y una ficha por métrica con su consulta DQL.
Cuarto módulo del curso de métricas de Dynatrace SaaS: las métricas RUM de Grail de los frontends (dt.frontend.*) y las de la monitorización sintética (dt.synthetic.*). Cada ficha da la unidad, las dimensiones, un caso de uso y una consulta DQL.
Los módulos anteriores miraban los servidores; este mira al usuario. El RUM mide lo que viven los visitantes reales, y lo sintético reproduce recorridos a intervalo fijo, incluso de noche cuando nadie navega. Juntos dan la visión de extremo a extremo que les falta a las métricas de servicio.
El contenido vale para Dynatrace SaaS con el nuevo RUM. Las claves builtin:apps.* de RUM Classic no existen en Grail; Dynatrace Managed las sigue usando, con el metric selector. Para la puesta en marcha, consulta RUM y Core Web Vitals y la monitorización sintética HTTP y de navegador.
Métricas RUM de Grail: la tabla de los frontends
Trece claves dt.frontend.*, todas producidas por el nuevo RUM en Grail. Las unidades y dimensiones proceden de la página Built-in RUM metrics; solo se listan las dimensiones más útiles, y dt.rum.application.entity, os.name y dt.rum.user_type también están disponibles.
| Clave | Unidad | Dimensiones principales | Qué mide |
|---|---|---|---|
dt.frontend.user_action.count |
número | frontend.name, device.type, browser.name, geo.country.iso_code |
Acciones de usuario |
dt.frontend.user_action.duration |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Duración de las acciones de usuario |
dt.frontend.request.count |
número | frontend.name, url.provider, http.response.status_code_class |
Solicitudes emitidas por el frontend |
dt.frontend.request.duration |
ms | frontend.name, url.provider, http.response.status_code_class |
Duración de las solicitudes del frontend |
dt.frontend.error.count |
número | frontend.name, error.type, app.short_version |
Errores del frontend |
dt.frontend.session.active.estimated_count |
número | frontend.name, device.type, browser.name, geo.country.iso_code |
Sesiones activas (estimación) |
dt.frontend.user.active.estimated_count |
número | frontend.name, device.type, browser.name, geo.country.iso_code |
Usuarios únicos activos (estimación) |
dt.frontend.web.page.largest_contentful_paint |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Largest Contentful Paint (LCP) |
dt.frontend.web.page.interaction_to_next_paint |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Interaction to Next Paint (INP) |
dt.frontend.web.page.cumulative_layout_shift |
sin unidad (×10 000) | frontend.name, device.type, browser.name, geo.country.iso_code |
Cumulative Layout Shift (CLS) |
dt.frontend.web.navigation.time_to_first_byte |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Time to First Byte (navegación) |
dt.frontend.web.navigation.load_event_end |
ms | frontend.name, device.type, browser.name, geo.country.iso_code |
Fin del evento load (W3C) |
dt.frontend.mobile.app_start.duration |
ms | frontend.name, app_start.type, os.name, app.short_version |
Duración del arranque de la aplicación móvil |

Fichas RUM: lo que vive el usuario
Mismo orden en cada ficha: utilidad, caso de uso, trampa eventual, consulta DQL. Los umbrales los fijas tú con tu historial.
dt.frontend.user_action.count
Utilidad: el tráfico visto desde el navegador o la aplicación móvil, antes de cualquier llamada al servidor.
Caso de uso: una caída brusca de las acciones en un frontend mientras los servicios responden con normalidad apunta al CDN, al DNS o a un error de JavaScript bloqueante.
Trampa: RUM en Grail no tiene el mismo modelo de datos que RUM Classic: la documentación advierte de que los valores difieren de builtin:apps.web.actionCount.*.
timeseries actions = sum(dt.frontend.user_action.count), by: {frontend.name}
dt.frontend.user_action.duration
Utilidad: la latencia percibida por el usuario, red y renderizado incluidos.
Caso de uso: seguir el percentil 90 por tipo de dispositivo: una diferencia entre móvil y ordenador suele revelar un peso de página excesivo.
timeseries p90 = percentile(dt.frontend.user_action.duration, 90),
by: {frontend.name, device.type}
dt.frontend.request.count
Utilidad: el denominador de la tasa de errores de las llamadas XHR y fetch.
Caso de uso: separar las llamadas a tus API de las llamadas a terceros gracias a url.provider.
timeseries req = sum(dt.frontend.request.count),
by: {frontend.name, http.response.status_code_class}
dt.frontend.request.duration
Utilidad: la latencia de las API tal como la vive el cliente, red incluida.
Caso de uso: comparada con dt.service.request.response_time (módulo 3), aísla la parte de la red y del CDN.
Trampa: unidades distintas: milisegundos aquí, microsegundos en el lado del servicio.
timeseries p75 = percentile(dt.frontend.request.duration, 75), by: {url.provider}
dt.frontend.error.count
Utilidad: sustituye ella sola a las claves Classic de errores de JavaScript, cierres inesperados y errores de solicitudes.
Caso de uso: tras una puesta en producción, comparar los errores por app.short_version para decidir un rollback.
timeseries errors = sum(dt.frontend.error.count),
by: {frontend.name, error.type, app.short_version}
dt.frontend.session.active.estimated_count
Utilidad: la carga real de un frontend, útil para leer las demás métricas en proporción.
Caso de uso: relacionar el número de errores con el número de sesiones para comparar dos frontends de tamaños distintos.
Trampa: es una estimación probabilística (algoritmo UltraLogLog según la documentación): no la uses como un recuento exacto para la facturación.
timeseries sessions = max(dt.frontend.session.active.estimated_count), by: {frontend.name}
dt.frontend.user.active.estimated_count
Utilidad: mide la audiencia afectada, lo que da el peso de un incidente.
Caso de uso: durante un incidente, estimar cuántos usuarios de un país o de un navegador están expuestos.
Trampa: sumar las series de varias dimensiones cuenta dos veces a un mismo usuario: estima en el nivel que necesites.
timeseries users = max(dt.frontend.user.active.estimated_count),
by: {frontend.name, geo.country.iso_code}
dt.frontend.web.page.largest_contentful_paint
Utilidad: la Core Web Vital de la carga: cuándo se hace visible el contenido principal.
Caso de uso: seguir el percentil 75 por frontend, la estadística que se suele usar para las Core Web Vitals, y compararlo con tu objetivo.
timeseries lcp = percentile(dt.frontend.web.page.largest_contentful_paint, 75),
by: {frontend.name}
dt.frontend.web.page.interaction_to_next_paint
Utilidad: la capacidad de respuesta de la página tras un clic o una entrada de texto.
Caso de uso: un INP que empeora tras añadir un script de terceros se lee por navegador y por tipo de dispositivo.
Trampa: dt.frontend.web.page.first_input_delay todavía existe, pero INP lo ha sustituido entre las Core Web Vitals: prefiere INP para los dashboards nuevos.
timeseries inp = percentile(dt.frontend.web.page.interaction_to_next_paint, 75),
by: {frontend.name, device.type}
dt.frontend.web.page.cumulative_layout_shift
Utilidad: la estabilidad visual: los elementos que se mueven durante la carga.
Caso de uso: tras cambiar un banner publicitario o una tipografía, comprobar que el CLS no se ha disparado.
Trampa: el valor se almacena multiplicado por 10 000: multiplica por 0,0001 para recuperar la puntuación entre 0 y 1, como indica la documentación.
timeseries cls = percentile(dt.frontend.web.page.cumulative_layout_shift, 75),
by: {frontend.name}
| fieldsAdd cls_score = cls[] * 0.0001
dt.frontend.web.navigation.time_to_first_byte
Utilidad: la parte de servidor y de red en la carga de una página.
Caso de uso: un TTFB que sube con un LCP estable señala el back-end o el CDN más que el renderizado.
timeseries ttfb = percentile(dt.frontend.web.navigation.time_to_first_byte, 75),
by: {frontend.name, geo.country.iso_code}
dt.frontend.web.navigation.load_event_end
Utilidad: el hito de carga completa, que da continuidad con los dashboards antiguos.
Caso de uso: seguir la tendencia mes a mes de un frontend, como complemento del LCP.
timeseries load = avg(dt.frontend.web.navigation.load_event_end),
by: {frontend.name}, interval: 1d, from: -30d
dt.frontend.mobile.app_start.duration
Utilidad: el primer contacto del usuario con la aplicación.
Caso de uso: comparar los arranques por app_start.type y por versión para detectar una regresión en una versión nueva.
Trampa: el recuento asociado es dt.frontend.mobile.app_start.count; lee siempre la duración junto con el volumen.
timeseries start = percentile(dt.frontend.mobile.app_start.duration, 90),
by: {app_start.type, app.short_version}
La tabla de la monitorización sintética
Ocho claves dt.synthetic.* para los monitores HTTP y de navegador. Los monitores de red (dt.synthetic.multi_protocol.*) y de terceros (dt.synthetic.third_party.*) también existen en Grail; quedan fuera del perímetro de esta selección.
| Clave | Unidad | Dimensiones principales | Qué mide |
|---|---|---|---|
dt.synthetic.http.availability |
% | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Tasa de disponibilidad de un monitor HTTP |
dt.synthetic.http.duration |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Duración acumulada de las solicitudes del monitor |
dt.synthetic.http.executions |
número | dt.entity.http_check, result.state, result.status.code |
Ejecuciones del monitor, por estado |
dt.synthetic.http.time_to_first_byte |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Tiempo hasta el primer byte |
dt.synthetic.http.tls_handshake_time |
ms | dt.entity.http_check, dt.entity.synthetic_location, step.name |
Duración de la negociación TLS |
dt.synthetic.browser.availability |
% | dt.entity.synthetic_test, dt.entity.synthetic_location, step.name |
Tasa de disponibilidad de un monitor de navegador |
dt.synthetic.browser.duration |
ms | dt.entity.synthetic_test, dt.entity.synthetic_location, step.name |
Duración del monitor de navegador (suma de los pasos) |
dt.synthetic.browser.executions |
número | dt.entity.synthetic_test, result.state, result.status.code |
Ejecuciones del monitor de navegador, por estado |
Fichas sintéticas: medir sin esperar al usuario
dt.synthetic.http.availability
Utilidad: el SLI de disponibilidad más sencillo, medido desde fuera e independiente del tráfico real.
Caso de uso: ordenar los monitores del menos al más disponible, como en el ejemplo de la documentación.
Trampa: no hay equivalente Classic directo (N/A en la tabla de correspondencia): un SLO migrado debe recalcularse.
timeseries avail = avg(dt.synthetic.http.availability), by: {dt.entity.http_check}
| fieldsAdd monitor = entityName(dt.entity.http_check)
| sort arrayAvg(avail) asc
dt.synthetic.http.duration
Utilidad: el tiempo de respuesta de extremo a extremo de un recorrido de API.
Caso de uso: comparar la duración entre ubicaciones: una sola ubicación lenta apunta a la red, todas lentas apuntan a la aplicación.
timeseries d = avg(dt.synthetic.http.duration),
by: {dt.entity.http_check, dt.entity.synthetic_location}
dt.synthetic.http.executions
Utilidad: dice por qué falla un monitor, no solo que falla.
Caso de uso: repartir los fallos por result.status.code para distinguir un timeout de una respuesta HTTP inesperada.
timeseries runs = sum(dt.synthetic.http.executions),
by: {dt.entity.http_check, result.state, result.status.code}
dt.synthetic.http.time_to_first_byte
Utilidad: aísla el tiempo de procesamiento del lado del servidor dentro de la duración total.
Caso de uso: si la duración sube pero el TTFB no, mira la descarga o las redirecciones.
timeseries ttfb = avg(dt.synthetic.http.time_to_first_byte), by: {dt.entity.http_check}
dt.synthetic.http.tls_handshake_time
Utilidad: señala un problema de certificado, de cadena o de terminación TLS.
Caso de uso: un salto tras renovar un certificado o cambiar de balanceador se ve de inmediato.
timeseries tls = avg(dt.synthetic.http.tls_handshake_time),
by: {dt.entity.http_check, dt.entity.synthetic_location}
dt.synthetic.browser.availability
Utilidad: la disponibilidad de un recorrido completo (inicio de sesión, carrito, pago) tal como lo haría un usuario.
Caso de uso: SLO de disponibilidad de un recorrido crítico, con una alerta sobre el presupuesto de error.
timeseries avail = avg(dt.synthetic.browser.availability), by: {dt.entity.synthetic_test}
| fieldsAdd monitor = entityName(dt.entity.synthetic_test)
| sort arrayAvg(avail) asc
dt.synthetic.browser.duration
Utilidad: el rendimiento de un recorrido con guion, estable de una ejecución a otra.
Caso de uso: para encontrar el paso lento, baja a dt.synthetic.browser.step.duration por step.name.
timeseries d = avg(dt.synthetic.browser.duration), by: {dt.entity.synthetic_test}
dt.synthetic.browser.executions
Utilidad: cuenta los éxitos y los fallos, con el código de resultado.
Caso de uso: comprobar que un monitor se ejecuta con la frecuencia prevista: un hueco en la serie es una ausencia de medición, no un éxito.
Trampa: la dimensión maintenance_window solo existe en Synthetic Classic; en Grail, usa dt.maintenance_window_ids para descartar las ventanas de mantenimiento.
timeseries runs = sum(dt.synthetic.browser.executions, default: 0),
by: {dt.entity.synthetic_test, result.state}
Cómo comprobar que funciona
- En un notebook, ejecuta
timeseries sum(dt.frontend.user_action.count), by: {frontend.name}: debe aparecer cada frontend instrumentado con el nuevo RUM. - Si no sale nada aunque la aplicación esté monitorizada, probablemente sigue en RUM Classic: sus métricas permanecen bajo
builtin:apps.*, fuera de Grail. - Para lo sintético, ejecuta
timeseries avg(dt.synthetic.http.availability), by: {dt.entity.http_check}y compara con la pantalla del monitor en la aplicación Synthetic. - Comprueba la unidad antes de cada umbral: milisegundos para el RUM y lo sintético, ×10 000 para el CLS.
Buenas prácticas
- Lee las Core Web Vitals en el percentil 75, no en media.
- Asocia cada duración a su volumen (acciones, sesiones, ejecuciones) antes de concluir.
- Mantén un monitor sintético en cada recorrido crítico: alerta incluso sin tráfico.
Para ir más lejos: alertas de burn rate sobre los SLO transforma una disponibilidad sintética en una alerta sobre el presupuesto de error. Fuentes: Built-in RUM metrics, HTTP monitor metrics y Browser monitor metrics.
← Módulo 3: métricas de servicio en Grail · Índice del curso · Módulo 5: métricas de Kubernetes en Grail →
Preguntas frecuentes
¿Dónde han ido a parar las métricas builtin:apps de RUM Classic?
No son compatibles con Grail. La página de migración de RUM propone sustitutos con un papel análogo, por ejemplo dt.frontend.user_action.count para builtin:apps.web.actionCount.*, con valores que pueden diferir.
¿Dónde está el Apdex?
Ninguna clave Apdex figura en la lista de métricas RUM integradas ni en la tabla de correspondencia. Sigue más bien los percentiles de duración y las Core Web Vitals.
¿RUM o sintético para un SLO de disponibilidad?
Lo sintético da una medición regular, incluso sin tráfico; el RUM refleja la experiencia real pero depende del volumen. Muchos equipos usan lo sintético para el SLO y el RUM para el diagnóstico.
Estas veintiuna claves cubren la experiencia vista por el usuario, real o simulada. El módulo siguiente vuelve a bajar a la infraestructura de aplicación: procesos, runtimes, contenedores y Kubernetes.
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Este módulo es una selección comentada, no la lista oficial: las claves, unidades y dimensiones se han tomado de la documentación pública de Dynatrace SaaS y pueden cambiar; compruébalas en el navegador de métricas de tu entorno.