Description
El servicio corre. Devuelve 200 en la demo, el deploy está en verde, y todos siguen con lo suyo, y después son las 3am y el checkout está roto y abrís el dashboard y todos los paneles están en verde. El dashboard medía si los servidores estaban arriba, no si algo funcionaba, y eso se volvió en silencio dos cosas distintas. Vas a los logs y son una pared de chatter rutinario a nivel info con el error real enterrado en algún lado que no podés grepear, impreso como un string plano sin request id, así que no podés seguir el único request que falla a través de todo eso. El request tocó tres servicios y no tenés forma de ver en qué parte de esa cadena se fue el tiempo o arrancó el error. Hay una alerta, y disparó, pero disparó porque un disco cruzó el 80 por ciento, que no le importa a nadie, y nunca disparó por la cosa que de verdad está caída. Un agente te va a entregar un servicio exactamente así: corre, y es invisible. La herramienta se queda muda sobre la diferencia, porque un servicio sin logs, sin métricas, sin traces y con una alerta de disco deploya igual que uno que podés ver por dentro. Lo que te falta no es una herramienta. Es el criterio para mirar un servicio corriendo y saber si producción es visible, y hacerla visible antes de la noche en que la necesitás.
Este libro te entrena para ver qué hace tu software en producción, y para quedarte con esa visibilidad como un revisor se queda con un diff. Arranca desde donde de verdad está la mayoría de los ingenieros: el código sube, quizás lo escribió un agente, corre, y nadie chequeó si lo podías ver correr. Así que el libro enseña los tres pilares desde cero, usando un servicio que instrumentás de punta a punta en cada capítulo, una API de notas llamada Quill con un endpoint de resumen que llama a un modelo, para que las lecciones se acumulen en vez de resetearse. Aprendés logging estructurado que una persona puede buscar bajo presión, con niveles que significan algo y un correlation id que te deja seguir un request a través del ruido. Aprendés las métricas que de verdad cazan caídas, RED y USE, counters y gauges e histogramas, y por qué un gráfico de latencia p99 te dice lo que un promedio esconde. Aprendés tracing distribuido, siguiendo un solo request a través de servicios para encontrar dónde viven el tiempo y la falla. Aprendés a armar dashboards que se ponen en rojo cuando los usuarios sufren en vez de quedarse en verde durante una caída, y alertas que le avisan a una persona por un síntoma roto en lugar de un disco lleno, sin quemar a la rotación de guardia con ruido. Aprendés error tracking que agrupa y contextualiza fallas reales en vez de ahogarte en duplicados, visibilidad de guardia e incidentes, cuándo agarrar un log contra una métrica contra un trace, y qué cuesta la observabilidad para que la factura y la cardinalidad no te sorprendan. El hilo conductor es la pregunta de un revisor hecha de día, con calma, en un cronograma: si producción se rompiera ahora mismo, ¿podrías decir qué está mal, y qué tan rápido? Para ingenieros que van a subir servicios igual y quieren ser los que los pueden ver cuando importa.
Para quién lo escribimos
Este libro es para: ingenieros que suben código que ahora corre en producción, muchas veces código que escribió un agente de IA, y que se quedan con la pregunta que nadie contestó mientras se construía, que es si de verdad podés ver qué hace el software una vez que le pegan usuarios reales. Sabés escribir un servicio y dejarlo deployado. Lo que todavía no sabés hacer es decir, a las 3am con el checkout roto, qué está fallando y por qué, porque el servicio no loguea nada que puedas buscar, no expone ninguna métrica atada a si funciona, no lleva un trace a través de los tres servicios que toca un request, y te avisa cuando un disco está al 80 por ciento mientras se queda mudo cuando los pagos se cortan. Este libro asume que sabés leer código y deployar un servicio; no asume que hayas instrumentado uno alguna vez. Enseña la postura del revisor frente a la visibilidad de producción: no cómo instalar una herramienta, sino cómo juzgar si podrías ver venir una caída y verla con claridad una vez que arrancó.
Con qué te vas a quedar
- Capítulo 1: El servicio corre. ¿Podés ver qué está haciendo?
- Capítulo 2: Tus logs son una pared de ruido justo cuando necesitás grepearlos
- Capítulo 3: El dashboard estaba en verde mientras los servidores andaban bien y nada funcionaba
- Capítulo 4: El request tocó tres servicios y no tenés idea de dónde se rompió
- Capítulo 5: El dashboard verde durante la caída, y cómo armar uno que se ponga en rojo
- Capítulo 6: El pager sonó por un disco lleno y se quedó mudo durante la caída
- Capítulo 7: El mismo error pasó diez mil veces y lo viste una
- Capítulo 8: Es tu noche de guardia. ¿Qué agarrás primero de verdad?
- Capítulo 9: Un log, una métrica o un trace: ¿cuál responde la pregunta que tenés?
- Capítulo 10: La factura de observabilidad que costó más que la cosa que miraba
- Capítulo 11: Cableando un servicio real para poder ver todo lo que hace
- Capítulo 12: Del ingeniero que lo subió al que lo puede ver
