OpenTelemetry Go: Vollständiges Tutorial für verteiltes Tracing

1. Was ist OpenTelemetry und warum wird es benötigt?

OpenTelemetry ist eine Sammlung von APIs, SDKs und Tools, die entwickelt wurden, um Telemetriedaten wie Traces, Metriken und Logs zu erstellen und zu verwalten. Die Bibliothek opentelemetry-go ist die offizielle Implementierung des OpenTelemetry-Standards für die Sprache Go. Sie bietet Entwicklern eine einheitliche, anbieterunabhängige Möglichkeit, ihre Anwendungen für die Sammlung von Telemetriedaten zu instrumentieren. Diese Daten können dann an verschiedene Backends wie Jaeger, Zipkin, Prometheus, Grafana Tempo, Datadog und viele andere gesendet werden.

Warum ist das wichtig? In modernen Microservice-Architekturen durchläuft eine Benutzeranfrage oft Dutzende verschiedener Dienste. Wenn ein Problem auftritt (z. B. eine Anfrage dauert zu lange oder endet mit einem Fehler), ist es ohne verteiltes Tracing (Distributed Tracing) äußerst schwierig zu erkennen, welcher Dienst der Engpass oder die Fehlerquelle ist. OpenTelemetry ermöglicht es, den Weg einer Anfrage durch das gesamte System zu verfolgen, die Ausführungszeit jedes Schritts zu sehen und sie in einem einzigen Trace, bestehend aus Spans, zu verknüpfen. Dies gibt Entwicklern und Site Reliability Engineers (SREs) ein leistungsstarkes Werkzeug für Debugging, Monitoring und Leistungsoptimierung.

Der entscheidende Vorteil von OpenTelemetry gegenüber anderen Lösungen (wie den älteren Bibliotheken OpenTracing oder OpenCensus) ist seine Vielseitigkeit und Standardisierung. Sie schreiben den Code einmal mit einer einheitlichen API und können das Backend für die Speicherung und Visualisierung der Daten wechseln, ohne den Anwendungscode zu ändern. Das macht opentelemetry-go nicht nur zu einer Bibliothek, sondern zur Grundlage für den Aufbau eines beobachtbaren (observable) Systems in Go.

2. Installation

Um die Bibliothek opentelemetry-go und ihre Hauptkomponenten zu installieren, verwenden Sie den standardmäßigen Go-Paketmanager. Sie müssen das Haupt-API-Paket, das SDK für Tracing und einen Exporter (z. B. für die Konsole oder Jaeger) installieren.

# Haupt-API installieren
go get go.opentelemetry.io/otel

# SDK für Tracing installieren
go get go.opentelemetry.io/otel/sdk

# Exporter für die Konsolenausgabe installieren (für Debugging)
go get go.opentelemetry.io/otel/exporters/stdout/stdouttrace

# HTTP-Propagator für den Kontext installieren (für HTTP-Integration)
go get go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp

# Exporter für Jaeger installieren (für die Produktion)
go get go.opentelemetry.io/otel/exporters/jaeger

Nach der Ausführung dieser Befehle werden alle erforderlichen Abhängigkeiten zu Ihrer go.mod-Datei hinzugefügt.

3. Schnellstart – Minimales funktionierendes Beispiel

Dieses Beispiel zeigt, wie Sie einen einfachen Trace mit einem einzigen Span erstellen und auf der Konsole ausgeben. Es ist ein hervorragender Ausgangspunkt, um die grundlegenden Konzepte zu verstehen.

package main

import (
	"context"
	"fmt"
	"log"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
	"go.opentelemetry.io/otel/trace"
)

func main() {
	// 1. Exporter für die Konsolenausgabe erstellen
	exporter, err := stdouttrace.New(
		stdouttrace.WithPrettyPrint(),
	)
	if err != nil {
		log.Fatal(err)
	}

	// 2. TracerProvider mit Exporter und Resource erstellen
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(resource.NewWithAttributes(
			semconv.SchemaURL,
			semconv.ServiceNameKey.String("my-service"),
		)),
	)
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatal(err)
		}
	}()

	// 3. Globalen TracerProvider setzen
	otel.SetTracerProvider(tp)

	// 4. Tracer holen
	tracer := otel.Tracer("my-tracer")

	// 5. Span erstellen
	ctx, span :=