TelemetryGuard AI — EXPLAINER

Concepto

TelemetryGuard es una startup API-first SaaS que automatiza el análisis de causa raíz (Root Cause Analysis) de incidentes de producción. Cuando ocurre un incidente, los equipos de SRE/DevOps reciben una avalancha de telemetría desde múltiples fuentes. TelemetryGuard despliega un enjambre de agentes de IA colaborativos que analizan en paralelo los logs, métricas y trazas distribuidas, y producen un informe con hipótesis de causa raíz en lenguaje natural en cuestión de segundos, reduciendo el MTTR de horas a minutos.

---

Arquitectura

┌─────────────────────────────────────────────────────────────────────┐
│  Monitoring Systems (PagerDuty / Grafana / Prometheus / Datadog)    │
└────────────────────────────┬────────────────────────────────────────┘
                             │ POST /api/v1/ingest (JWT Bearer Token)
                             ▼
┌─────────────────────────────────────────────────────────────────────┐
│  IncidentController  ──►  IncidentRepository (H2 / PostgreSQL)      │
│         │                                                            │
│         │  @Async (Virtual Thread Executor — Java 25)               │
│         ▼                                                            │
│  IncidentAnalysisService                                            │
│    │                                                                 │
│    ├── CompletableFuture (3× parallel virtual threads)              │
│    │     ├── LogAnalystAgent   → LLM (OpenAI-compatible API)        │
│    │     ├── MetricAnalystAgent → LLM                               │
│    │     └── TraceAnalystAgent  → LLM                               │
│    │                                                                 │
│    └── SupervisorAgent  → LLM (synthesises 1-3 hypotheses)         │
│              │                                                       │
│              ▼                                                       │
│    HypothesisRepository (persists ranked hypotheses)                │
│    AgentTaskRepository  (persists per-agent audit trail)            │
└─────────────────────────────────────────────────────────────────────┘
                             │ GET /api/v1/incidents/{id}/hypothesis
                             ▼
                     Client (SRE Dashboard)

Capas

Capa	Clases principales
Controller	%%INLINE0%%, %%INLINE1%%
Service	%%INLINE2%%, %%INLINE3%%, AuthService
Agent	%%INLINE5%%, %%INLINE6%%, %%INLINE7%%, %%INLINE8%%
Client	LlmFeignClient (OpenFeign → OpenAI-compatible)
Repository	%%INLINE10%%, %%INLINE11%%, HypothesisRepository
Model	%%INLINE13%%, %%INLINE14%%, Hypothesis
Security	%%INLINE16%%, %%INLINE17%%, UserDetailsServiceImpl
Config	%%INLINE19%%, %%INLINE20%%, %%INLINE21%%, %%INLINE22%%, JacksonConfig

---

Endpoints REST

Autenticación

Método	URL	Auth	Descripción
%%INLINE24%%	%%INLINE25%%	❌ público	Obtiene un JWT bearer token

Request:

{ "username": "admin", "password": "admin123" }

Response:

{ "token": "eyJ...", "type": "Bearer" }

---

Gestión de Incidentes (requieren Authorization: Bearer <token>)

Método	URL	Descripción
%%INLINE27%%	%%INLINE28%%	Ingesta un webhook de alerta → inicia análisis async
%%INLINE29%%	%%INLINE30%%	Lista todos los incidentes
%%INLINE31%%	%%INLINE32%%	Estado de un incidente
%%INLINE33%%	%%INLINE34%%	Hipótesis de causa raíz

POST /api/v1/ingest

{
  "source": "PagerDuty",
  "title": "High error rate on orders service",
  "description": "P99 latency spiked to 4200ms. Error rate at 38%. DB pool exhausted.",
  "severity": "critical"
}

Response 202 Accepted:

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "source": "PagerDuty",
  "title": "High error rate on orders service",
  "severity": "critical",
  "status": "PENDING",
  "reportedAt": "2026-04-16T12:00:00Z",
  "analyzedAt": null
}

GET /api/v1/incidents/{id}/hypothesis

