OpenTelemetry¶

Descripción¶

OpenTelemetry es un framework de observabilidad que proporciona APIs, librerías, agentes y herramientas para instrumentar, generar, recolectar y exportar telemetría (métricas, logs y traces).

Configuración¶

otel-collector:
  image: otel/opentelemetry-collector-contrib
  container_name: otel-collector
  volumes:
    - ./otel-collector-config.yml:/etc/otel-collector-config.yml
  command: ["--config", "/etc/otel-collector-config.yml"]
  environment:
    VIRTUAL_HOST: otel.seekdev.com
    VIRTUAL_PORT: 4318
    LETSENCRYPT_HOST: otel.seekdev.com
    LETSENCRYPT_EMAIL: jgarcia@seek.pe
  ports:
    - "4317:4317"  # OTLP gRPC
    - "4318:4318"  # OTLP HTTP
  networks:
    - sonarnet

Configuración del Collector¶

El archivo otel-collector-config.yml define la configuración:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:
    timeout: 1s
    send_batch_size: 1024

exporters:
  prometheus:
    endpoint: "0.0.0.0:9464"
    namespace: "otel"
    const_labels:
      label1: value1
  logging:
    loglevel: debug

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus, logging]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [logging]

Instrumentación de Aplicaciones¶

Node.js¶

const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-http');

const provider = new NodeTracerProvider();
const exporter = new OTLPTraceExporter({
  url: 'https://otel.seekdev.com:4318/v1/traces'
});

provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
provider.register();

Python¶

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

provider = TracerProvider()
processor = BatchSpanProcessor(
    OTLPSpanExporter(endpoint="https://otel.seekdev.com:4318/v1/traces")
)
provider.add_span_processor(processor)
trace.set_tracer_provider(provider)

Java¶

import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
    .setEndpoint("https://otel.seekdev.com:4317")
    .build();

SdkTracerProvider sdkTracerProvider = SdkTracerProvider.builder()
    .addSpanProcessor(BatchSpanProcessor.builder(exporter).build())
    .build();

Métricas Personalizadas¶

Definición de Métricas¶

const { MeterProvider } = require('@opentelemetry/metrics');
const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');

const meter = new MeterProvider().getMeter('my-service');
const counter = meter.createCounter('requests_total', {
  description: 'Total number of requests'
});

// Uso
counter.add(1, { endpoint: '/api/users' });

Traces Distribuidos¶

Propagación de Contexto¶

const { trace } = require('@opentelemetry/api');

const tracer = trace.getTracer('my-service');

async function processRequest(req, res) {
  const span = tracer.startSpan('process-request');

  try {
    // Procesar request
    const result = await callExternalService();
    span.setStatus({ code: SpanStatusCode.OK });
    res.json(result);
  } catch (error) {
    span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
    res.status(500).json({ error: error.message });
  } finally {
    span.end();
  }
}

Integración con Monitoreo¶

Prometheus¶

Métricas automáticas de la aplicación
Métricas del sistema
Métricas personalizadas

Grafana¶

Dashboards de traces
Visualización de métricas
Alertas basadas en telemetría

Jaeger (Opcional)¶

Visualización de traces
Análisis de performance
Debugging de requests

Mejores Prácticas¶

Instrumentación Automática: Usar agentes automáticos cuando sea posible
Sampling: Configurar sampling apropiado para producción
Métricas Clave: Definir métricas de negocio importantes
Traces Significativos: Crear spans con información útil
Monitoreo de Performance: Evitar overhead en la aplicación