Cómo calcular throughput por servicio en Real-Time Analytics

João Barros 16 de October de 2026 4 min de lectura

Vamos a calcular el throughput (eventos por segundo) por servicio en Real-Time Analytics para monitorizar capacidad y detectar picos. Este ejemplo muestra cómo agregar eventos en ventanas de tiempo fijas y normalizar por segundo, útil para dashboards y alertas de escalabilidad.

Pre-requisitos

Cuenta con acceso a una instancia de Real-Time Analytics (ej.: Azure Data Explorer/Kusto o servicio compatible).
Fuente de eventos con timestamp y campo service_name (p. ej. telemetría, logs o eventos de API).
Conocimientos básicos de KQL/consulta y acceso a la tabla de eventos.

Paso 1: Entender el objetivo y formato de los datos

Queremos una métrica: eventos por segundo por servicio a lo largo del tiempo. Los datos deben tener al menos un timestamp (p. ej. timestamp, EventTime) y un identificador del servicio (service_name). Verifique el formato y la zona horaria del timestamp para evitar valores incorrectos.

Paso 2: Contar eventos por ventana fija (ejemplo 1 segundo)

Usamos ventanas de 1 segundo para obtener el throughput por segundo. En muchos sistemas, usar ventanas muy pequeñas puede generar ruido; elija 1s, 5s o 10s según necesidad. Abajo un ejemplo en KQL que agrega por ventana de 1s y por service_name.

EventsTable
| where EventTime >= ago(10m)
| summarize events_count = count() by bin(EventTime, 1s), service_name
| order by EventTime asc

Paso 3: Normalizar para obtener eventos por segundo cuando la ventana sea mayor

Si prefiere ventanas de 10s para suavizar la variación, divida el recuento por la duración de la ventana para obtener eventos/segundo. Esto evita picos falsos y hace las comparaciones más estables.

let window = 10s;
EventsTable
| where EventTime >= ago(30m)
| summarize events_count = count() by bin(EventTime, window), service_name
| extend events_per_second = todouble(events_count) / todouble(tolong(window) / 1s)
| order by EventTime asc

Paso 4: Tratar periodos con ausencia de eventos (rellenar ceros)

Si un servicio no genera eventos en una ventana, se desea ver 0 en lugar de ausencia de fila. Use make-series o join con una serie temporal. make-series rellena automáticamente con 0 cuando se usa count().

EventsTable
| where EventTime >= ago(30m)
| make-series events_count = count() on EventTime from ago(30m) to now() step 10s by service_name
| mv-expand EventTime to typeof(datetime), events_count to typeof(long)
| extend events_per_second = todouble(events_count) / 10.0
| order by EventTime asc

Paso 5: Agregar para múltiples granularidades (ej.: 1s, 1m) y preparar para visualización

Es útil tener varias granularidades para dashboards. Haga una consulta que genere ambas y elija en el cliente (Power BI, Grafana). Aquí mostramos cómo generar 1s y 1m usando dos consultas y union.

// 1 segundo
let a = EventsTable
| where EventTime >= ago(15m)
| summarize events_count = count() by bin(EventTime, 1s), service_name
| extend granularity = '1s', events_per_second = todouble(events_count);

// 1 minuto
let b = EventsTable
| where EventTime >= ago(15m)
| summarize events_count = count() by bin(EventTime, 1m), service_name
| extend granularity = '1m', events_per_second = todouble(events_count) / 60.0;

a union b
| order by EventTime asc, service_name

Paso 6: Evitar picos por bursts y outliers (suavizado y percentil)

Picos cortos pueden sesgar métricas. Para dashboards use media móvil o percentil bajo/alto. Ejemplo de media móvil simple en KQL con series_fir()

// ejemplo de media móvil simple (ventana 5 puntos)
EventsTable
| where EventTime >= ago(30m)
| make-series count() on EventTime from ago(30m) to now() step 10s by service_name
| extend smoothed = series_fir(events_count, dynamic([0.2,0.2,0.2,0.2,0.2]))
| mv-expand EventTime to typeof(datetime), events_count to typeof(long), smoothed to typeof(double)
| extend events_per_second_smoothed = smoothed / 10.0

Verificar el resultado

Confirme que cada service_name tiene tiempo continuo (o ceros) y que events_per_second tiene valores plausibles. Verifique extremos: la suma de events_per_second por ventana debe aproximarse al count() total por ventana. Pruebe con datos conocidos: genere eventos de prueba a N por segundo y compare con la salida.

Conclusión

Ahora tiene una forma práctica de calcular throughput por servicio en Real-Time Analytics, con alternativas para ventanas, relleno de ceros y suavizado. Próximos pasos: conectar a un dashboard (Power BI/Grafana) y crear alertas cuando events_per_second exceda límites. Consejo: experimente con diferentes ventanas y compare resultados para elegir la que mejor refleje la realidad de su servicio.