{"canonical_url":"https://engineer.company/es/glossary/observability/","content_markdown":"# Observabilidad\n\n## Qué es\n\nLa observabilidad es el grado en que un equipo puede entender desde fuera lo que\nhace un sistema en ejecución, utilizando solo los datos que este emite, sin\nabrirlo ni saber de antemano qué ha fallado. La introducción del proyecto\nOpenTelemetry lo plantea en términos de preguntas: un sistema observable permite\nhacer preguntas sobre él sin conocer su funcionamiento interno, incluidas\npreguntas que nadie se había planteado cuando se escribió el software. La\nfórmula breve de esa introducción para la pregunta que debería poder responder\nes «¿Por qué está ocurriendo esto?».\n\nEso hace de la observabilidad una propiedad del sistema, no un producto. Una\nherramienta puede almacenar y mostrar datos, pero antes esos datos tienen que\nsalir de la aplicación. La documentación de OpenTelemetry es clara: para que un\nsistema sea observable, sus componentes deben estar instrumentados, es decir, su\ncódigo debe emitir señales. Después fija un criterio práctico. Una aplicación se\nconsidera correctamente instrumentada cuando sus señales existentes permiten a\nlos desarrolladores investigar un problema sin cambiar primero la\ninstrumentación.\n\nEsos datos se llaman telemetría, y OpenTelemetry los clasifica en señales:\n\n- **Las trazas** registran el recorrido de una petición por el sistema. Una\n  traza se compone de spans, cada uno una unidad de trabajo con un nombre, un\n  tiempo de inicio y de fin y atributos como el método y la ruta HTTP. El primer\n  span es la raíz y abarca la petición de principio a fin.\n- **Las métricas** son mediciones recogidas durante la ejecución y agregadas a\n  lo largo del tiempo: tasa de errores, tasa de peticiones o uso del procesador.\n- **Los registros** son anotaciones de eventos con marca temporal. Muchos no\n  están vinculados a una petición concreta.\n- **Baggage** es información contextual que se transmite junto con una petición\n  para que otras señales puedan utilizarla.\n\nLa página de señales también enumera los eventos, un tipo específico de\nregistro, y los perfiles, registros del uso de recursos a nivel de código, como\nelementos en desarrollo o en fase de propuesta.\n\nLo que convierte tres montones de datos en algo que un equipo puede interrogar\nes la correlación. OpenTelemetry propaga contexto entre servicios, de modo que\nun span de un servicio sabe a qué traza pertenece, y puede incorporar los\nidentificadores de la traza y del span activos a cada registro. Cada señal\ntambién incluye un recurso: atributos que identifican la entidad que la produce,\ncomo el nombre del servicio, el host o el contenedor. Con esas claves\ncompartidas, un equipo puede pasar de una métrica a las peticiones que hay\ndetrás y de una petición a las líneas de registro que produjo.\n\nLa observabilidad y la monitorización se solapan, pero no son lo mismo. La\nmonitorización vigila condiciones que alguien decidió de antemano que eran\nrelevantes y genera una alerta cuando aparece alguna. La observabilidad es\naquello con lo que puede trabajar el equipo una vez que ha saltado la alerta y\nla causa es algo que nadie había previsto.\n\n## Por qué importa\n\nLos sistemas modernos fallan de formas difíciles de predecir. Una petición puede\npasar por una puerta de enlace, varios servicios, una cola y una base de datos\nantes de recibir respuesta, y un fallo en cualquiera de ellos puede manifestarse\ncomo lentitud en otro lugar. La introducción considera esencial el rastreo\ndistribuido para estos sistemas, porque sus problemas suelen ser no\ndeterministas o demasiado complejos para reproducirlos en el equipo de un\ndesarrollador. Cuando un fallo no se puede reproducir, la telemetría registrada\nmientras ocurría es la única evidencia disponible.\n\nLos paneles y las alertas responden a preguntas previstas. Eso es valioso y\ncubre los fallos que un equipo ya ha visto. Los incidentes difíciles son los\nnuevos, donde la pregunta no es si subieron las tasas de error, sino por qué\nempezaron a fallar peticiones de una región, a través de una versión, hacia un\nproveedor de pagos. Si responder exige escribir código nuevo, desplegarlo y\nesperar a que reaparezca el problema, la interrupción dura tanto como ese ciclo\ncompleto.\n\nLa observabilidad también mantiene al usuario en primer plano. La introducción\ndefine la fiabilidad como el hecho de que el servicio haga lo que esperan los\nusuarios y da un ejemplo: una tienda podría estar siempre disponible y seguir\nsiendo poco fiable si al pulsar para añadir zapatos negros al carrito no se\nañaden siempre zapatos negros. Una métrica del host nunca mostraría eso. La\ntelemetría a nivel de petición sí puede hacerlo y es la base de los indicadores\nde nivel de servicio: mediciones desde el punto de vista del usuario, que los\nobjetivos de nivel de servicio vinculan después con las necesidades del negocio.\n\nPor último, cambia el coste de un incidente. Un equipo que puede seguir una\npetición lenta hasta la llamada exacta que la retrasó dedica su tiempo a\ncorregir en vez de hacer conjeturas, y el análisis posterior puede citar\nevidencias en lugar de recuerdos.\n\n## Cómo se aplica en la práctica\n\nConsidere una tienda en línea inventada. Desde las 14:00, una pequeña parte de\nlas finalizaciones de compra tarda más de dos segundos. Nada está caído, no ha\nsaltado ninguna alerta y no se creó ningún panel para este caso. Así lo\ninvestigaría un equipo con señales correlacionadas. Todos los nombres,\nidentificadores y números que aparecen a continuación se han inventado para el\nejemplo.\n\nEl primer paso es el histograma de latencia de la finalización de compra, medida\nen segundos. En el formato de texto OpenMetrics, un intervalo puede incluir un\nejemplar después de `#`: una referencia a datos externos a la métrica,\nnormalmente el identificador de una traza correspondiente a ese intervalo. Dos de los\nintervalos se muestran así:\n\n```text\ncheckout_bucket{le=\"1.0\"} 95\ncheckout_bucket{le=\"2.5\"} 97 # {trace_id=\"3f1c9a77e2b04d18a6c5e0b9d4127f60\"} 2.3\n```\n\nEl segundo paso sigue ese identificador de traza. La traza muestra en qué se\nemplearon los 2,3 segundos, span a span:\n\n```text\nPOST /checkout                       2.30 s   service checkout\n  SELECT cart                        0.04 s   service checkout\n  POST /authorise                    2.21 s   service payments\n    event: provider timeout, retrying\n  INSERT order                       0.03 s   service checkout\n```\n\nEl tercer paso recupera las líneas de registro con el mismo identificador de\ntraza. La especificación de OpenTelemetry para registros escritos en formatos\ndistintos de su propio protocolo pide registrar los identificadores como campos\nde nivel superior llamados `trace_id` y `span_id` en JSON, en minúsculas y codificados en\nhexadecimal:\n\n```json\n{\n    \"timestamp\": 1793110051.402,\n    \"severity\": \"WARN\",\n    \"body\": \"provider timeout after 2000 ms, retrying\",\n    \"provider\": \"acquirer-b\",\n    \"trace_id\": \"3f1c9a77e2b04d18a6c5e0b9d4127f60\",\n    \"span_id\": \"a91c04e7d2f3b658\"\n}\n```\n\nTres saltos, y la pregunta que nadie había previsto tiene respuesta: uno de los\ndos proveedores de pagos empezó a agotar el tiempo de espera, y cada compra que\nse le enviaba esperaba un reintento. Ahora se puede agrupar por el mismo\natributo, `provider`, en todas las trazas recientes para confirmar el patrón antes de\nque nadie toque el código.\n\nNada de eso funciona si los servicios no se identifican. Los SDK de\nOpenTelemetry establecen el atributo de recurso `service.name` en `unknown_service` de forma predeterminada, y la\ndocumentación recomienda establecerlo explícitamente, en el código o mediante\nuna variable de entorno. Se pueden añadir otros atributos de recurso de la misma\nmanera:\n\n```sh\nenv OTEL_SERVICE_NAME=checkout \\\n    OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=production \\\n    ./checkout\n```\n\nEn este sitio, tres entradas del portafolio muestran cómo se fue construyendo la\nobservabilidad por etapas. Una describe [el primer panel de observabilidad de una empresa](/es/portfolio/built-the-companys-first-observability-dashboard/), que recopilaba métricas del sistema\ncomo CPU, memoria y disco de servidores Linux remotos por SSH; más adelante se\ncreó una segunda versión sobre Grafana y Prometheus. El trabajo para [reducir el riesgo operativo con Grafana y Prometheus](/es/portfolio/cut-operational-risk-with-grafana-and-prometheus/)\ninstrumentó los servicios clave y eligió métricas significativas en lugar de\ncifras de vanidad. Una entrada posterior, [monitorización de errores y trazado propios](/es/portfolio/built-first-party-error-monitoring-and-tracing/), añadió trazado OpenTelemetry\nsobre OTLP, de modo que una petición lenta pueda seguirse por el frontend, la\nAPI y la base de datos en lugar de recurrir a conjeturas, junto con un\nflujo de procesamiento de errores que sanea las cargas útiles antes de\nalmacenarlas.\n\n## Dónde surgen los problemas\n\n**Comprarla en vez de incorporarla al sistema.** Una herramienta nueva a la que\nno llega nada útil es una sala vacía. La observabilidad nace de la\ninstrumentación del código y las bibliotecas, así que presupueste tiempo de\ningeniería para añadir spans, atributos y campos de registro, no solo la\nlicencia.\n\n**Tres señales, tres islas.** Las métricas en una herramienta, los registros en\notra y las trazas en una tercera, sin una clave compartida, dejan al equipo\ncopiando marcas temporales de una pantalla a otra. Incluya los identificadores\nde traza y span en cada registro, adjunte ejemplares a los histogramas de\nlatencia donde la pila los admita y dé a cada señal los mismos atributos de\nrecurso.\n\n**Todos los servicios se llaman unknown_service.** Es el valor predeterminado\ndel SDK, y no se pueden distinguir los servicios de una flota que lo comparte.\nEstablezca `OTEL_SERVICE_NAME` para cada servicio. El recurso se adjunta al crear los\nproveedores de trazas y métricas y no puede cambiarse después, así que debe ser\ncorrecto desde el arranque.\n\n**Solo se instrumentan los extremos.** La instrumentación sin código es un buen\ncomienzo y registra lo que ocurre en los extremos de una aplicación: en sus\nbibliotecas y en el entorno donde se ejecuta. Las preguntas de un incidente\nsuelen referirse al negocio: qué nivel de cliente, qué proveedor o qué valor de\nuna bandera de funcionalidad. Para eso hacen falta atributos añadidos en el\ncódigo. La documentación de OpenTelemetry presenta la instrumentación mediante\ncódigo como complemento de la instrumentación sin código, y ambas pueden\nfuncionar a la vez.\n\n**Instrumentar durante el incidente.** Si la respuesta exigió una nueva línea de\nregistro y un despliegue, el sistema no estaba correctamente instrumentado según\nel criterio de la propia introducción. Convierta «¿qué tuvimos que añadir?» en\nuna pregunta fija de cada revisión de incidente y trate cada respuesta como una\ntarea de seguimiento.\n\n**Detalle sin límites en la señal equivocada.** Los identificadores de usuario,\nlas URL completas y los cuerpos de petición pertenecen a los spans y los\nregistros, no a las etiquetas de métricas, donde cada valor nuevo crea otra\nserie temporal. El estándar OpenMetrics limita los nombres y valores de\netiquetas de un ejemplar a 128 caracteres en total, precisamente para impedir\nque los ejemplares transporten datos de spans, y permite que un receptor\ndescarte por completo los ejemplares. Compruebe que los enlaces sobreviven a\ntodo el recorrido desde el exportador hasta la pantalla antes de confiar en\nellos.\n\n**Telemetría que filtra información.** Los spans y los registros recogen el\ncontenido de las peticiones, que puede incluir direcciones, nombres y tokens.\nDecida qué atributos pueden registrarse, elimine el resto antes del\nalmacenamiento y proteja la telemetría con el mismo cuidado que la base de datos\nque describe.\n\n## Lecturas adicionales\n\n- [Introducción a la observabilidad](https://opentelemetry.io/docs/concepts/observability-primer/)\n  — definición del proyecto OpenTelemetry, con fiabilidad, SLI y SLO, spans y\n  trazas distribuidas.\n- [Señales](https://opentelemetry.io/docs/concepts/signals/)\n  — trazas, métricas, registros y baggage, y las señales aún en desarrollo.\n- [Instrumentación](https://opentelemetry.io/docs/concepts/instrumentation/)\n  — instrumentación mediante código y sin código, y cómo la propagación de\n  contexto enlaza las señales.\n- [Recursos](https://opentelemetry.io/docs/concepts/resources/)\n  — atributos de recurso, el valor predeterminado `unknown_service` y las variables de entorno\n  que los establecen.\n- [Contexto de traza en formatos de registro distintos de OTLP](https://opentelemetry.io/docs/specs/otel/compatibility/logging_trace_context/)\n  — especificación estable para registrar identificadores de traza y span en\n  syslog, texto plano y registros JSON.\n- [OpenMetrics 1.0](https://prometheus.io/docs/specs/om/open_metrics_spec/)\n  — estándar del formato de exposición, incluidos los ejemplares y sus\n  recomendaciones sobre cardinalidad.\n\n\u003chttps://engineer.company/es/glossary/observability/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Qué es la observabilidad, cómo los identificadores compartidos unen trazas, métricas y registros, y qué hábitos dificultan investigar un sistema.","formats":{"gemtext":"https://engineer.company/es/glossary/observability/index.gmi","gopher":"https://engineer.company/es/glossary/observability/gophermap","html":"https://engineer.company/es/glossary/observability/","json":"https://engineer.company/es/glossary/observability/index.json","markdown":"https://engineer.company/es/glossary/observability/index.md","pdf":"https://engineer.company/es/glossary/observability/index.pdf"},"kind":"page","language":"es","title":"¿Qué es la observabilidad?","url":"https://engineer.company/es/glossary/observability/","version":1}