Tracing und Observability mit Opentelemetry in Spring-Boot-Anwendungen

Einleitung

Die Entwicklung von Microservices-basierten Anwendungen hat in den letzten Jahren stark zugenommen, und mit dieser Entwicklung sind auch die Anforderungen an die Observability und das Tracing von Anwendungen gestiegen. Opentelemetry ist eine Initiative, die dazu beiträgt, diese Anforderungen zu erfüllen, indem sie eine einheitliche Möglichkeit zur Instrumentierung von Anwendungen für das Tracing und die Observability bereitstellt. In diesem Artikel werden wir uns darauf konzentrieren, wie Opentelemetry in Spring-Boot-Anwendungen integriert werden kann, um umfassende Einblicke in das Anwendungsverhalten zu erhalten.

1. Opentelemetry im Überblick

Opentelemetry ist ein quelloffenes Projekt, das darauf abzielt, die Observability in Cloud-native Umgebungen zu verbessern. Es kombiniert die Bemühungen der Projekte OpenTracing und OpenCensus, um eine einheitliche Lösung für das Tracing, die Metriken und das Logging bereitzustellen. Durch die Unterstützung von verschiedenen Programmiersprachen und Frameworks, einschließlich Java und Spring, ermöglicht Opentelemetry Entwicklern die Instrumentierung ihrer Anwendungen, um detaillierte Einblicke in die Anwendungsleistung zu erhalten.

2. Integration von Opentelemetry in Spring-Boot

Die Integration von Opentelemetry in Spring-Boot-Anwendungen ist ein relativ einfacher Prozess, der in mehreren Schritten durchgeführt werden kann. Hier ist eine schrittweise Anleitung:

a. Abhängigkeiten hinzufügen

Beginnen Sie damit, die erforderlichen Opentelemetry-Abhängigkeiten zu Ihrer Spring-Boot-Anwendung hinzuzufügen. Dies umfasst normalerweise die Kernbibliotheken, Instrumentierungsbibliotheken für verschiedene Technologien sowie Exporter für die Weiterleitung von Tracing-Daten an Backend-Systeme.

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

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

<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-instrumentation-api</artifactId>
    <version>1.35.0</version>
</dependency>

<!-- Instrumentation for Spring Boot -->
<dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-instrumentation-spring-boot</artifactId>
    <version>1.5.0</version>
</dependency>

<!-- Exporter for Jaeger -->
<dependency>
    <groupId>io.opentelemetry.exporters</groupId>
    <artifactId>opentelemetry-exporters-jaeger</artifactId>
    <version>1.35.0</version>
</dependency>Code-Sprache: HTML, XML (xml)

b. Konfiguration vornehmen

Konfigurieren Sie Opentelemetry in Ihrer Spring-Boot-Anwendung. Dies umfasst die Initialisierung des Tracer-Providers und die Festlegung von Exporter-Optionen.

import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporter;
import io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporterBuilder;
import io.opentelemetry.sdk.OpenTelemetrySdk;
import io.opentelemetry.sdk.trace.SdkTracerProvider;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

@Configuration
public class OpentelemetryConfig {

    @Value("${opentelemetry.jaeger.endpoint}")
    private String jaegerEndpoint;

    @Bean
    public OpenTelemetry configureOpenTelemetry() {
        JaegerGrpcSpanExporter exporter = JaegerGrpcSpanExporter.builder()
            .setEndpoint(jaegerEndpoint)
            .build();

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

        return OpenTelemetrySdk.builder()
            .setTracerProvider(tracerProvider)
            .build();
    }
}Code-Sprache: JavaScript (javascript)

c. Tracing in Ihrer Anwendung verwenden

Sobald Opentelemetry konfiguriert ist, können Sie Tracing in Ihrer Anwendung verwenden, indem Sie Spans erstellen und damit Messungen durchführen.

import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.Tracer;

@RestController
@RequestMapping("/api")
public class MyController {

    private static final Tracer tracer = OpenTelemetry.getGlobalTracer("my-instrumentation");

    @GetMapping("/example")
    public String exampleEndpoint() {
        Span span = tracer.spanBuilder("example-operation").startSpan();
        try (Scope scope = span.makeCurrent()) {
            // Your business logic here
            return "Hello, Opentelemetry!";
        } finally {
            span.end();
        }
    }
}Code-Sprache: PHP (php)

3. Tracing-Daten visualisieren

Nachdem Sie Opentelemetry in Ihre Spring-Boot-Anwendung integriert haben, ist es wichtig, die erfassten Tracing-Daten zu visualisieren. Opentelemetry bietet Unterstützung für verschiedene Backend-Systeme wie Jaeger und Zipkin. In diesem Beispiel verwenden wir Jaeger als Tracing-Backend.

a. Jaeger konfigurieren

Stellen Sie sicher, dass Ihr Jaeger-Backend bereit ist und erreichbar ist. Konfigurieren Sie dann die Jaeger-Verbindungsdaten in Ihrer Anwendungs-Properties-Datei.

opentelemetry.jaeger.endpoint=http://jaeger-collector:14250Code-Sprache: JavaScript (javascript)

b. Tracing visualisieren

Öffnen Sie das Jaeger-UI im Browser, indem Sie die entsprechende URL aufrufen (z.B., http://jaeger-ui:16686). Hier können Sie Traces, Spans und andere Tracing-Daten visualisieren.

4. Fehlerbehandlung und Best Practices

Die Integration von Opentelemetry in Spring-Boot-Anwendungen erfordert sorgfältige Planung und Beachtung einiger bewährter Praktiken. Hier sind einige wichtige Aspekte:

a. Ressourcen schonen

Opentelemetry bietet verschiedene Konfigurationsoptionen, mit denen Sie die Auswirkungen auf die Anwendungsleistung minimieren können. Stellen Sie sicher, dass Sie die Instrumentierung nur dort durchführen, wo sie wirklich benötigt wird.

b. Logging

Integrieren Sie Logging auf angemessene Weise, um Informationen über Tracing-Ereignisse zu erhalten. Dies kann helfen, potenzielle Probleme zu diagnostizieren und die Leistung Ihrer Anwendung zu optimieren.