{
  "incidentId": "550e8400-e29b-41d4-a716-446655440000",
  "status": "COMPLETED",
  "hypotheses": [
    {
      "rank": 1,
      "description": "Database connection pool exhaustion caused by an unoptimised ORDER BY query...",
      "evidence": "span 7e1c3b9d (11890ms postgres query), metric db.pool.active=100/100, log: 'Connection pool exhausted' app-2026-04-16.log:L4821",
      "confidence": 0.87,
      "createdAt": "2026-04-16T12:00:05Z"
    },
    {
      "rank": 2,
      "description": "Traffic spike (2.3× normal RPS) overwhelmed the orders service thread pool...",
      "evidence": "metric http.server.rps spike at T-4m30s, metric system.cpu.utilization=94%",
      "confidence": 0.72,
      "createdAt": "2026-04-16T12:00:05Z"
    }
  ]
}

---

Análisis de Negocio

Problema

Los equipos de SRE/DevOps pierden horas cada vez que ocurre un incidente de producción intentando correlacionar manualmente terabytes de telemetría de múltiples fuentes (logs, métricas, trazas). Este proceso es lento, estresante y propenso a errores humanos.

Solución

TelemetryGuard automatiza el análisis inicial mediante un sistema multi-agente:

• 3 agentes especialistas analizan en paralelo logs, métricas y trazas
• 1 agente supervisor sintetiza las hipótesis más probables
• Todo el proceso se completa en segundos gracias a Virtual Threads de Java 25

Modelo de Monetización — API-first SaaS

Tier	Precio/mes	Límite de incidentes
Starter	$299	100 incidentes
Growth	$999	500 incidentes
Enterprise	Negociable	Ilimitado + SLA

ROI para el cliente

• Un incidente P1 puede costar $5,000–$50,000/hora en revenue y productividad
• Reducir el MTTR de 2 horas a 10 minutos = ahorro potencial de $9,000–$90,000 por incidente
• El plan Starter se amortiza con un solo incidente resuelto más rápido

Mercado objetivo

• 50,000+ empresas globales con arquitecturas de microservicios (Gartner, 2025)
• TAM estimado: $8.5B (AIOps market, 2026)
• Competidores directos: Dynatrace Davis AI, Moogsoft — TelemetryGuard es más accesible y agnóstico

---

Stack Tecnológico

Componente	Tecnología
Runtime	Java 25, Virtual Threads (Project Loom)
Framework	Spring Boot 4.0.4 / Spring Framework 7.x
Seguridad	Spring Security 7, JJWT 0.12.6
Persistencia	Spring Data JPA + Hibernate 6.6, H2 (dev) / PostgreSQL (prod)
HTTP Client	Spring Cloud OpenFeign 4.2.1
Serialización	Jackson 3 (tools.jackson.*)
Resiliencia	Resilience4j 2.2.0
LLM	OpenAI-compatible API (GPT-4o por defecto)

---

Cómo Ejecutar

Prerequisitos

• Java 25+ (JDK)
• Maven 3.9+

1. Clonar y compilar

cd solutions/2026-04-16-telemetry-guard-ai
mvn clean compile

2. Ejecutar (modo dev con H2 embebido)

mvn spring-boot:run

La aplicación arranca en http://localhost:8080.

3. Configurar LLM real (opcional)

Añade a application.yml o como variables de entorno:

telemetry-guard:
  llm:
    api-url: https://api.openai.com
    api-key: sk-your-key-here
    model: gpt-4o
  jwt:
    secret: dGVsZW1ldHJ5LWd1YXJkLWFpLWp3dC1zZWNyZXQta2V5LTIwMjY=
    expiration-ms: 86400000

Sin API key, los agentes retornan análisis simulados realistas — el pipeline completo funciona igual.

4. Obtener JWT

curl -X POST http://localhost:8080/api/v1/auth/token \
  -H "Content-Type: application/json" \
  -d '{"username":"admin","password":"admin123"}'

5. Ingestar un incidente

TOKEN="eyJ..."  # del paso anterior

curl -X POST http://localhost:8080/api/v1/ingest \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "source": "Grafana",
    "title": "P99 latency spike — orders service",
    "description": "Error rate jumped to 38%. DB connection pool at 100/100. GC pauses > 4s.",
    "severity": "critical"
  }'

6. Consultar hipótesis (poll hasta COMPLETED)

INCIDENT_ID="550e8400-..."  # del paso anterior

# Estado del incidente
curl -H "Authorization: Bearer $TOKEN" \
  http://localhost:8080/api/v1/incidents/$INCIDENT_ID

# Hipótesis de causa raíz
curl -H "Authorization: Bearer $TOKEN" \
  http://localhost:8080/api/v1/incidents/$INCIDENT_ID/hypothesis

7. Producción con PostgreSQL

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/telemetry_guard
    username: telemetry
    password: secret
  jpa:
    hibernate:
      ddl-auto: update

