Como calcular throughput por serviço em Real-Time Analytics

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

Vamos calcular o throughput (eventos por segundo) por serviço em Real-Time Analytics para monitorizar capacidade e detetar picos. Este exemplo mostra como agregar eventos em janelas de tempo fixas e normalizar por segundo, útil para dashboards e alertas de escalabilidade.

Pré-requisitos

Conta com acesso a uma instância de Real-Time Analytics (ex.: Azure Data Explorer/Kusto ou serviço compatível).
Fonte de eventos com timestamp e campo service_name (p. ex. telemetria, logs ou eventos de API).
Conhecimentos básicos de KQL/consulta e acesso à tabela de eventos.

Passo 1: Entender o objetivo e formato dos dados

Queremos uma métrica: eventos por segundo por serviço ao longo do tempo. Os dados devem ter pelo menos um timestamp (p. ex. timestamp, EventTime) e um identificador do serviço (service_name). Verifique o formato e fuso horário do timestamp para evitar valores incorretos.

Passo 2: Contar eventos por janela fixa (exemplo 1 segundo)

Usamos janelas de 1 segundo para obter o throughput por segundo. Em muitos sistemas, usar janelas muito pequenas pode gerar ruído; escolha 1s, 5s ou 10s conforme necessidade. Abaixo um exemplo em KQL que agrega por janela de 1s e por service_name.

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

Passo 3: Normalizar para obter eventos por segundo quando a janela for maior

Se preferir janelas de 10s para suavizar variação, divida a contagem pela duração da janela para obter eventos/segundo. Isto evita picos falsos e torna comparações mais estáveis.

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

Passo 4: Tratar períodos com ausência de eventos (preencher zeros)

Caso um serviço não gere eventos numa janela, pretende-se ver 0 em vez de ausência de linha. Use make-series ou join com uma série temporal. make-series preenche automaticamente com 0 quando 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

Passo 5: Agregar para múltiplas granularidades (ex.: 1s, 1m) e preparar para visualização

É útil ter várias granularidades para dashboards. Faça uma consulta que gere ambas e escolha no cliente (Power BI, Grafana). Aqui mostramos como gerar 1s e 1m usando duas consultas e 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

Passo 6: Evitar picos por bursts e outliers (suavização e percentil)

Picos curtos podem enviesar métricas. Para dashboards use média móvel ou percentil baixo/alto. Exemplo de média móvel simples em KQL com series_fir()

// exemplo de média móvel simples (janela 5 pontos)
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 o resultado

Confirme que cada service_name tem tempo contínuo (ou zeros) e que events_per_second tem valores plausíveis. Verifique extremos: somatório de events_per_second por janela deve aproximar-se de count() total por janela. Teste com dados conhecidos: gere eventos de teste a N por segundo e compare com a saída.

Conclusão

Agora tem uma forma prática de calcular throughput por serviço em Real-Time Analytics, com alternativas para janelas, preenchimento de zeros e suavização. Próximos passos: ligar a um dashboard (Power BI/Grafana) e criar alertas quando events_per_second exceder limites. Dica: experimente diferentes janelas e compare resultados para escolher a que melhor reflete a realidade do seu serviço.