Como agregar eventos de sessão em Real-Time Analytics: passo a passo

Este tutorial mostra como agregar eventos de sessão em Real-Time Analytics para obter métricas por sessão (duração, contagem de eventos, últimos atributos). Agregar por sessão é útil para análises de comportamento, medição de retenção e deteção de experiências anormais em tempo real.

Pré-requisitos

• Conta e cluster com suporte a Real-Time Analytics (por exemplo, Azure Data Explorer / Kusto).
• Dados de eventos com um identificador de sessão (sessionId), timestamp e tipo de evento.
• Conhecimentos básicos de KQL (Kusto Query Language) e de ingestão de dados.

Passo 1: entender o objetivo e o esquema

Antes de escrever a query é importante saber quais colunas existem: sessionId, timestamp (datetime), eventType e, opcionalmente, userId e properties. O objetivo é agregar por sessionId e produzir métricas: start, end, duration, event_count, last_event_type.

Passo 2: filtrar e normalizar eventos

Filtre o intervalo temporal relevante e normalize o timestamp. Isto reduz o custo de processamento e evita incluir sessões antigas ou eventos fora da janela.

Events
| where Timestamp between (ago(1h) .. now())
| where isnotempty(sessionId)

Passo 3: agregar por sessão para métricas básicas

Use summarize para obter start, end e contagem. start=min(Timestamp) e end=max(Timestamp) fornecem o período da sessão; duration é a diferença entre ambos.

Events
| where Timestamp between (ago(1h) .. now())
| where isnotempty(sessionId)
| summarize
    session_start = min(Timestamp),
    session_end = max(Timestamp),
    event_count = count()
  by sessionId, userId
| extend duration_sec = todouble(session_end - session_start) / 1s

Passo 4: obter o último evento e outros atributos por sessão

Para saber o último tipo de evento ou o último valor de uma propriedade use arg_max que seleciona a linha com maior timestamp por sessão.

let sessions_basic = Events
| where Timestamp between (ago(1h) .. now())
| where isnotempty(sessionId)
| summarize
    session_start = min(Timestamp),
    session_end = max(Timestamp),
    event_count = count()
  by sessionId, userId;

let sessions_last = Events
| where Timestamp between (ago(1h) .. now())
| where isnotempty(sessionId)
| summarize arg_max(Timestamp, *) by sessionId;

sessions_basic
| join kind=inner (sessions_last) on sessionId
| project sessionId, userId, session_start, session_end, duration_sec, event_count, last_event_type = eventType, last_properties = properties

Passo 5: tratar sessões inativas e falsos positivos

Nem todos os sessionId representam sessões válidas. Defina um limiar mínimo de duração ou contagem de eventos para filtrar ruído (ex.: ignorar sessões com ≤1 evento ou duração <5s).

// Filtrar sessões muito curtas ou com poucos eventos
...
| where event_count > 1 and duration_sec > 5

Passo 6: produzir métricas agregadas em tempo real

Com as sessões processadas, calcule métricas agregadas por janela temporal (ex.: por minuto) para dashboards em Real-Time Analytics.

let sessions = (
  // query de sessão final do passo anterior
  Events
  | where Timestamp between (ago(1h) .. now())
  | where isnotempty(sessionId)
  | summarize session_start = min(Timestamp), session_end = max(Timestamp), event_count = count() by sessionId
  | extend duration_sec = todouble(session_end - session_start) / 1s
  | where event_count > 1 and duration_sec > 5
);

sessions
| summarize
    avg_duration = avg(duration_sec),
    sessions_count = count(),
    pct_long = 100.0 * sumif(1, duration_sec > 300) / count()
  by bin(session_start, 1m)
| order by session_start desc

Verificar o resultado

Para confirmar que tudo correu bem: 1) compare o número de eventos originais com a soma de event_count por sessionId (devem corresponder); 2) veja exemplos de sessões (limit 10) para inspecionar start/end; 3) valide as métricas agregadas num dashboard em tempo real e procure outliers (durações muito longas ou muito curtas).

Conclusão

Agora consegue agregar eventos por sessionId em Real-Time Analytics e gerar métricas por sessão e por janela temporal. Próximos passos: enriquecer com segmentação por userId, deviceType ou country e exportar sessões para um downstream ETL/streaming. Dica: se notar latência elevada, reduza a janela de consulta e pré-agrupa eventos na ingestão.