---

Referencias

• Agentes colaborativos para detección de fallos (arXiv cs.AI)
• Spring Boot 4.0 Reference Documentation
• Java 25 Virtual Threads — Project Loom
• JJWT 0.12 Migration Guide
• OpenAI Chat Completions API
• Spring Cloud OpenFeign 4.2

---

FinOps Analysis para TelemetryGuard

Estimación de Costos Operativos Mensuales

Nuestra proyección de costos operativos mensuales para TelemetryGuard, en su fase de Producto Mínimo Viable (MVP) con 20 clientes iniciales, es de $115 USD.

Desglose de Costos:

• LLM Tokens: Se estima un consumo de aproximadamente 30 millones de tokens al mes. Esto se basa en un escenario donde cada uno de los 20 clientes genera 100 incidentes mensuales, y cada incidente requiere alrededor de 15,000 tokens (entre input y output) para el razonamiento colaborativo de los agentes (gpt-4o-mini). El costo asociado es de $15/mes.

• Infraestructura Cloud (AWS): Para una operación robusta y con alta disponibilidad adecuada para un servicio B2B crítico, se ha considerado:

* Cómputo: Dos instancias EC2 t3.small operando en un Auto Scaling Group detrás de un Application Load Balancer (ALB). Esto asegura redundancia y capacidad de manejo de carga. El costo de las instancias y el ALB se estima en ~$65/mes. * Base de Datos: Una instancia RDS t3.micro de PostgreSQL con 20GB de almacenamiento, con un costo aproximado de ~$18/mes. * Networking y Monitoring: Costos asociados a transferencia de datos, direcciones IP elásticas y servicios básicos de monitoreo (CloudWatch) se estiman en ~$17/mes. * Costo Total de Infraestructura: $100/mes.

Estimación de Ingresos Mensuales y Margen de Beneficio

Con un modelo de monetización API-first SaaS y un precio de $25 por cliente para el MVP, y asumiendo una base inicial de 20 clientes:

Ingresos Mensuales Estimados: 20 clientes $25/cliente = $500/mes.

• Margen de Beneficio:

* Ingresos: $500 * Costos Totales: $115 * Beneficio: $500 - $115 = $385 Margen de Beneficio: (385 / 500) 100 = 77%

Este margen del 77% es saludable para una startup en fase MVP, indicando una buena rentabilidad unitaria por cliente y un modelo de negocio escalable desde la perspectiva de costos operativos directos.

Estrategias de Optimización de Costos (FinOps)

Para mantener y mejorar este margen de beneficio a medida que TelemetryGuard escale, se recomiendan las siguientes estrategias FinOps:

1. Optimización Agresiva de Prompts: Reducir la verbosidad y el tamaño de los prompts enviados a los LLM. Cada token cuenta. Experimentar con diferentes plantillas y técnicas de ingeniería de prompts para obtener la misma calidad de respuesta con menos tokens.
2. Pre-procesamiento Inteligente de Datos: Implementar lógica robusta para filtrar, agregar y resumir la telemetría (logs, métricas, trazas) antes de enviarla a los LLM. Esto reducirá drásticamente el volumen de datos de entrada y, por ende, los costos de tokens.
3. Adopción de Infraestructura Serverless: Migrar los microservicios de Spring Boot a plataformas serverless como AWS Fargate o GCP Cloud Run. Estas plataformas ofrecen escalado a cero (cuando no hay tráfico) y pago por uso, lo que puede reducir significativamente los costos de cómputo en periodos de baja actividad.
4. Estrategias de Caching de LLM: Desarrollar un sistema de caché para almacenar y reutilizar resultados de análisis de LLM para incidentes recurrentes o patrones de fallos conocidos. Esto evitaría llamadas redundantes a la API del LLM.
5. Diversificación de Modelos LLM: Evaluar si todas las tareas de los agentes requieren el mismo nivel de capacidad del LLM. Podría ser posible utilizar modelos más pequeños y económicos para tareas de análisis preliminar o filtrado, reservando los modelos más potentes (y costosos) para la síntesis final o el razonamiento complejo.
6. Monitoreo de Consumo de Recursos: Implementar un monitoreo detallado del uso de LLM (tokens por solicitud, costo por solicitud) y de los recursos de infraestructura. Esto permitirá identificar rápidamente cualquier anomalía o ineficiencia en el uso de recursos y aplicar correcciones proactivas.