Introducción a Open Source Observability

Con frecuencia existe la necesidad de monitorear la operación de los servicios que desplegamos cuando hacemos actualizaciones de software. Las aplicaciones más sencillas se pueden dar a basto con una simple supervisión de logs, tal vez alguna herramienta ad-hoc o por medio de la creación de un tablero que calcule métricas en tiempo real sobre lo que está sucediendo.

Para el resto de los servicios que tratan con workflows más sofisticados y que tienen múltiples cajas negras a lo largo de su ejecución recurrimos a medios que nos permitan medir exactamente lo que está ocurriendo sin que esto represente un costo de rendimiento. Un framework o suite de Observability satisface perfectamente esta necesidad.

Datadog es una excelente solución que ofrece una gran gama de soluciones para monitorear múltiples dimensiones en nuestro software: trazas, logs, metrics, alertas, rendimiento, profiling, entre otros. A veces entre la necesidad real y el presupuesto disponible, la propuesta de una solución como Datadog puede no ser la adecuada, inclusive porque no se le sacaría gran parte de su rendimiento potencial. Aquí es donde podemos aprovechar la disponibilidad de herramientas open source que nos brindan muchas de las funcionalidades de soluciones de observabilidad populares, con un rendimiento similar a un costo más rentable.

Scope

El objetivo de este artículo es presentar un setup con ejemplos funcionales en javascript/typescript o python en la capa de aplicación y con el stack de tecnología propuesto que cumplen con las siguientes funciones:

• Logs y búsqueda de logs
• Traces o trazas
• Instrumentación manual y automática
• Reporte de métricas

Suite Open Source

Grafana

Grafana es una plataforma open-source para la visualización de data y monitoreo que permite analizar y ver la data en series de tiempo. Soporta integraciones por medio de data sources que permite a los equipos monitorear sistemas, aplicaciones, servidores, base de datos y métricas de negocio utilizando dashboard interactivos.

Tempo

Grafana Tempo es otra herramienta de open-source para el tracing de backend distribuido. Permite enviar, guardar y buscar trazas, es decir los registros de ejecución en la aplicación que estén instrumentados. Ejemplos de traza pueden ser:

• La ejecución de un api request
• Llamados a múltiples servicios de backend
• Queries a base de datos

Una traza va a permitir visualizar: cuánto tiempo tomó un servicio, cuantos errores ocurrieron – inclusive logs registrados de por medio – y cuales servicios estuvieron involucrados.

Loki

Grafana Loki es un sistema de agregación de logs open-source. Colecciona, guarda y te permite hacer consultas sobre tus logs de aplicación de manera más eficiente que sistemas de logs tradicionales.

Prometheus

Prometheus es un toolkit open-source que permite monitorear y crear alertas utilizado para coleccionar y guardar métricas out-of-box – como uso de CPU, memoria, cantidad de requests, porcentaje de error y latencia – y personalizadas a las necesidades de negocio, imaginemos medidas de frustración, cantidad de reintentos o tiempo de interacción por servicio determinado.

Instrumentando Código

Antes de que un app pueda reportar data sobre su ejecución es necesario la implementación de telemetría. Esta funcionalidad permite la medición, recopilación y comunicación de estos datos. Una vez se implementa entonces nuestro código es “instrumentable”. Hay dos tipos de instrumentación: manual y automática. La instrumentación automática depende de soporte de librerías de terceros que ya activamente reportan las métricas de sus funcionalidades core. En el caso de un framework MVC podrían ser las ejecuciones de cada uno de sus endpoints. La instrumentación manual es aquella que se diseña y desarrolla intencionalmente, por ejemplo la cobertura de un lote de procesamiento de archivos. A continuación se muestran ejemplos de instrumentación automática en python y javascript:

# manage.py
import os
import sys


from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.django import DjangoInstrumentor
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor


def main():


   resource = Resource(attributes={SERVICE_NAME: "my-service"})


   otlp_exporter = OTLPSpanExporter(
       endpoint=os.environ.get("OPEN_TELEMETRY_HOST"),
   )


   provider = TracerProvider(resource=resource)
   processor = BatchSpanProcessor(otlp_exporter)
   provider.add_span_processor(processor)


   trace.set_tracer_provider(provider)


   DjangoInstrumentor().instrument()


   from django.core.management import execute_from_command_line
  
   execute_from_command_line(sys.argv)


if __name__ == "__main__":
   main()

# wsgi.py

from django.core.wsgi import get_wsgi_application
from opentelemetry.instrumentation.wsgi import OpenTelemetryMiddleware

application = get_wsgi_application()
application = OpenTelemetryMiddleware(application)

// instrumentation.js
import { trace } from '@opentelemetry/api';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
import { resourceFromAttributes } from '@opentelemetry/resources';

export const setupTelemetry = () => {
 const exporter = new OTLPTraceExporter({});
 const provider = new NodeTracerProvider({
   resource: resourceFromAttributes({
     [ATTR_SERVICE_NAME]: ‘express’,
   }),
   spanProcessors: [new SimpleSpanProcessor(exporter)],
 });
 registerInstrumentations({
   tracerProvider: provider,
   instrumentations: [
     new HttpInstrumentation(),
     new ExpressInstrumentation(),
   ],
 });

 provider.register();

 return trace.getTracer(serviceName);
};

// app.js
import { setupTelemetry } from './instrumentation';

setupTelemetry();

import * as express from 'express';

const app = express();

...

¿Como funciona?

Al instalar, configurar cada servicio y tener el app instrumentada lo único que falta es agregar “datasources” en el dashboard de Grafana. Mientras ejecuta la aplicación cada instancia de proceso, log y métrica será exportada o extraída, procesada y luego entregada a Grafana para poder observar y analizar.

Resultado

Una vez se han parametrizado los requisitos en el app hay una trazabilidad de todos los procesos que hemos instrumentado. Podemos conectar trazas a los logs, y entender lo que ocurre en cada uno de los workflows que se estén ejecutando.

Unos de los casos de uso más comunes es el de desarrollar un feature nuevo, instrumentarlo y una vez se despliega en ambientes productivos en cuestión de segundos por medio de los dashboard “drilldown” de Grafana o personalizados se puede monitorear cómo está rindiendo el nuevo feature.

Se muestra la traza de un servicio con múltiples componentes

Tener transparencia sobre la ejecución de aplicaciones complejas no solo es útil para un equipo de IT sino que también permite a cualquier área interesada ver lo que está pasando en tiempo real. La data recopilada por las distintas fuentes genera oportunidades para iterar sobre el desarrollo software con evidencias y retroalimentación sobre qué priorizar y puntos para mejorar. Finalmente el diseño de software que está consistentemente tomando en cuenta su instrumentación crea una cultura de conciencia en el equipo de hacer visible la mayor cantidad de información posible por defecto en vez de un pensamiento de último orden.

Logs filtrados por actividad de usuario.