(+351) 21 24 10006  ·  info@bconcepts.pt
Carnaxide, Lisboa

Cómo calcular la tasa de error por servicio en Real-Time Analytics: paso a paso

João Barros 17 de November de 2026 5 min de lectura

Presento cómo calcular la tasa de error por servicio en Real-Time Analytics, una métrica crucial para monitorizar la estabilidad y disparar alertas. Saber calcular la tasa de error en tiempo real permite identificar regresiones y actuar antes de que los usuarios se vean afectados. En esta guía explico el porqué de cada opción (ventana, deslizamiento, smoothing) y doy ejemplos concretos que funcionan en producción.

Requisitos previos

  • Fuente de eventos en streaming (Kafka, Event Hubs o similar) con eventos JSON que contengan service_id, status y timestamp.
  • Procesador de streaming (p. ej.: Azure Stream Analytics, Apache Flink, Spark Structured Streaming o ksqlDB).
  • Destino para métricas (p. ej.: Time Series db, Prometheus, InfluxDB, o un tópico Kafka para paneles).
  • Conocimientos básicos de SQL/KQL o API del motor de streaming elegido.

Nota práctica: en entornos con 5k–50k eventos/segundo conviene usar particionamiento por service_id y garantizar checkpointing. Definir watermark (p. ej.: 2 minutos) ayuda a tratar eventos retrasados sin inflar ventanas.

Paso 1: Definir el evento y la métrica (por qué)

Antes de codear, aclara qué es un "error" en tu sistema. Normalmente, se considera error un evento con status = "error" o código HTTP >= 500. La tasa de error es: errores / total de peticiones en una ventana temporal. Vamos a calcular esta tasa por servicio en ventanas de 1 minuto con actualización cada 15s (sliding window) para obtener resolución y suavidad.

¿Por qué 1 minuto y slide de 15s? Una ventana de 60s reduce el ruido en picos cortos; slide de 15s da 4 actualizaciones por minuto, suficiente para alertas rápidas. Para APIs con latencias muy bajas puedes usar 30s / 10s. En términos de thresholds prácticos, se definen alertas: warning si error_rate > 0.005 (0,5%) durante 3 ventanas consecutivas; critical si > 0.01 (1%). Estos números son orientativos y dependen del SLA.

Paso 2: Ingestión del stream y parsing del JSON

Recibe los eventos del tópico y convierte el payload JSON en columnas: service_id, status, timestamp. Ejemplo con Spark Structured Streaming (PySpark):

# Exemplo em PySpark
from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, to_timestamp
from pyspark.sql.types import StructType, StringType

schema = StructType() \
  .add('service_id', StringType()) \
  .add('status', StringType()) \
  .add('timestamp', StringType())

spark = SparkSession.builder.appName('error-rate').getOrCreate()
raw = spark.readStream.format('kafka') \
  .option('kafka.bootstrap.servers','kafka:9092') \
  .option('subscribe','events') \
  .load()

json_df = raw.select(from_json(col('value').cast('string'), schema).alias('j')) \
  .select(col('j.service_id'), col('j.status'), to_timestamp(col('j.timestamp')).alias('ts'))

Consejo práctico: si esperas eventos retrasados, usa withWatermark('ts','2 minutes') antes de agrupar.

Paso 3: Clasificar eventos como error o éxito

Crea una columna booleana is_error que facilita conteos. Esto reduce errores comunes como olvidar el parse del status o considerar mayúsculas/minúsculas. También trata casos en que el campo status viene vacío.

from pyspark.sql.functions import when

events = json_df.withColumn('is_error', when(col('status').rlike('(?i)error|5\\d\\d'), 1).otherwise(0))

Ejemplo práctico: si un servicio tiene 12 000 peticiones en una ventana y 60 errores, la tasa es 60/12000 = 0.005 = 0,5%.

Paso 4: Agregar por ventana deslizante y por servicio

Usa una ventana tumbling o sliding. Para sliding de 1 minuto con slide de 15s en Spark:

from pyspark.sql.functions import window, sum as _sum, count as _count, when, lit

agg = events.withWatermark('ts','2 minutes').groupBy(
    col('service_id'),
    window(col('ts'), '60 seconds', '15 seconds')
).agg(
    _sum(col('is_error')).alias('errors'),
    _count(col('service_id')).alias('total')
)

result = agg.withColumn('error_rate', when(col('total') == 0, lit(0.0)).otherwise(col('errors') / col('total')))

Importante: evita división por cero (total = 0) y piensa en smoothing: aplica EWMA al error_rate para reducir falsos positivos (p. ej.: alpha = 0.3). En términos de latencia, con micro-batches de 15s se espera ~100–500ms de procesamiento adicional por batch dependiendo del clúster.

Paso 5: Escritura de las métricas al destino

Exporta los resultados a un sistema de métricas o tópico para visualización. Evita latencia extra con writes por micro-batch pequeños. Ejemplo escribiendo a otro tópico Kafka y definiendo trigger de 15s:

result.selectExpr('service_id', 'window.start as window_start', 'window.end as window_end', 'errors', 'total', 'error_rate') \
  .selectExpr("to_json(struct(*)) AS value") \
  .writeStream.format('kafka') \
  .option('kafka.bootstrap.servers', 'kafka:9092') \
  .option('topic', 'metrics.error_rate') \
  .option('checkpointLocation', '/tmp/checkpoint_error_rate') \
  .trigger(processingTime='15 seconds') \
  .start()

Considera la retención y compresión en el tópico de métricas; para paneles en Grafana/Prometheus, escribe en la Time Series db con resolución compatible (p. ej.: 15s). No olvides monitorizar el directorio de checkpoint y el uso de disco.

Verificar el resultado

Confirma que tienes mensajes en el tópico de destino o en el sistema de métricas con campos: service_id, window_start, window_end, errors, total, error_rate. Verifica casos límite: total = 0 (evitar división por cero), ventanas con tráfico bajo y consistencia con logs de origen. Un consumer simple de Kafka o una query en la UI de la Time Series db debe mostrar tasas próximas a lo esperado. Prueba con tráfico sintético: envía 10k eventos con 100 errores (1%) y valida la métrica.

Conclusión

Calcular la tasa de error por servicio en Real-Time Analytics permite detectar regresiones rápidamente y alimentar alertas y paneles. Próximos pasos: normalizar por tipo de petición, aplicar smoothing (p. ej.: EWMA con alpha entre 0.2 y 0.5) o crear thresholds dinámicos basados en baseline histórico. Consejo final: trata siempre el caso total = 0, valida la timezone de los timestamps para evitar ventanas desalineadas y dimensiona los recursos de acuerdo con el throughput esperado.