Aller au contenu principal

OpenTelemetry

Overview​

OpenTelemetry (OTel), c'est le framework d'observabilité CNCF qui pense que l'instrumentation doit être standard, pas propriétaire. Il unifie la collecte de métriques, logs et traces avec un seul SDK et un format de données commun. Fusion d'OpenTracing et OpenCensus, c'est maintenant LE standard pour l'observabilité cloud-native. Si tu veux instrumenter tes applications sans vendor lock-in, c'est parfait.

OpenTelemetry fournit des SDKs pour tous les langages populaires, une instrumentation automatique pour les frameworks courants, et des collecteurs pour router les données vers n'importe quel backend (Jaeger, Prometheus, Grafana, Datadog, etc.). Un standard, tous les backends compatibles.

OpenTelemetry se distingue par son statut de standard universel (CNCF, tous les vendors supportent), son approche unifiée (metrics, logs, traces dans un même framework), et sa flexibilité totale (instrumenter une fois, changer de backend quand tu veux).

Informations essentielles​

PropriétéValeur
Site officielhttps://opentelemetry.io/
Repositoryhttps://github.com/open-telemetry
LicenceApache 2.0
OrganisationCNCF (Cloud Native Computing Foundation)
Langages SDKsJava, .NET, Python, Go, JavaScript, Rust, C++, PHP, Ruby
Backends supportésJaeger, Prometheus, Grafana, Datadog, New Relic, AWS X-Ray, Azure Monitor, etc.

Fonctionnalités principales​

SDKs multi-langages​

  • APIs standardisées pour tous les langages
  • Instrumentation automatique pour frameworks populaires
  • Instrumentation manuelle fine-grained
  • Context propagation entre services
  • Sampling configurable par langage

Collecteur OpenTelemetry​

  • Réception, traitement et export des données
  • Transformation et enrichissement des données
  • Load balancing et retry logic
  • Support batch processing et streaming
  • Extensible via processors custom

Signaux d'observabilité unifiés​

  • Traces : distributed tracing avec spans
  • Métriques : counters, gauges, histogrammes
  • Logs : structured logging avec corrélation
  • Context propagation automatique entre signaux
  • Semantic conventions pour standardiser les données

Écosystème vendor-neutral​

  • Export vers tous les backends populaires
  • Pas de vendor lock-in
  • Format de données OTLP (OpenTelemetry Protocol)
  • Interopérabilité garantie
  • Migration facilitée entre solutions

Cas d'usage​

  • Standardisation observabilité : Unifier l'instrumentation à travers l'organisation
  • Migration backends : Changer de solution d'observabilité sans re-instrumenter
  • Observabilité multi-cloud : Envoyer les données vers plusieurs backends simultanément
  • Debugging distribué : Corréler automatiquement traces, métriques et logs
  • Future-proofing : Utiliser le standard qui va s'imposer universellement

Installation​

SDK Python​

pip install opentelemetry-api opentelemetry-sdk
pip install opentelemetry-auto-instrumentation

SDK Java​

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-api</artifactId>
    <version>1.32.0</version>
</dependency>
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-sdk</artifactId>
    <version>1.32.0</version>
</dependency>

Collecteur OpenTelemetry​

# Via Docker
docker run -p 4317:4317 -p 4318:4318 \
  -v $(pwd)/otel-collector-config.yml:/etc/otelcol-contrib/config.yaml \
  otel/opentelemetry-collector-contrib:latest

# Via binaire
curl -L -o otelcol-contrib https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v0.91.0/otelcol-contrib_0.91.0_linux_amd64
chmod +x otelcol-contrib
./otelcol-contrib --config=config.yaml

Utilisation basique​

Instrumentation automatique (Python)​

# Avec auto-instrumentation
from opentelemetry.instrumentation.auto_instrumentation import AutoInstrumentation

# Configuration
import os
os.environ["OTEL_SERVICE_NAME"] = "my-service"
os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "http://localhost:4317"

# Auto-instrumentation Flask/Django/FastAPI/etc.
AutoInstrumentation().instrument()

# Votre application démarre normalement
from flask import Flask
app = Flask(__name__)
# Instrumentation automatique appliquée !

Instrumentation manuelle (Go)​

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/trace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/trace"
)

func initTracer() {
    exporter, _ := otlptracegrpc.New(context.Background(),
        otlptracegrpc.WithEndpoint("localhost:4317"),
        otlptracegrpc.WithInsecure(),
    )
    
    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceNameKey.String("my-service"),
        )),
    )
    
    otel.SetTracerProvider(tp)
}

Configuration collecteur​

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

processors:
  batch:
  memory_limiter:
    limit_mib: 512

exporters:
  jaeger:
    endpoint: jaeger:14250
    tls:
      insecure: true
  prometheus:
    endpoint: "0.0.0.0:8889"
  loki:
    endpoint: http://loki:3100/loki/api/v1/push

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [jaeger]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [prometheus]

Avantages​

  • ✅ Standard universel : CNCF project, tous les vendors supportent, c'est pérenne
  • ✅ Vendor agnostic : instrumenter une fois, changer de backend quand tu veux, pas de lock-in
  • ✅ Auto-instrumentation : frameworks populaires instrumentés automatiquement, zéro effort
  • ✅ Écosystème mature : SDKs stables pour tous les langages, communauté active
  • ✅ Signals unifiés : traces, métriques, logs corrélés automatiquement, vue d'ensemble complète

Limitations​

  • Écosystème encore en évolution pour certains langages : mais les principaux sont stables
  • Configuration initiale peut sembler complexe : mais l'auto-instrumentation simplifie beaucoup
  • Overhead de performance avec instrumentation complète : mais le sampling gère ça intelligemment

Alternatives​

  • Propriétaires : Datadog APM, New Relic, Dynatrace (vendor lock-in)
  • Legacy : OpenTracing + OpenCensus (maintenant fusionnés dans OTel)
  • Spécialisés : Jaeger seul, Prometheus seul (limités à un signal)

Ressources​