Java einfach erklärt

Spring

OpenTelemetry in Spring Boot: Automatische Instrumentierung mit dem JVM-Agent

Mit der wachsenden Bedeutung verteilter Systeme und Microservices in der modernen Softwareentwicklung wird die Observierbarkeit von Anwendungen immer wichtiger. Entwickler möchten nicht nur Fehler schneller finden, sondern auch die Performance von Anwendungen überwachen und verbessern. OpenTelemetry, ein Open-Source-Framework für Observability, bietet hierfür eine umfassende Lösung. In Kombination mit Spring Boot ermöglicht es eine leistungsstarke Überwachung und Nachverfolgung (Tracing) von Anfragen in Microservices-Architekturen. In diesem Artikel erläutern wir die Grundlagen von OpenTelemetry, den Einsatz in Spring Boot und die automatische Instrumentierung mittels des JVM-Agents.

Was ist OpenTelemetry?

OpenTelemetry ist ein CNCF-Projekt (Cloud Native Computing Foundation), das standardisierte APIs, SDKs und Tools für Tracing, Metriken und Logs bereitstellt. Ziel ist es, die Observierbarkeit von Anwendungen zu erleichtern, indem Entwickler eine einheitliche und technologieübergreifende Plattform nutzen können. OpenTelemetry unterstützt zahlreiche Sprachen und Frameworks, darunter Java und Spring Boot.

Mit OpenTelemetry können Entwickler:

  • Traces: Die Ausführung von Anfragen über mehrere Dienste hinweg nachverfolgen.
  • Metriken: Leistungsdaten wie Latenzzeiten und Durchsatz sammeln.
  • Logs: Relevante Ereignisse und Fehler dokumentieren.

Spring Boot und Observierbarkeit

Spring Boot ist eines der am häufigsten verwendeten Frameworks für die Entwicklung von Microservices. Die Observierbarkeit solcher Anwendungen ist entscheidend, da ein Fehler in einem Service zu einem Kaskadeneffekt führen kann, der die gesamte Anwendung beeinträchtigt. Mit Spring Boot lassen sich Observability-Tools wie OpenTelemetry nahtlos integrieren.

Während die manuelle Instrumentierung (d.h. das Hinzufügen von Tracing-Logik im Code) möglich ist, ist sie oft zeitaufwändig und fehleranfällig. Hier kommt die automatische Instrumentierung ins Spiel, die durch den OpenTelemetry JVM-Agent realisiert wird.

Automatische Instrumentierung mit dem JVM-Agent

Was ist der OpenTelemetry JVM-Agent?

Der JVM-Agent ist ein Java-Agent, der zur Laufzeit an die JVM (Java Virtual Machine) angehängt wird. Er modifiziert die Bytecode-Ausführung und fügt automatisch Tracing- und Metrik-Funktionalitäten hinzu, ohne dass Änderungen am Anwendungscode erforderlich sind. Dies ist besonders nützlich in Szenarien, in denen manuelle Instrumentierung unpraktisch ist.

Vorteile des JVM-Agents:

  1. Keine Codeänderungen: Entwickler müssen keine spezifischen OpenTelemetry-Bibliotheken in ihre Anwendung einbinden.
  2. Zeitersparnis: Automatische Instrumentierung reduziert den Entwicklungsaufwand erheblich.
  3. Konsistenz: Der Agent verwendet bewährte Instrumentierungsbibliotheken und sorgt für konsistente Traces und Metriken.
  4. Flexibilität: Der Agent unterstützt verschiedene Backends für Traces und Metriken, z. B. Jaeger, Zipkin oder Prometheus.

Schritt-für-Schritt-Anleitung: OpenTelemetry in Spring Boot mit JVM-Agent

Voraussetzungen

  • Eine Spring-Boot-Anwendung (Version 2.5 oder höher wird empfohlen).
  • Java 8 oder höher.
  • Zugriff auf ein Observability-Backend wie Jaeger oder Zipkin (optional für Tracing-Visualisierung).

1. JVM-Agent herunterladen

