Cómo agregar eventos de sesión en Real-Time Analytics: paso a paso

João Barros 06 de September de 2026 4 min de lectura

Este tutorial muestra cómo agregar eventos de sesión en Real-Time Analytics para obtener métricas por sesión (duración, recuento de eventos, últimos atributos). Agregar por sesión es útil para análisis de comportamiento, medición de retención y detección de experiencias anómalas en tiempo real.

Requisitos previos

Cuenta y clúster con soporte para Real-Time Analytics (por ejemplo, Azure Data Explorer / Kusto).
Datos de eventos con un identificador de sesión (sessionId), timestamp y tipo de evento.
Conocimientos básicos de KQL (Kusto Query Language) y de ingestión de datos.

Paso 1: entender el objetivo y el esquema

Antes de escribir la query es importante saber qué columnas existen: sessionId, timestamp (datetime), eventType y, opcionalmente, userId y properties. El objetivo es agregar por sessionId y producir métricas: start, end, duration, event_count, last_event_type.

Paso 2: filtrar y normalizar eventos

Filtra el intervalo temporal relevante y normaliza el timestamp. Esto reduce el coste de procesamiento y evita incluir sesiones antiguas o eventos fuera de la ventana.

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

Paso 3: agregar por sesión para métricas básicas

Usa summarize para obtener start, end y recuento. start=min(Timestamp) y end=max(Timestamp) proporcionan el periodo de la sesión; duration es la diferencia 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

Paso 4: obtener el último evento y otros atributos por sesión

Para conocer el último tipo de evento o el último valor de una propiedad usa arg_max que selecciona la fila con mayor timestamp por sesión.

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

Paso 5: tratar sesiones inactivas y falsos positivos

No todos los sessionId representan sesiones válidas. Define un umbral mínimo de duración o recuento de eventos para filtrar ruido (p. ej.: ignorar sesiones con ≤1 evento o duración <5s).

// Filtrar sesiones muy cortas o con pocos eventos
...
| where event_count > 1 and duration_sec > 5

Paso 6: producir métricas agregadas en tiempo real

Con las sesiones procesadas, calcula métricas agregadas por ventana temporal (p. ej.: por minuto) para dashboards en Real-Time Analytics.

let sessions = (
  // query de sesión final del paso 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 el resultado

Para confirmar que todo ha ido bien: 1) compara el número de eventos originales con la suma de event_count por sessionId (deben corresponder); 2) observa ejemplos de sesiones (limit 10) para inspeccionar start/end; 3) valida las métricas agregadas en un dashboard en tiempo real y busca outliers (duraciones muy largas o muy cortas).

Conclusión

Ahora puedes agregar eventos por sessionId en Real-Time Analytics y generar métricas por sesión y por ventana temporal. Siguientes pasos: enriquecer con segmentación por userId, deviceType o country y exportar sesiones a un downstream ETL/streaming. Consejo: si notas latencia elevada, reduce la ventana de consulta y pre-agrega eventos en la ingestión.