Módulo 3 — Servicios: 20 métricas de servicio builtin de Dynatrace Managed

Métricas de servicio builtin de Dynatrace Managed: 20 claves builtin:service para tráfico, latencia, errores, key requests y bases de datos.
Module 3 — Services : 20 métriques service builtin de Dynatrace Managed

Módulo 3 del curso de métricas de Dynatrace Managed: 20 métricas de servicio builtin (claves builtin:service.*) para seguir el tráfico, la latencia, los errores, las key requests y las llamadas a bases de datos, con una consulta de metric selector por ficha.

Curso: Formación en métricas de Dynatrace Managed · Módulo 3/7 · Dominio: servicios, peticiones, bases de datos · Plataforma: Dynatrace Managed (Metrics API v2, metric selector)

Los usuarios no ven un host, ven un servicio que responde despacio o con errores. Las métricas de servicio llevan, por tanto, las señales de oro: tráfico, latencia, errores y una parte de la saturación a través de los tiempos pasados en la base de datos o en espera. Son ellas las que alimentan la mayoría de los SLO.

El módulo 2 cubrió los hosts; este módulo sube un escalón. Todas las fichas siguen el mismo esquema: medida, uso, trampa, consulta.

El contenido vale para Dynatrace Managed y para las métricas clásicas de Dynatrace SaaS. En Grail, las claves pasan a ser dt.service.* y se consultan con DQL.

Servicios: la tabla resumen

Fuente: página Built-in metrics de la documentación de Managed. La dimensión principal es dt.entity.service; las métricas keyRequest se desglosan por key request (dt.entity.service_method). Punto de atención: los tiempos están en microsegundos.

Clave Unidad Agregaciones Qué mide
builtin:service.requestCount.total Count value Peticiones recibidas
builtin:service.requestCount.server Count value Peticiones medidas en el servidor
builtin:service.response.time Microsegundo avg, count, max, median, min, percentile, sum Tiempo de respuesta
builtin:service.response.server Microsegundo avg, count, max, median, min, percentile, sum Tiempo de respuesta en el servidor
builtin:service.errors.total.count Count value Peticiones fallidas (todas)
builtin:service.errors.total.rate % avg Tasa de fallos (todos)
builtin:service.errors.server.count Count value Fallos en el servidor
builtin:service.errors.server.rate % avg Tasa de fallos en el servidor
builtin:service.errors.fivexx.count Count value Respuestas HTTP 5xx
builtin:service.errors.fourxx.count Count value Respuestas HTTP 4xx
builtin:service.successes.server.rate % avg Tasa de éxito en el servidor
builtin:service.cpu.time Microsegundo value CPU consumida por el servicio
builtin:service.cpu.perRequest Microsegundo avg, count, max, min, sum CPU por petición
builtin:service.dbChildCallCount Count value Llamadas a bases de datos
builtin:service.dbChildCallTime Microsegundo value Tiempo pasado en la base de datos
builtin:service.nonDbChildCallCount Count value Llamadas a otros servicios
builtin:service.dbconnections.failureRate % value Fallos de conexión a la base de datos
builtin:service.keyRequest.response.time Microsegundo avg, count, max, median, min, percentile, sum Tiempo de respuesta de una key request
builtin:service.keyRequest.count.total Count value Volumen de una key request
builtin:service.keyRequest.errors.server.rate % avg Tasa de fallos de una key request
Extracto de la página Built-in metrics de la documentación de Dynatrace Managed: claves builtin:service.requestCount.total, response.time, errors.server.rate, cpu.time, dbChildCallTime, keyRequest.response.time y dbconnections.failureRate con unidad y agregaciones

Tráfico y latencia: las métricas de servicio builtin de base

builtin:service.requestCount.total

El número de peticiones recibidas por el servicio; la documentación precisa que acepta los desgloses de servicio (splittings). Es la señal de tráfico. Una caída brusca merece tanta atención como un aumento de errores: a menudo delata un problema aguas arriba.

builtin:service.requestCount.total:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)

builtin:service.requestCount.server

El mismo recuento, medido solo en el servidor. Sirve de denominador coherente al calcular una tasa a partir de los errores del lado servidor.

builtin:service.requestCount.server:splitBy("dt.entity.service")

builtin:service.response.time