Der OpenTelemetry JVM-Agent kann von der offiziellen OpenTelemetry-Website heruntergeladen werden. Die Agent-Datei hat üblicherweise den Namen opentelemetry-javaagent.jar.

2. Agent zur JVM hinzufügen

Der JVM-Agent wird der Anwendung über die JVM-Option -javaagent hinzugefügt. Die grundlegende Syntax zum Starten einer Spring-Boot-Anwendung mit dem Agent sieht folgendermaßen aus:

java -javaagent:/pfad/zum/opentelemetry-javaagent.jar \
     -Dotel.service.name=mein-spring-boot-service \
     -Dotel.traces.exporter=jaeger \
     -Dotel.metrics.exporter=none \
     -Dotel.exporter.jaeger.endpoint=http://localhost:14250 \
     -jar target/meine-anwendung.jar
Code-Sprache: JavaScript (javascript)

Parameter erklärt:

  • -Dotel.service.name: Der Name des Dienstes, der im Tracing-Backend angezeigt wird.
  • -Dotel.traces.exporter: Gibt den Exporter für Traces an (z. B. jaeger, zipkin oder otlp).
  • -Dotel.metrics.exporter: Gibt den Exporter für Metriken an. Standardmäßig wird dieser deaktiviert.
  • -Dotel.exporter.jaeger.endpoint: Der Endpoint des Jaeger-Backends (optional).

3. Backend konfigurieren

Für die Visualisierung von Traces kann ein Observability-Backend wie Jaeger, Zipkin oder ein OpenTelemetry-Kollektor verwendet werden. Beispielsweise kann Jaeger mit Docker schnell gestartet werden:

docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
  -p 5775:5775/udp \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 14268:14268 \
  -p 14250:14250 \
  -p 9411:9411 \
  jaegertracing/all-in-one:1.46

Jaeger ist dann über http://localhost:16686 erreichbar.

4. Anwendung starten und Traces überprüfen

Nach dem Start der Spring-Boot-Anwendung sollten automatisch Traces generiert und an das Backend gesendet werden. Diese Traces zeigen Details zur Ausführung der Anfragen, z. B.:

  • Dauer einzelner Operationen
  • Abhängigkeiten zwischen Microservices
  • Fehler oder Ausnahmen

Anpassungen und erweiterte Konfiguration

Sampling

Sampling steuert, wie viele Anfragen tatsächlich getraced werden, um die Systemlast zu reduzieren. Standardmäßig ist das Sampling auf 1% gesetzt. Dies kann über die JVM-Option angepasst werden:

-Dotel.traces.sampler=parentbased_always_on

Kontextpropagation

OpenTelemetry verwendet W3C-konforme Kontextpropagatoren, um Tracing-Informationen über HTTP-Header wie traceparent zwischen Diensten weiterzugeben. Der JVM-Agent sorgt automatisch dafür, dass Spring Boot diese Header korrekt verarbeitet.

Unterstützung weiterer Frameworks

Der Agent unterstützt automatisch zahlreiche Java-Frameworks wie Spring, Hibernate, JDBC und gRPC. Entwickler können jedoch auch benutzerdefinierte Instrumentierung hinzufügen, falls erforderlich.

Fazit

OpenTelemetry in Kombination mit Spring Boot bietet eine robuste Grundlage für die Observierbarkeit moderner Anwendungen. Die automatische Instrumentierung mit dem JVM-Agent macht den Einstieg besonders einfach und reduziert den Aufwand erheblich. Entwickler können sich so auf die eigentliche Entwicklung konzentrieren, während sie gleichzeitig von einer besseren Überwachung und Fehlersuche profitieren.

Durch die Kombination aus automatischer Instrumentierung, flexibler Konfiguration und Unterstützung für gängige Observability-Backends wird OpenTelemetry zu einem unverzichtbaren Werkzeug für die Entwicklung moderner Microservices. Mit der zunehmenden Verbreitung verteilter Systeme wird der Einsatz von OpenTelemetry und ähnlichen Tools weiter an Bedeutung gewinnen.