Go微服务链路追踪OpenTelemetry实战

// pkg/otel/otel.go
package otel
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
	"go.opentelemetry.io/otel/propagation"
	"go.opentelemetry.io/otel/sdk/resource"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)
// InitTracer 初始化OpenTelemetry TracerProvider
func InitTracer(serviceName string, endpoint string) (*sdktrace.TracerProvider, error) {
	// 创建OTLP gRPC导出器
	conn, err := grpc.DialContext(
		context.Background(),
		endpoint,
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithBlock(),
	)
	if err != nil {
		return nil, err
	}
	exporter, err := otlptracegrpc.New(
		context.Background(),
		otlptracegrpc.WithGRPCConn(conn),
	)
	if err != nil {
		return nil, err
	}
	// 配置资源信息，标记服务名称
	res, err := resource.New(
		context.Background(),
		resource.WithAttributes(
			semconv.ServiceName(serviceName),
		),
	)
	if err != nil {
		return nil, err
	}
	// 创建TracerProvider，配置批量处理器
	tp := sdktrace.NewTracerProvider(
		sdktrace.WithSampler(sdktrace.AlwaysSample()), // 开发环境全采样，生产环境建议用基于概率的采样
		sdktrace.WithBatcher(exporter),
		sdktrace.WithResource(res),
	)
	// 设置全局TracerProvider
	otel.SetTracerProvider(tp)
	// 设置全局文本映射 propagator，用于在服务间传递上下文
	otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
		propagation.TraceContext{},
		propagation.Baggage{},
	))
	return tp, nil
}

// services/user/main.go
package main
import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/trace"
	"your-project-path/pkg/otel"
)
func main() {
	// 初始化OpenTelemetry
	tp, err := otel.InitTracer("user-service", "localhost:4317")
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("failed to shutdown TracerProvider: %v", err)
		}
	}()
	// 创建HTTP服务器，使用otelhttp.Handler包装路由，实现自动插桩
	mux := http.NewServeMux()
	mux.Handle("/user/", otelhttp.NewHandler(http.HandlerFunc(userHandler), "user-handler"))
	srv := &http.Server{
		Addr:    ":8081",
		Handler: mux,
	}
	// 启动服务器
	go func() {
		log.Println("User service starting on :8081")
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %s\n", err)
		}
	}()
	// 等待中断信号
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("Shutting down user service...")
	// 优雅关闭服务器
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("User service shutdown failed:", err)
	}
	log.Println("User service exited")
}
func userHandler(w http.ResponseWriter, r *http.Request) {
	// 从请求中获取Span上下文，手动添加属性
	span := trace.SpanFromContext(r.Context())
	span.SetAttributes(
		trace.StringAttribute("user.id", r.PathValue("id")),
	)
	// 模拟业务处理耗时
	time.Sleep(50 * time.Millisecond)
	// 返回用户信息
	userID := r.PathValue("id")
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	fmt.Fprintf(w, `{"id":"%s","name":"user-%s","email":"user-%s@example.com"}`, userID, userID, userID)
}

// services/order/main.go
package main
import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/trace"
	"your-project-path/pkg/otel"
)
// 初始化HTTP客户端，使用otelhttp.Transport实现自动插桩
var client = http.Client{
	Transport: otelhttp.NewTransport(http.DefaultTransport),
}
func main() {
	// 初始化OpenTelemetry
	tp, err := otel.InitTracer("order-service", "localhost:4317")
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("failed to shutdown TracerProvider: %v", err)
		}
	}()
	mux := http.NewServeMux()
	mux.Handle("/order", otelhttp.NewHandler(http.HandlerFunc(createOrderHandler), "create-order-handler"))
	srv := &http.Server{
		Addr:    ":8082",
		Handler: mux,
	}
	go func() {
		log.Println("Order service starting on :8082")
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %s\n", err)
		}
	}()
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("Shutting down order service...")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("Order service shutdown failed:", err)
	}
	log.Println("Order service exited")
}
func createOrderHandler(w http.ResponseWriter, r *http.Request) {
	span := trace.SpanFromContext(r.Context())
	// 模拟获取用户ID（实际场景可能从请求参数或Token中解析）
	userID := "123"
	span.SetAttributes(
		trace.StringAttribute("user.id", userID),
	)
	// 调用用户服务
	userInfo, err := getUserInfo(r.Context(), userID)
	if err != nil {
		http.Error(w, fmt.Sprintf("failed to get user info: %v", err), http.StatusInternalServerError)
		return
	}
	span.SetAttributes(
		trace.StringAttribute("user.info", string(userInfo)),
	)
	// 模拟订单创建耗时
	time.Sleep(100 * time.Millisecond)
	// 返回订单信息
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusOK)
	fmt.Fprintf(w, `{"order_id":"order-%d","user_id":"%s","status":"created","create_time":"%s"}`, time.Now().Unix(), userID, time.Now().Format(time.RFC3339))
}
func getUserInfo(ctx context.Context, userID string) ([]byte, error) {
	// 手动创建子Span，标记内部调用
	tr := otel.Tracer("order-service")
	ctx, span := tr.Start(ctx, "get-user-info")
	defer span.End()
	// 创建HTTP请求，传递上下文
	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("http://localhost:8081/user/%s", userID), nil)
	if err != nil {
		return nil, err
	}
	// 调用用户服务
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	return body, nil
}

// services/gateway/main.go
package main
import (
	"context"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/trace"
	"your-project-path/pkg/otel"
)
var client = http.Client{
	Transport: otelhttp.NewTransport(http.DefaultTransport),
}
func main() {
	// 初始化OpenTelemetry
	tp, err := otel.InitTracer("gateway-service", "localhost:4317")
	if err != nil {
		log.Fatal(err)
	}
	defer func() {
		if err := tp.Shutdown(context.Background()); err != nil {
			log.Fatalf("failed to shutdown TracerProvider: %v", err)
		}
	}()
	mux := http.NewServeMux()
	mux.Handle("/api/order", otelhttp.NewHandler(http.HandlerFunc(gatewayOrderHandler), "gateway-order-handler"))
	srv := &http.Server{
		Addr:    ":8080",
		Handler: mux,
	}
	go func() {
		log.Println("Gateway service starting on :8080")
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %s\n", err)
		}
	}()
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("Shutting down gateway service...")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("Gateway service shutdown failed:", err)
	}
	log.Println("Gateway service exited")
}
func gatewayOrderHandler(w http.ResponseWriter, r *http.Request) {
	span := trace.SpanFromContext(r.Context())
	span.SetAttributes(
		trace.StringAttribute("client