El tiempo que tarda el servicio en devolver su respuesta, en microsegundos. Prefiere un percentil a la media: un p90 describe la experiencia de la mayoría sin quedar aplastado por unas pocas peticiones muy rápidas. Divide entre 1 000 para leer milisegundos.

builtin:service.response.time:splitBy("dt.entity.service"):percentile(90):sort(value(max,descending)):limit(10)

builtin:service.response.server

El tiempo de respuesta en el servidor, sin la parte medida en el cliente que llama. La diferencia entre ambos revela un tiempo de red o de cola en el llamante.

builtin:service.response.server:splitBy("dt.entity.service"):median

Errores y éxitos

builtin:service.errors.total.count

Las peticiones fallidas, medidas en el servidor o en el cliente. Lo que cuenta como fallo depende de la detección de fallos configurada para el servicio: verifica ese ajuste antes de construir un SLO sobre ella.

builtin:service.errors.total.count:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)

builtin:service.errors.total.rate

La tasa de fallos con todos los errores juntos, en porcentaje, con la única agregación avg. Práctica para un dashboard; para un SLO, calcula mejor el ratio tú mismo para controlar el denominador.

builtin:service.errors.total.rate:splitBy("dt.entity.service"):avg

builtin:service.errors.server.count

Los fallos medidos en el servidor. Es el contador que conviene priorizar para un indicador de fiabilidad del propio servicio, independientemente de sus clientes.

builtin:service.errors.server.count:splitBy("dt.entity.service")

builtin:service.errors.server.rate

La tasa de fallos en el servidor. Un aumento repentino tras un despliegue es el caso de uso típico de un evento de métrica o de una alerta de burn rate.

builtin:service.errors.server.rate:splitBy("dt.entity.service"):avg:sort(value(avg,descending)):limit(10)

builtin:service.errors.fivexx.count

Las respuestas HTTP cuyo código está entre 500 y 599. Señalan un fallo del servicio o de una de sus dependencias.

builtin:service.errors.fivexx.count:splitBy("dt.entity.service")

builtin:service.errors.fourxx.count

Las respuestas HTTP 4xx. Trampa clásica: un pico de 404 o de 401 suele venir de un cliente mal configurado, no del servicio. No lo integres tal cual en un presupuesto de error.

builtin:service.errors.fourxx.count:splitBy("dt.entity.service")

builtin:service.successes.server.rate

La tasa de éxito en el servidor, en porcentaje. Es la forma más directa de un SLI de disponibilidad; el artículo sobre los SLO en Dynatrace Managed muestra cómo usarla.

builtin:service.successes.server.rate:splitBy("dt.entity.service"):avg

Consumo y dependencias

builtin:service.cpu.time

El tiempo de CPU consumido por el servicio, en microsegundos. Permite relacionar un aumento de CPU en el host con un servicio concreto y comparar dos versiones de un mismo código.

builtin:service.cpu.time:splitBy("dt.entity.service"):sort(value(sum,descending)):limit(10)

builtin:service.cpu.perRequest

La CPU consumida por petición. A diferencia del total, no sube con el tráfico: un aumento señala una petición que se ha vuelto más costosa, a menudo tras un cambio de código.

builtin:service.cpu.perRequest:splitBy("dt.entity.service"):avg

builtin:service.dbChildCallCount

El número de llamadas a bases de datos que hace el servicio. Un ratio llamadas/petición que se dispara delata el patrón N+1, frecuente con los ORM.

builtin:service.dbChildCallCount:splitBy("dt.entity.service") / builtin:service.requestCount.total:splitBy("dt.entity.service")

builtin:service.dbChildCallTime

El tiempo pasado en las llamadas a bases de datos, en microsegundos. Comparado con el tiempo de respuesta, dice si la lentitud viene de la base de datos o del código del servicio.

builtin:service.dbChildCallTime:splitBy("dt.entity.service")

builtin:service.nonDbChildCallCount

El número de llamadas a otros servicios; nonDbChildCallTime da el tiempo correspondiente. Un aumento de ese tiempo orienta el análisis hacia una dependencia aguas abajo. En la misma familia, builtin:service.ioTime, lockTime y waitTime (microsegundos) detallan los tiempos de entrada/salida, de bloqueo y de espera.

