¿Eventos perdidos en el backend? Arquitectura de streaming
En resumen
Evita la pérdida de eventos en tu backend de juegos con una arquitectura de streaming durable. Aprende a desacoplar productores y consumidores con lag.
Tu pipeline de analytics acaba de perder el 40% de los eventos de muerte de jugadores durante un pico de fin de semana. Los leaderboards están desactualizados. Los crash reports nunca llegaron. Nadie se dio cuenta en tres días.
Este es el asesino silencioso de la fiabilidad en el backend de un juego: arquitecturas productoras-consumidoras acopladas que funcionan bien a 100 peticiones por segundo y desangran datos a 10,000. La llamada RPC desde tu game server al consumidor de analytics expira, la conexión se reinicia y el evento simplemente desaparece — sin error, sin reintento, sin registro.
Este runbook cubre qué falla, cómo detectarlo, el patrón arquitectónico que lo soluciona y cómo prevenir que vuelva a ocurrir.
Qué falla: El modo de fallo del productor-consumidor acoplado
Las arquitecturas RPC tradicionales obligan a los productores y consumidores a alinearse tanto en escala como en tiempo. Cuando tu game server envía un evento "player_killed" directamente a un servicio de analytics por HTTP:
- Desajuste de escala: Si 5,000 jugadores mueren simultáneamente durante un evento en el servidor, tu endpoint de analytics recibe un pico que no puede procesar. La conexión HTTP expira tras 30 segundos. Los eventos se descartan.
- Acoplamiento temporal: Si tu servicio de detección de fraude despliega una nueva versión y se apaga durante 90 segundos, cada evento producido durante esa ventana desaparece.
- Fan-out multi-consumidor: El mismo evento "player_killed" necesita llegar a tres sistemas independientes: un actualizador de leaderboards, un pipeline de analytics y un dashboard de live-ops. Cada consumidor tiene un throughput diferente. El más lento se convierte en un cuello de botella para el productor.
Así es como se ve esto en la práctica:
[Game Server] --HTTP POST--> [Analytics Service] ✓ works at 200 req/s
[Game Server] --HTTP POST--> [Analytics Service] ✗ 40% drops at 8,000 req/s
[Game Server] --HTTP POST--> [Fraud Detection] ✗ offline during deploy
El resultado: pérdida de datos silenciosa y parcial que corrompe el analytics, leaderboards desactualizados y patrones de crash invisibles. Lo descubres semanas después cuando tus números de embudo no cuadran.
Números de fallo concretos
En un backend multiplayer indie típico que maneja 5,000 jugadores concurrentes:
- ~2,400 eventos de juego/segundo en pico (kills, actualizaciones de puntuación, cambios de inventario, transiciones de zona)
- Payload promedio por evento: ~200 bytes
- Fan-out HTTP directo a 3 consumidores: 7,200 peticiones salientes/segundo
- Umbral de timeout del consumidor: 30 segundos
- Tasa de pérdida observada en pico: 15–45% dependiendo de la salud del consumidor
Las matemáticas son brutales. Un solo consumidor que deja de estar saludable durante 60 segundos pierde 72,000 eventos. Esos eventos desaparecen a menos que hayas construido un búfer.
Cómo detectar la pérdida silenciosa de eventos
La pérdida silenciosa de eventos es, por definición, difícil de detectar. Aquí tienes un runbook de detección:
Paso 1: Instrumentar números de secuencia
Cada productor debe estampar en cada evento un número de secuencia que aumente monótonamente por entidad de origen. Si tu game server envía eventos para player_abc, la secuencia va 1, 2, 3, 4...
Event 1: { seq: 1, player: "abc", type: "kill", ts: 1719432000 }
Event 2: { seq: 2, player: "abc", type: "death", ts: 1719432001 }
Event 3: { seq: 4, player: "abc", type: "score", ts: 1719432005 } // seq 3 missing!
Un hueco en los números de secuencia del lado del consumidor significa pérdida de eventos confirmada.
Paso 2: Monitorear el consumer lag
Monitorea la diferencia entre la última secuencia producida y la última secuencia consumida para cada consumidor. Umbrales de alerta:
- Lag < 1,000 eventos: Saludable
- Lag 1,000–10,000 eventos: Advertencia — el consumidor se está quedando atrás
- Lag > 10,000 eventos: Crítico — el consumidor está efectivamente offline o saturado
Paso 3: Validar totales de forma cruzada
Compara los recuentos de eventos entre los logs del productor y las ingestas del consumidor de forma horaria. Una discrepancia superior al 1% amerita investigación.
// Producer-side counter (emit to your monitoring system every 60s)
public class EventProducerMetrics
{
private long _producedCount = 0;
public void RecordProduced()
{
Interlocked.Increment(ref _producedCount);
}
public long GetAndResetCount()
{
return Interlocked.Exchange(ref _producedCount, 0);
}
}
Si tu recuento producido por hora es 8,400,000 y tu consumidor de analytics ingirió 5,100,000, perdiste el 39% de los eventos. Esa es tu señal.
La solución arquitectónica: Desacoplar con un evento de log durable
La solución consiste en desacoplar a los productores de los consumidores insertando un búfer durable entre ellos. En lugar de:
Game Server --direct HTTP--> Analytics
Game Server --direct HTTP--> Leaderboard Service
Game Server --direct HTTP--> Crash Reporter
Escribes a:
Game Server --single write--> [Durable Event Stream] --independent reads--> Analytics
--independent reads--> Leaderboard Service
--independent reads--> Crash Reporter
El stream durable absorbe escrituras a la velocidad del productor. Cada consumidor lee a su propio ritmo. Si un consumidor se desconecta durante 5 minutos, los eventos se acumulan en el stream y el consumidor retoma desde donde lo dejó cuando vuelve. Sin pérdida de datos.
Propiedades clave de un stream de eventos durable
Un event stream de nivel de producción para backends de juegos necesita estas propiedades:
| Propiedad | Por qué importa para los juegos |
|---|---|
| Ordenado dentro de una partición | Todos los eventos de un jugador deben procesarse en secuencia: una baja antes de actualizar la puntuación, no después |
| Almacenamiento durable | Los eventos sobreviven a reinicios de consumidores, ventanas de despliegue y fallos de infraestructura |
| Offsets de consumidor independientes | Tu consumidor de analytics y el de leaderboards leen a diferentes velocidades sin bloquearse mutuamente |
| Ordenamiento a nivel de partición | Obtienes paralelismo entre jugadores (diferentes particiones) y consistencia dentro de un jugador (misma partición) |
Estrategia de particionamiento para backends de juegos
La clave de partición determina qué eventos caen en qué log ordenado. Para backends de juegos, la clave de partición natural es playerId:
Partition 0: [player_abc kill#1] [player_abc death#2] [player_abc score#3]
Partition 1: [player_def zone#1] [player_def kill#2] [player_def loot#3]
Partition 2: [player_ghi death#1] [player_ghi spawn#2]
Esto garantiza que todos los eventos de un solo jugador se procesen en orden exacto por cada consumidor, mientras que los eventos de diferentes jugadores se pueden procesar en paralelo.
Implementación de durable event streaming: Un recorrido práctico
Aquí tienes un patrón de implementación concreto. Puedes construir esto sobre almacenamiento de objetos (como S3/R2), un servicio de streaming gestionado o un log respaldado por base de datos.
El productor: Fan-out de escritura única
Tu game server escribe un evento. La infraestructura de streaming maneja la entrega a todos los consumidores.
public class GameEventProducer
{
private readonly IEventStreamClient _stream;
private readonly ILogger _logger;
public GameEventProducer(IEventStreamClient stream, ILogger logger)
{
_stream = stream;
_logger = logger;
}
public async Task EmitAsync(string playerId, string eventType,
Dictionary<string, object> payload)
{
var gameEvent = new GameEvent
{
Id = Guid.NewGuid().ToString(),
PlayerId = playerId, // partition key
EventType = eventType,
Payload = payload,
Timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
try
{
// Single write — the stream handles fan-out to all consumers
await _stream.AppendAsync(
partitionKey: playerId,
eventData: JsonSerializer.Serialize(gameEvent)
);
}
catch (EventStreamException ex)
{
// Events that fail to write should be queued locally
// and retried, not silently dropped
_logger.LogWarning(ex,
"Failed to emit event {EventType} for {Player}, queueing retry",
eventType, playerId);
await _retryQueue.EnqueueAsync(gameEvent);
}
}
}
Decisiones de diseño clave en este código:
- La clave de partición es
playerId: Garantiza el orden por jugador en todos los tipos de eventos. - Llamada de escritura única: El productor no sabe ni le importa cuántos consumidores existan. Agregar un nuevo consumidor (por ejemplo, un rastreador de eventos de temporada) requiere cero cambios en el productor.
- Cola de reintentos local: Si el stream no está disponible temporalmente, los eventos se encolan localmente y se vacían cuando se restablece la conectividad. Esto previene la pérdida de datos durante intermitencias de red.
El consumidor: Seguimiento de offset independiente
Cada consumidor mantiene su propio offset de lectura por partición. Este es el mecanismo principal que permite velocidades de procesamiento independientes.
public class LeaderboardConsumer
{
private readonly IEventStreamClient _stream;
private readonly ILeaderboardService _leaderboard;
private readonly IOffsetStore _offsets;
public async Task ProcessEventsAsync(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
// Read the next batch from where we left off
var lastOffset = await _offsets.GetOffsetAsync(
consumerName: "leaderboard-updater",
partitionId: 0
);
var batch = await _stream.ReadBatchAsync(
partitionId: 0,
fromOffset: lastOffset,
maxBatchSize: 500
);
foreach (var evt in batch.Events)
{
var gameEvent = JsonSerializer.Deserialize<GameEvent>(evt.Data);
if (gameEvent.EventType == "player_killed")
{
await _leaderboard.IncrementKillsAsync(
gameEvent.PlayerId,
amount: 1
);
}
else if (gameEvent.EventType == "score_updated")
{
await _leaderboard.UpdateScoreAsync(
gameEvent.PlayerId,
gameEvent.Payload["score"].GetInt32()
);
}
// Advance offset AFTER successful processing
await _offsets.SetOffsetAsync(
consumerName: "leaderboard-updater",
partitionId: 0,
offset: evt.Offset + 1
);
}
await Task.Delay(100, ct); // Poll interval
}
}
}
Detalles críticos de implementación:
- El offset avanza después del procesamiento, no antes. Si el consumidor falla a mitad de un lote, vuelve a procesar los mismos eventos al reiniciarse. Tus manejadores deben ser idempotentes — procesar el mismo evento de muerte dos veces no debe duplicar la entrada en el leaderboard.
- Un tamaño de lote de 500 equilibra el throughput con la memoria. A eventos de 200 bytes, son ~100KB por lote, algo insignificante.
- Un intervalo de sondeo de 100ms significa que la latencia en el peor de los casos es de ~100ms desde la producción del evento hasta la actualización del leaderboard. Para la mayoría de los casos de uso de leaderboards, esto es perfectamente aceptable. Si necesitas una latencia inferior a 10ms, estás en territorio de transporte en tiempo real, que es una arquitectura completamente diferente.
Idempotencia: La red de seguridad del consumidor
La idempotencia no es negociable en esta arquitectura. Aquí tienes un manejador idempotente concreto:
public class IdempotentKillCounter
{
private readonly IDatabase _db;
public async Task ProcessKillAsync(string playerId, string eventId)
{
// Check if we already processed this event
var alreadyProcessed = await _db.ExecuteScalarAsync<bool>(
"SELECT COUNT(*) > 0 FROM processed_events WHERE event_id = @id",
new { id = eventId }
);
if (alreadyProcessed)
{
return; // Skip duplicate — this is the idempotency guard
}
// Process and record in a transaction
await _db.ExecuteInTransactionAsync(async tx =>
{
await tx.ExecuteAsync(
"UPDATE leaderboard SET kills = kills + 1 WHERE player_id = @pid",
new { pid = playerId }
);
await tx.ExecuteAsync(
"INSERT INTO processed_events (event_id, processed_at) VALUES (@id, @now)",
new { id = eventId, now = DateTime.UtcNow }
);
});
}
}
La tabla processed_events actúa como un almacén de deduplicación. Cuesta una escritura extra por evento, pero garantiza que los reinicios del consumidor nunca corrompan tus datos.
Gestión del tiempo de inactividad del consumidor: La garantía de búfer
La razón principal para usar durable event streaming es sobrevivir al tiempo de inactividad del consumidor sin perder datos. Así es como funcionan las matemáticas del búfer:
Producer rate: 2,400 events/second
Consumer offline window: 5 minutes (300 seconds)
Events buffered: 720,000 events
Storage required: 720,000 × 200 bytes = ~144 MB
Con 144 MB, esto cabe sin problemas en cualquier sistema de almacenamiento moderno. La perspectiva crítica: el tamaño de tu búfer es proporcional a tu tasa de eventos multiplicada por tu tolerancia máxima a la inactividad, no a tus datos históricos totales.
Para la retención a largo plazo (30 días de eventos para reproducción o reprocesamiento), los números crecen:
30 days × 86,400 seconds × 2,400 events/sec × 200 bytes = ~1.24 TB
Esto está muy dentro de la capacidad de los backends de object storage. La estructura de particiones mantiene el rendimiento de lectura predecible incluso a esta escala: nunca escaneas el log completo, lees de particiones específicas en offsets específicos.
Lo que horizOn aporta en una arquitectura orientada a eventos
Una vez que tu event stream entrega datos de forma fiable, necesitas servicios que consuman esos eventos. horizOn proporciona servicios de backend gestionados a los que tus consumidores pueden escribir mediante los SDKs o la REST API:
- Leaderboards mantienen las clasificaciones de las puntuaciones que tus consumidores envían desde los eventos de muertes, puntuaciones y finalizaciones
- User logs almacenan las entradas de registro que escribes, para que cuando un jugador diga "mi puntuación se reinició", puedas revisar sus logs
- Crash reports recopilan informes de fallos y no fatales de los SDKs, agrupados para su revisión
El punto clave: el event stream lleva los datos a tus consumidores de forma fiable. horizOn no reemplaza el stream en sí, cubre los servicios que se encuentran detrás de tus consumidores.
Runbook: Prevención de la recurrencia de pérdida de eventos
Cuando hayas experimentado pérdida de eventos una vez, aquí tienes la lista de verificación para evitar que vuelva a suceder:
1. Auditar cada acoplamiento productor-consumidor
Recorre tu base de código e identifica cada lugar donde un game server realiza una llamada HTTP síncrona directa a un servicio de backend. Cada una es un punto potencial de caída bajo carga. Lístalos:
GameServer → AnalyticsService (HTTP POST, no retry) ← RISK
GameServer → LeaderboardService (HTTP POST, no retry) ← RISK
GameServer → CrashReporter (UDP, fire-and-forget) ← RISK
2. Introducir el Event Stream como intermediario
Reemplaza cada llamada directa con una única escritura en el durable event stream. Cada servicio aguas abajo se convierte en un consumidor independiente con su propio offset.
3. Implementar monitoreo de salud del consumidor
Para cada consumidor, rastrea:
- Lag (eventos por detrás del productor)
- Tasa de procesamiento (eventos consumidos por segundo)
- Tasa de errores (eventos que fallaron en el procesamiento por segundo)
- Último offset exitoso (detección de obsolescencia)
Configura alertas si el lag supera tu ventana de búfer calculada. Si tu stream retiene 7 días y tu consumidor ha estado caído durante 6 días, tienes 24 horas antes de que comience la pérdida de datos.
4. Probar la recuperación por reinicio del consumidor
Apaga deliberadamente a un consumidor durante 5 minutos, vuelve a encenderlo y verifica que se pone al día sin duplicados. Esta es tu prueba de confianza de que la arquitectura funciona.自动化 en CI:
[Test]
public async Task ConsumerResumesAfterDowntime()
{
// Produce 10,000 events
await ProduceEvents(count: 10_000);
// Simulate consumer offline — skip reads for 30 seconds
await Task.Delay(TimeSpan.FromSeconds(30));
// Resume consumer
var processed = await Consumer.ProcessUntilCaughtUp();
// Verify: all events processed, no duplicates
Assert.AreEqual(10_000, processed.UniqueEventCount);
Assert.AreEqual(0, processed.DuplicateCount);
}
5. Configurar una Dead-Letter Queue
Los eventos que fallan en el procesamiento tras N reintentos (típicamente de 3 a 5) se mueven a una dead-letter queue (DLQ). Monitorea el tamaño de la DLQ. Una DLQ en crecimiento significa que tu consumidor tiene un bug, no un fallo transitorio.
Buenas prácticas para el event streaming en backends de juegos
Elige playerId como tu clave de partición. Esto te proporciona orden por jugador (crítico para eventos de inventario, puntuación y estado) a la vez que permite el paralelismo entre jugadores. No particiones por tipo de evento — un "kill" y un "score_update" para el mismo jugador deben mantenerse ordenados.
Mantén los eventos pequeños y autodescriptivos. Cada evento debe medir entre 100 y 500 bytes. Incluye el tipo de evento, el ID del jugador, la marca de tiempo y el payload mínimo necesario. No incorpores el estado completo del juego: referéncialo por ID.
Diseña los consumidores para que sean idempotentes desde el primer día. Usa IDs de eventos y un almacén de deduplicación. Asume que cada evento se entregará al menos una vez, y posiblemente más de una vez durante una conmutación por error (failover).
Dimensiona tu ventana de retención según tu tolerancia máxima aceptable a la inactividad del consumidor. Si tu despliegue más largo toma 15 minutos, retén al menos 30 minutos de eventos en caliente. Guarda de 7 a 30 días de almacenamiento en frío para reproducción y depuración.
Monitorea el consumer lag como una métrica de primer nivel. El lag es el latido de tu arquitectura orientada a eventos. Un consumidor que se retrasa más del 50% de su ventana de retención es una emergencia de pérdida de datos, no un elemento para "arreglar en el próximo sprint".
Siguientes pasos
Si actualmente ejecutas llamadas RPC directas desde los game servers hacia los servicios de backend, audita esas conexiones esta semana. Cuenta cuántas descartarían eventos silenciosamente bajo un pico de carga de 10x. Luego, haz un prototipo de event stream durable entre tus productores y consumidores — incluso un log simple respaldado por base de datos es mejor que el acoplamiento directo.
Si tus consumidores escriben en leaderboards, crash reports o user logs, horizOn los proporciona como servicios gestionados para que no tengas que construir cada uno desde cero. Puedes empezar aquí.