Motor de enrutamiento de cobranza paralelo

Reconstrucción didáctica de la arquitectura que usé para el Reloj de Cobranza en Totalplay: un proceso que cada ciclo decide, para más de un millón de cuentas con saldo vencido, en qué etapa de cobranza están, por qué canal se gestionan y con qué prioridad.

En producción, pasar de un proceso secuencial a uno paralelo y escalado horizontalmente redujo el tiempo de enrutamiento en 80%.

Este repositorio no contiene código, reglas ni datos de Totalplay. Es una implementación nueva, escrita desde cero, que reproduce las mismas decisiones de diseño con datos sintéticos.

El problema

Enrutar una cuenta es barato en CPU, pero cada cuenta necesita consultar información remota (historial de contactos, promesas de pago). Procesadas una por una, el tiempo total es latencia × número de cuentas, y con un millón de cuentas el ciclo no termina a tiempo.

La arquitectura

                    ┌──────────────── instancia i de N ─────────────────┐
 origen de cuentas ─▶ particionado ─▶ [canal acotado] ─▶ N workers ─▶ [canal] ─▶ escritor por lotes ─▶ Elasticsearch
                    │  (hash del id)                  enriquecer + reglas              (_bulk, idempotente)
                    └───────────────────────────────────────────────────┘
Decisión Por qué
Reglas como función pura (RoutingRules) Sin estado ni E/S: se paralelizan sin bloqueos y se prueban sin infraestructura.
Canales acotados (System.Threading.Channels) Contrapresión: si el destino se alenta, el origen espera en lugar de llenar la memoria.
Particionado por hash (Partitioner) Escalar es levantar más instancias con otro índice. Sin coordinador central ni bloqueos distribuidos.
Clave de idempotencia ciclo:cuenta Reprocesar un lote después de una falla no duplica gestiones. En Elasticsearch es el _id del documento.
Escritura por lotes (_bulk) Un viaje de red por cada 500 decisiones en lugar de uno por decisión.
Implementación secuencial conservada Línea base para medir y oráculo para las pruebas: ambas deben producir las mismas decisiones.

Cómo ejecutarlo

Requiere el SDK de .NET 8. No usa paquetes de NuGet.

# Pruebas
dotnet run -c Release --project tests/CollectionRouter.Tests

# Comparativa: cuentas, latencia simulada por cuenta (ms), grado de paralelismo
dotnet run -c Release --project src/CollectionRouter -- 10000 2 64

Resultado en una máquina de desarrollo (10,000 cuentas, 2 ms de latencia simulada, paralelismo 64):

Secuencial     10,000 decisiones en   40.07 s (       250/s)
Paralelo       10,000 decisiones en    0.64 s (    15,698/s)

Reducción de tiempo: 98.4 %
Decisiones idénticas: sí

La mejora de la demo es mayor que la de producción porque aquí la latencia es perfectamente uniforme y el destino es memoria. En un sistema real también pesan la base de datos, la red y el propio Elasticsearch, por eso no hay que leer el 98% como una promesa: el número que vale es el que se mide con datos reales.

Para escribir en Elasticsearch se usa ElasticsearchBulkSink.FromEnvironment(), que lee ELASTIC_URL y ELASTIC_API_KEY de variables de entorno. Ninguna credencial vive en el código.

Pruebas incluidas

  • Exclusiones de negocio: cuentas en disputa o con promesa de pago nunca se gestionan.
  • Escalamiento de canal según contactos fallidos.
  • Particionado: cada cuenta pertenece a una sola instancia y la carga se reparte con menos de 2% de desviación.
  • Cuatro instancias en paralelo cubren todas las cuentas sin duplicar ni perder ninguna.
  • Idempotencia del destino.
  • Equivalencia exacta entre la versión secuencial y la paralela.

Qué agregaría en producción

  • Reintentos con backoff y circuit breaker hacia el destino.
  • Métricas por etapa (cuentas leídas, enrutadas, latencia p95) y trazas distribuidas.
  • Un checkpoint por partición para reanudar un ciclo interrumpido sin empezar de cero.