builtin:service.nonDbChildCallCount:splitBy("dt.entity.service")

builtin:service.dbconnections.failureRate

La tasa de intentos de conexión a una base de datos que fallan, respecto a todos los intentos. Un pool saturado o una base inalcanzable se ven aquí antes que los errores de aplicación.

builtin:service.dbconnections.failureRate:splitBy("dt.entity.service")

Key requests

Una key request es un punto de entrada que marcas como crítico (pago, inicio de sesión). Dynatrace escribe entonces métricas dedicadas para cada una.

builtin:service.keyRequest.response.time

El tiempo de respuesta de una key request, en microsegundos. Es la granularidad adecuada para un SLO de latencia sobre un recorrido de negocio: evita que peticiones secundarias diluyan la señal.

builtin:service.keyRequest.response.time:splitBy("dt.entity.service_method"):percentile(95)

builtin:service.keyRequest.count.total

El número de peticiones de una key request. Sirve de denominador a los SLO y de señal de negocio: aquí se ve una caída del volumen de pagos.

builtin:service.keyRequest.count.total:splitBy("dt.entity.service_method")

builtin:service.keyRequest.errors.server.rate

La tasa de fallos en el servidor de una key request. Junto con el tiempo de respuesta, cubre los dos SLI más usados en un punto de entrada crítico.

builtin:service.keyRequest.errors.server.rate:splitBy("dt.entity.service_method"):avg

Cómo comprobar que funciona

  1. Lista las claves de servicio disponibles:
    curl -s "$DT_URL/api/v2/metrics?metricSelector=builtin:service.*&fields=unit,aggregationTypes" \
      -H "Authorization: Api-Token $DT_TOKEN"
  2. Ejecuta una consulta del módulo:
    curl -s -G "$DT_URL/api/v2/metrics/query" \
      --data-urlencode 'metricSelector=builtin:service.response.time:splitBy("dt.entity.service"):percentile(90)' \
      --data-urlencode 'from=now-2h' \
      -H "Authorization: Api-Token $DT_TOKEN"
  3. Compara un valor con el gráfico de la página del servicio: al dividir entre 1 000, los microsegundos deben corresponder a los milisegundos mostrados.

Las métricas keyRequest no devuelven nada mientras ninguna petición esté marcada como clave. La sintaxis del metric selector se detalla en el módulo de metric selector y API.

Buenas prácticas

  • Lee los tiempos en microsegundos y conviértelos antes de compararlos con un objetivo en milisegundos.
  • Usa un percentil para la latencia y un ratio éxitos/total para la disponibilidad.
  • Separa 4xx y 5xx: solo los segundos reflejan, en general, la fiabilidad del servicio.
  • Marca tus recorridos críticos como key requests para obtener métricas con la granularidad adecuada.

Preguntas frecuentes

¿Qué diferencia hay entre errors.total y errors.server?

La primera cuenta los fallos medidos en el servidor o en el cliente; la segunda, solo en el servidor. Para juzgar el servicio en sí, parte del lado servidor.

¿Dónde están las bases de datos en este módulo?

Vistas desde el servicio que llama: llamadas, tiempos y fallos de conexión. Las métricas internas de un motor de base de datos dependen de las extensiones (módulo 6).

¿Existen estas claves en Grail?

Existen equivalentes dt.service.* en Dynatrace SaaS con Grail, con nombres y unidades a veces distintos; el curso de métricas de SaaS los trata.

Con los hosts y los servicios ya tienes los dos escalones del lado servidor. El módulo siguiente pasa al lado de los usuarios: aplicaciones web y móviles, Apdex y monitores sintéticos.

← Módulo 2: hosts · Índice del curso · Módulo 4: aplicaciones →

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Las claves y unidades citadas proceden de la documentación oficial de Dynatrace Managed; compruébalas en la versión de tu clúster.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Module 3 — Métriques de service Grail : requêtes, messagerie et service mesh dt.service.*

Módulo 3 — Métricas de servicio de Grail: solicitudes, mensajería y service mesh dt.service.*

Next Post
Module 4 — Applications : les métriques application builtin, RUM web, mobile et synthétique

Módulo 4 — Aplicaciones: las métricas de aplicación builtin, RUM web, móvil y sintético

Related Posts