wehub-resource-sync
654 lines
21 KiB
Go
654 lines
21 KiB
Go
package trace
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"math"
|
||
"net/http"
|
||
"net/http/httptest"
|
||
"os"
|
||
"sync"
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"go.opentelemetry.io/otel"
|
||
"go.opentelemetry.io/otel/propagation"
|
||
sdktrace "go.opentelemetry.io/otel/sdk/trace"
|
||
oteltrace "go.opentelemetry.io/otel/trace"
|
||
)
|
||
|
||
// initTracerSnapshot 捕获包 init() 后、任何测试改动前的全局 tracer 快照。
|
||
// 用于锁定 init() 的 Noop 兜底不变式（C13a），避免 resetGlobal/Init/Close
|
||
// 在其他测试中重置全局后掩盖 init() 路径的回归。
|
||
var initTracerSnapshot oteltrace.Tracer
|
||
|
||
func TestMain(m *testing.M) {
|
||
// init() 已运行；此处立即快照 getTracer()（永不 nil 的 Noop 兜底）。
|
||
initTracerSnapshot = getTracer()
|
||
code := m.Run()
|
||
os.Exit(code)
|
||
}
|
||
|
||
// resetGlobal 恢复 trace 包级全局到 Noop 兜底状态，避免测试间污染。
|
||
func resetGlobal(t *testing.T) {
|
||
t.Helper()
|
||
noopProvider := oteltrace.NewNoopTracerProvider()
|
||
noopTracer := noopProvider.Tracer("xlgo")
|
||
tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.NeverSample()))
|
||
tracerProviderPtr.Store(tp)
|
||
tracerPtr.Store(&noopTracer)
|
||
otel.SetTracerProvider(noopProvider)
|
||
otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(
|
||
propagation.TraceContext{}, propagation.Baggage{}))
|
||
}
|
||
|
||
func setOperationTimeoutForTest(t *testing.T, timeout time.Duration) {
|
||
t.Helper()
|
||
old := operationTimeoutNanos.Load()
|
||
operationTimeoutNanos.Store(int64(timeout))
|
||
t.Cleanup(func() {
|
||
operationTimeoutNanos.Store(old)
|
||
})
|
||
}
|
||
|
||
type blockingExporter struct{}
|
||
|
||
func (blockingExporter) ExportSpans(context.Context, []sdktrace.ReadOnlySpan) error {
|
||
return nil
|
||
}
|
||
|
||
func (blockingExporter) Shutdown(ctx context.Context) error {
|
||
<-ctx.Done()
|
||
return ctx.Err()
|
||
}
|
||
|
||
type recordingExporter struct {
|
||
mu sync.Mutex
|
||
spans []sdktrace.ReadOnlySpan
|
||
}
|
||
|
||
func (e *recordingExporter) ExportSpans(_ context.Context, spans []sdktrace.ReadOnlySpan) error {
|
||
e.mu.Lock()
|
||
defer e.mu.Unlock()
|
||
e.spans = append(e.spans, spans...)
|
||
return nil
|
||
}
|
||
|
||
func (e *recordingExporter) Shutdown(context.Context) error {
|
||
return nil
|
||
}
|
||
|
||
func (e *recordingExporter) Spans() []sdktrace.ReadOnlySpan {
|
||
e.mu.Lock()
|
||
defer e.mu.Unlock()
|
||
spans := make([]sdktrace.ReadOnlySpan, len(e.spans))
|
||
copy(spans, e.spans)
|
||
return spans
|
||
}
|
||
|
||
func requireNoPanic(t *testing.T, fn func()) {
|
||
t.Helper()
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
t.Fatalf("unexpected panic: %v", r)
|
||
}
|
||
}()
|
||
fn()
|
||
}
|
||
|
||
// TestC13aInitNoopInvariant 锁定 init() 的 Noop 兜底不变式：
|
||
// 包加载后（任何 Init/Close/resetGlobal 之前）getTracer() 必须非 nil。
|
||
//
|
||
// 变异 init() 去掉 Noop Store 后，initTracerSnapshot（在 TestMain 即 init 后捕获）
|
||
// 将为 nil → 此测试红。resetGlobal 等后续改动不影响此快照。
|
||
func TestC13aInitNoopInvariant(t *testing.T) {
|
||
if initTracerSnapshot == nil {
|
||
t.Fatal("init() did not store a Noop tracer: getTracer() was nil at package load (C13a)")
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// C13a：未 Init 即用 → nil tracer panic
|
||
// ============================================================
|
||
|
||
// TestC13aNoInitNoPanic 验证未 Init 时包级函数不 panic（Noop 兜底）。
|
||
//
|
||
// 修复前：包级 tracer 为 nil，Middleware/StartSpanFromContext/GetTracer 裸用 → panic。
|
||
// 修复后：init() Store Noop，getTracer() 永不 nil。
|
||
func TestC13aNoInitNoPanic(t *testing.T) {
|
||
// 强制重置到"未 Init"的 Noop 兜底状态。
|
||
resetGlobal(t)
|
||
|
||
// GetTracer 非 nil。
|
||
if tr := GetTracer(); tr == nil {
|
||
t.Fatal("GetTracer() nil before Init (C13a)")
|
||
}
|
||
|
||
// StartSpanFromContext 不 panic。
|
||
ctx, span := StartSpanFromContext(context.Background(), "test-span")
|
||
defer span.End()
|
||
if span == nil {
|
||
t.Fatal("StartSpanFromContext returned nil span")
|
||
}
|
||
_ = ctx
|
||
|
||
// Middleware 不 panic：走一次请求。
|
||
gin.SetMode(gin.TestMode)
|
||
r := gin.New()
|
||
r.Use(Middleware("test-svc"))
|
||
r.GET("/p", func(c *gin.Context) {
|
||
// 下游用 c.Request.Context() 取 span（C13d 闭环）。
|
||
s := oteltrace.SpanFromContext(c.Request.Context())
|
||
c.String(http.StatusOK, s.SpanContext().TraceID().String())
|
||
})
|
||
|
||
w := httptest.NewRecorder()
|
||
req := httptest.NewRequest(http.MethodGet, "/p", nil)
|
||
r.ServeHTTP(w, req)
|
||
|
||
// Noop tracer 的 TraceID 为空（Noop 不记录），但绝不应 panic。
|
||
if w.Code != http.StatusOK {
|
||
t.Fatalf("status = %d, want 200 (C13a should not panic)", w.Code)
|
||
}
|
||
}
|
||
|
||
// TestC13aInitDisabledNoop 验证 Init(Enabled:false) 后 Noop 安全。
|
||
func TestC13aInitDisabledNoop(t *testing.T) {
|
||
t.Cleanup(func() { _ = Close(context.Background()); resetGlobal(t) })
|
||
if err := Init(Config{Enabled: false, ServiceName: "svc"}); err != nil {
|
||
t.Fatalf("Init: %v", err)
|
||
}
|
||
if GetTracer() == nil {
|
||
t.Fatal("GetTracer nil after Init(Enabled:false)")
|
||
}
|
||
// Noop tracer Start 不 panic。
|
||
_, span := StartSpanFromContext(context.Background(), "x")
|
||
span.End()
|
||
}
|
||
|
||
// TestC13aCloseThenUseNoPanic 验证 Close 后再用不 panic（Store 回 Noop 兜底）。
|
||
func TestC13aCloseThenUseNoPanic(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
// 即便未真正 Init 出带 exporter 的 provider，Close 也应安全并把全局重置为兜底。
|
||
if err := Close(context.Background()); err != nil {
|
||
t.Fatalf("Close: %v", err)
|
||
}
|
||
// Close 后包级函数仍安全。
|
||
if GetTracer() == nil {
|
||
t.Fatal("GetTracer nil after Close")
|
||
}
|
||
_, span := StartSpanFromContext(context.Background(), "after-close")
|
||
span.End()
|
||
}
|
||
|
||
// ============================================================
|
||
// C13b：未知导出器返 nil + stdout 未实现
|
||
// ============================================================
|
||
|
||
// TestC13bStdoutExporterWorks 验证 stdout 导出器可创建（C13b 实现）。
|
||
func TestC13bStdoutExporterWorks(t *testing.T) {
|
||
// 用 stdouttrace 但 Init 会向 os.Stdout 输出，故直接测 createExporter。
|
||
cfg := Config{ExporterType: "stdout"}
|
||
exp, err := createExporter(cfg)
|
||
if err != nil {
|
||
t.Fatalf("createExporter(stdout): %v (C13b stdout unimplemented)", err)
|
||
}
|
||
if exp == nil {
|
||
t.Fatal("createExporter(stdout) returned nil exporter (C13b)")
|
||
}
|
||
_ = exp.Shutdown(context.Background())
|
||
}
|
||
|
||
// TestC13bUnknownExporterReturnsError 验证未知导出器返错（修复前返 nil,nil）。
|
||
func TestC13bUnknownExporterReturnsError(t *testing.T) {
|
||
cfg := Config{ExporterType: "xyz-unknown"}
|
||
exp, err := createExporter(cfg)
|
||
if err == nil {
|
||
t.Error("createExporter(unknown) should return error (C13b), got nil")
|
||
}
|
||
if exp != nil {
|
||
t.Errorf("createExporter(unknown) should return nil exporter, got %T", exp)
|
||
}
|
||
}
|
||
|
||
// TestC13bInitUnknownExporterFails 验证 Init 未知导出器返错（不喂 nil 给 WithBatcher）。
|
||
func TestC13bInitUnknownExporterFails(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
err := Init(Config{Enabled: true, ExporterType: "xyz-unknown", Propagator: "w3c"})
|
||
if err == nil {
|
||
t.Error("Init with unknown exporter should fail (C13b)")
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// C13c：OTLP 默认 HTTPS 无 WithInsecure
|
||
// ============================================================
|
||
|
||
// TestC13cInsecureExporterCreates 验证 Insecure:true 时 otlp-http 导出器可创建（无 TLS 握手）。
|
||
// createExporter 仅构造 client，不连接；Insecure 注入不报错即验证 option 路径生效。
|
||
func TestC13cInsecureExporterCreates(t *testing.T) {
|
||
cfg := Config{ExporterType: "otlp-http", Endpoint: "localhost:4318", Insecure: true}
|
||
exp, err := createExporter(cfg)
|
||
if err != nil {
|
||
t.Fatalf("createExporter(otlp-http, Insecure): %v (C13c)", err)
|
||
}
|
||
_ = exp.Shutdown(context.Background())
|
||
}
|
||
|
||
// TestC13cOtlpGrpcInsecureCreates 验证 otlp-grpc Insecure 路径。
|
||
func TestC13cOtlpGrpcInsecureCreates(t *testing.T) {
|
||
cfg := Config{ExporterType: "otlp-grpc", Endpoint: "localhost:4317", Insecure: true}
|
||
exp, err := createExporter(cfg)
|
||
if err != nil {
|
||
t.Fatalf("createExporter(otlp-grpc, Insecure): %v (C13c)", err)
|
||
}
|
||
_ = exp.Shutdown(context.Background())
|
||
}
|
||
|
||
// ============================================================
|
||
// C13d：Middleware 不更新 c.Request
|
||
// ============================================================
|
||
|
||
// TestC13dRequestContextContainsSpan 验证 Middleware 更新 c.Request，
|
||
// 下游 c.Request.Context() 含 span（TraceID 非空且与 X-Trace-ID 一致）。
|
||
//
|
||
// 修复前：仅 c.Set("otel_ctx", ctx)，下游 c.Request.Context() 无 span。
|
||
func TestC13dRequestContextContainsSpan(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { _ = Close(context.Background()); resetGlobal(t) })
|
||
|
||
// 用 stdout 导出器 + 全采样，使 span 真实生成（非 Noop）。
|
||
if err := Init(Config{
|
||
Enabled: true,
|
||
ServiceName: "test-svc",
|
||
ExporterType: "stdout",
|
||
SampleRatio: 1.0,
|
||
Propagator: "w3c",
|
||
}); err != nil {
|
||
t.Fatalf("Init: %v", err)
|
||
}
|
||
|
||
gin.SetMode(gin.TestMode)
|
||
r := gin.New()
|
||
r.Use(Middleware("test-svc"))
|
||
|
||
var seenTraceID string
|
||
r.GET("/p", func(c *gin.Context) {
|
||
// 关键：用 c.Request.Context()（而非 trace.GetContext(c)）取 span。
|
||
s := oteltrace.SpanFromContext(c.Request.Context())
|
||
seenTraceID = s.SpanContext().TraceID().String()
|
||
c.String(http.StatusOK, "ok")
|
||
})
|
||
|
||
w := httptest.NewRecorder()
|
||
req := httptest.NewRequest(http.MethodGet, "/p", nil)
|
||
r.ServeHTTP(w, req)
|
||
|
||
if seenTraceID == "" {
|
||
t.Fatal("c.Request.Context() has no span/TraceID (C13d: Middleware didn't update c.Request)")
|
||
}
|
||
headerTraceID := w.Header().Get("X-Trace-ID")
|
||
if headerTraceID == "" {
|
||
t.Fatal("X-Trace-ID header missing")
|
||
}
|
||
if seenTraceID != headerTraceID {
|
||
t.Errorf("TraceID mismatch: downstream %q vs header %q (C13d)", seenTraceID, headerTraceID)
|
||
}
|
||
}
|
||
|
||
// TestC13dPropagatedTraceContextExtracted 验证 Middleware 从入站 W3C 头提取父 context
|
||
// 并写入 c.Request，下游 span 继承父 TraceID。
|
||
func TestC13dPropagatedTraceContextExtracted(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { _ = Close(context.Background()); resetGlobal(t) })
|
||
|
||
if err := Init(Config{
|
||
Enabled: true, ServiceName: "test-svc", ExporterType: "stdout",
|
||
SampleRatio: 1.0, Propagator: "w3c",
|
||
}); err != nil {
|
||
t.Fatalf("Init: %v", err)
|
||
}
|
||
|
||
// 构造一个父 span 并注入 W3C traceparent 头（用真实采样 provider，非 noop）。
|
||
parentProvider := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.AlwaysSample()))
|
||
defer parentProvider.Shutdown(context.Background())
|
||
parentTracer := parentProvider.Tracer("test-parent")
|
||
parentCtx, parentSpan := parentTracer.Start(context.Background(), "parent")
|
||
defer parentSpan.End()
|
||
parentTraceID := parentSpan.SpanContext().TraceID().String()
|
||
|
||
carrier := propagation.HeaderCarrier{}
|
||
otel.GetTextMapPropagator().Inject(parentCtx, carrier)
|
||
|
||
gin.SetMode(gin.TestMode)
|
||
r := gin.New()
|
||
r.Use(Middleware("test-svc"))
|
||
var seen string
|
||
r.GET("/p", func(c *gin.Context) {
|
||
s := oteltrace.SpanFromContext(c.Request.Context())
|
||
seen = s.SpanContext().TraceID().String()
|
||
c.Status(http.StatusOK)
|
||
})
|
||
|
||
w := httptest.NewRecorder()
|
||
req := httptest.NewRequest(http.MethodGet, "/p", nil)
|
||
// 把 carrier 中的头复制到请求。
|
||
for _, key := range carrier.Keys() {
|
||
req.Header.Set(key, carrier.Get(key))
|
||
}
|
||
r.ServeHTTP(w, req)
|
||
|
||
if seen != parentTraceID {
|
||
t.Errorf("downstream TraceID = %q, want parent %q (C13d propagation/extract)", seen, parentTraceID)
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// C13e：b3/jaeger 未实现
|
||
// ============================================================
|
||
|
||
// TestC13eB3PropagatorImplemented 验证 b3 传播器返回非 nil 的 b3 propagator（C13e 实现）。
|
||
func TestC13eB3PropagatorImplemented(t *testing.T) {
|
||
prop, err := createPropagator("b3")
|
||
if err != nil {
|
||
t.Fatalf("createPropagator(b3): %v (C13e unimplemented)", err)
|
||
}
|
||
if prop == nil {
|
||
t.Fatal("createPropagator(b3) returned nil (C13e)")
|
||
}
|
||
// 用真实采样的 provider tracer，使 span SpanContext 有效。
|
||
tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.AlwaysSample()))
|
||
defer tp.Shutdown(context.Background())
|
||
tracer := tp.Tracer("t")
|
||
ctx, span := tracer.Start(context.Background(), "s")
|
||
defer span.End()
|
||
// b3 propagator 应识别 b3 头。注入后 b3 单头或 x-b3-traceid 至少其一非空。
|
||
carrier := propagation.HeaderCarrier{}
|
||
prop.Inject(ctx, carrier)
|
||
if carrier.Get("b3") == "" && carrier.Get("x-b3-traceid") == "" {
|
||
t.Error("b3 propagator did not inject b3 headers (C13e)")
|
||
}
|
||
}
|
||
|
||
// TestC13eJaegerMapsToW3C 验证 jaeger 映射 W3C TraceContext（非静默 nil）。
|
||
func TestC13eJaegerMapsToW3C(t *testing.T) {
|
||
prop, err := createPropagator("jaeger")
|
||
if err != nil {
|
||
t.Fatalf("createPropagator(jaeger): %v (C13e)", err)
|
||
}
|
||
if prop == nil {
|
||
t.Fatal("createPropagator(jaeger) returned nil (C13e)")
|
||
}
|
||
// 用真实采样的 provider tracer，使 span SpanContext 有效（noop tracer 不生成 TraceID）。
|
||
tp := sdktrace.NewTracerProvider(sdktrace.WithSampler(sdktrace.AlwaysSample()))
|
||
defer tp.Shutdown(context.Background())
|
||
tracer := tp.Tracer("t")
|
||
ctx, span := tracer.Start(context.Background(), "s")
|
||
defer span.End()
|
||
// 注入 W3C traceparent 头。
|
||
carrier := propagation.HeaderCarrier{}
|
||
prop.Inject(ctx, carrier)
|
||
if carrier.Get("traceparent") == "" {
|
||
t.Error("jaeger(→W3C) propagator did not inject traceparent (C13e)")
|
||
}
|
||
}
|
||
|
||
// TestC13eUnknownPropagatorReturnsError 验证未知传播器返错（修复前静默回落 W3C）。
|
||
func TestC13eUnknownPropagatorReturnsError(t *testing.T) {
|
||
prop, err := createPropagator("xyz")
|
||
if err == nil {
|
||
t.Error("createPropagator(unknown) should return error (C13e), got nil")
|
||
}
|
||
if prop != nil {
|
||
t.Errorf("createPropagator(unknown) should return nil, got %T", prop)
|
||
}
|
||
}
|
||
|
||
// TestC13eInitUnknownPropagatorFails 验证 Init 未知传播器返错且回滚 provider。
|
||
func TestC13eInitUnknownPropagatorFails(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
err := Init(Config{Enabled: true, ExporterType: "stdout", Propagator: "xyz"})
|
||
if err == nil {
|
||
t.Error("Init with unknown propagator should fail (C13e)")
|
||
}
|
||
}
|
||
|
||
// TestC13eW3CDefault 验证空 propagator 默认 W3C（兼容）。
|
||
func TestC13eW3CDefault(t *testing.T) {
|
||
prop, err := createPropagator("")
|
||
if err != nil {
|
||
t.Fatalf("createPropagator(''): %v", err)
|
||
}
|
||
if prop == nil {
|
||
t.Fatal("createPropagator('') returned nil")
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// C13 顺带：GetContext 裸断言防护
|
||
// ============================================================
|
||
|
||
// TestC13GetContextCommaOk 验证 otel_ctx 被置为非 context 值时不 panic。
|
||
func TestC13GetContextCommaOk(t *testing.T) {
|
||
gin.SetMode(gin.TestMode)
|
||
c, _ := gin.CreateTestContext(httptest.NewRecorder())
|
||
c.Request = httptest.NewRequest(http.MethodGet, "/", nil)
|
||
c.Set("otel_ctx", "not-a-context") // 污染
|
||
|
||
// 修复前：ctx.(context.Context) 裸断言 panic；修复后 comma-ok 回退 c.Request.Context()。
|
||
ctx := GetContext(c)
|
||
if ctx == nil {
|
||
t.Fatal("GetContext returned nil")
|
||
}
|
||
// 应回退到 c.Request.Context()。
|
||
if ctx != c.Request.Context() {
|
||
t.Error("GetContext should fall back to c.Request.Context() on bad otel_ctx")
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// H-14：Close→Init→Close 多轮生命周期（原 sync.Once 致第二次 Close 不 Shutdown）
|
||
// ============================================================
|
||
|
||
// TestH14CloseInitCloseMultipleRounds 验证 Close 可反复执行，
|
||
// 且 Close→Init→Close 第二次 Close 仍真正 Shutdown 新 provider（不泄漏 exporter）。
|
||
//
|
||
// 修复前：Close 用 sync.Once，第二次 Close no-op，第二轮 Init 创建的 provider 的
|
||
// exporter 后台 goroutine/连接泄漏。
|
||
func TestH14CloseInitCloseMultipleRounds(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
for round := 0; round < 3; round++ {
|
||
if err := Init(Config{Enabled: true, ServiceName: "svc", ExporterType: "stdout", Propagator: "w3c"}); err != nil {
|
||
t.Fatalf("round %d Init failed: %v", round, err)
|
||
}
|
||
// Init 后 provider 非 nil
|
||
if TracerProvider() == nil {
|
||
t.Fatalf("round %d: provider nil after Init", round)
|
||
}
|
||
if err := Close(context.Background()); err != nil {
|
||
t.Fatalf("round %d Close failed: %v", round, err)
|
||
}
|
||
// Close 后仍非 nil（兜底 NeverSample provider，C13a）
|
||
if TracerProvider() == nil {
|
||
t.Fatalf("round %d: provider nil after Close", round)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestH14CloseIdempotent 验证连续 Close 不 panic、不报错。
|
||
func TestH14CloseIdempotent(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
if err := Close(context.Background()); err != nil {
|
||
t.Fatalf("first Close: %v", err)
|
||
}
|
||
if err := Close(context.Background()); err != nil {
|
||
t.Fatalf("second Close: %v", err)
|
||
}
|
||
}
|
||
|
||
// ============================================================
|
||
// M14 trace residue: validation, timeout, nil guards, headers, service name
|
||
// ============================================================
|
||
func TestM14SampleRatioRange(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
for _, ratio := range []float64{-0.01, 1.01, math.NaN()} {
|
||
err := Init(Config{
|
||
Enabled: true,
|
||
ExporterType: "stdout",
|
||
Propagator: "w3c",
|
||
SampleRatio: ratio,
|
||
})
|
||
if err == nil {
|
||
t.Fatalf("Init with SampleRatio=%v should fail", ratio)
|
||
}
|
||
}
|
||
|
||
for _, ratio := range []float64{0, 1} {
|
||
if err := Init(Config{
|
||
Enabled: true,
|
||
ServiceName: "svc",
|
||
ExporterType: "stdout",
|
||
Propagator: "w3c",
|
||
SampleRatio: ratio,
|
||
}); err != nil {
|
||
t.Fatalf("Init with boundary SampleRatio=%v failed: %v", ratio, err)
|
||
}
|
||
if err := Close(context.Background()); err != nil {
|
||
t.Fatalf("Close after SampleRatio=%v: %v", ratio, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestM14CloseUsesOperationTimeout(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
setOperationTimeoutForTest(t, 20*time.Millisecond)
|
||
|
||
blockingProvider := sdktrace.NewTracerProvider(sdktrace.WithSyncer(blockingExporter{}))
|
||
tracerProviderPtr.Store(blockingProvider)
|
||
|
||
start := time.Now()
|
||
err := Close(context.Background())
|
||
elapsed := time.Since(start)
|
||
if !errors.Is(err, context.DeadlineExceeded) {
|
||
t.Fatalf("Close error = %v, want context deadline exceeded", err)
|
||
}
|
||
if elapsed > 500*time.Millisecond {
|
||
t.Fatalf("Close took %s, expected operation timeout to bound shutdown", elapsed)
|
||
}
|
||
}
|
||
|
||
func TestM14InitDisabledShutdownUsesOperationTimeout(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
setOperationTimeoutForTest(t, 20*time.Millisecond)
|
||
|
||
blockingProvider := sdktrace.NewTracerProvider(sdktrace.WithSyncer(blockingExporter{}))
|
||
tracerProviderPtr.Store(blockingProvider)
|
||
|
||
start := time.Now()
|
||
if err := Init(Config{Enabled: false, ServiceName: "svc"}); err != nil {
|
||
t.Fatalf("Init disabled: %v", err)
|
||
}
|
||
if elapsed := time.Since(start); elapsed > 500*time.Millisecond {
|
||
t.Fatalf("Init disabled took %s, expected operation timeout to bound old provider shutdown", elapsed)
|
||
}
|
||
}
|
||
|
||
func TestM14RecordErrorNilInputsNoPanic(t *testing.T) {
|
||
gin.SetMode(gin.TestMode)
|
||
c, _ := gin.CreateTestContext(httptest.NewRecorder())
|
||
c.Request = httptest.NewRequest(http.MethodGet, "/", nil)
|
||
|
||
requireNoPanic(t, func() { RecordError(nil, errors.New("boom")) })
|
||
requireNoPanic(t, func() { RecordError(c, nil) })
|
||
|
||
var nilSpan oteltrace.Span
|
||
requireNoPanic(t, func() { RecordErrorToSpan(nilSpan, errors.New("boom")) })
|
||
requireNoPanic(t, func() {
|
||
RecordErrorToSpan(oteltrace.SpanFromContext(context.Background()), nil)
|
||
})
|
||
}
|
||
|
||
func TestM14NoZeroTraceIDHeaderFromNoop(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
gin.SetMode(gin.TestMode)
|
||
r := gin.New()
|
||
r.Use(Middleware("svc"))
|
||
r.GET("/p", func(c *gin.Context) {
|
||
c.Status(http.StatusOK)
|
||
})
|
||
|
||
w := httptest.NewRecorder()
|
||
req := httptest.NewRequest(http.MethodGet, "/p", nil)
|
||
r.ServeHTTP(w, req)
|
||
|
||
const zeroTraceID = "00000000000000000000000000000000"
|
||
if got := w.Header().Get("X-Trace-ID"); got == zeroTraceID {
|
||
t.Fatalf("X-Trace-ID should not expose all-zero TraceID, got %q", got)
|
||
}
|
||
}
|
||
|
||
func TestM14MiddlewareServiceNameAttribute(t *testing.T) {
|
||
resetGlobal(t)
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
exporter := &recordingExporter{}
|
||
provider := sdktrace.NewTracerProvider(
|
||
sdktrace.WithSyncer(exporter),
|
||
sdktrace.WithSampler(sdktrace.AlwaysSample()),
|
||
)
|
||
tracer := provider.Tracer("test")
|
||
tracerProviderPtr.Store(provider)
|
||
tracerPtr.Store(&tracer)
|
||
|
||
gin.SetMode(gin.TestMode)
|
||
r := gin.New()
|
||
r.Use(Middleware("middleware-svc"))
|
||
r.GET("/p", func(c *gin.Context) {
|
||
c.Status(http.StatusOK)
|
||
})
|
||
|
||
w := httptest.NewRecorder()
|
||
req := httptest.NewRequest(http.MethodGet, "/p", nil)
|
||
r.ServeHTTP(w, req)
|
||
|
||
for _, span := range exporter.Spans() {
|
||
for _, attr := range span.Attributes() {
|
||
if string(attr.Key) == "service.name" && attr.Value.AsString() == "middleware-svc" {
|
||
return
|
||
}
|
||
}
|
||
}
|
||
t.Fatal("server span missing service.name attribute from Middleware(serviceName)")
|
||
}
|
||
|
||
// TestM65PropagatorFailureLeavesOtelUsable 验证传播器失败时 otel 全局未被切到
|
||
// 已 Shutdown 的 provider（M-65）。失败后仍可正常 start span 不 panic。
|
||
func TestM65PropagatorFailureLeavesOtelUsable(t *testing.T) {
|
||
t.Cleanup(func() { resetGlobal(t) })
|
||
|
||
// 先成功 Init 一个
|
||
if err := Init(Config{Enabled: true, ServiceName: "svc", ExporterType: "stdout", Propagator: "w3c"}); err != nil {
|
||
t.Fatalf("setup Init: %v", err)
|
||
}
|
||
|
||
// 再用非法传播器 Init，应失败
|
||
err := Init(Config{Enabled: true, ExporterType: "stdout", Propagator: "xyz"})
|
||
if err == nil {
|
||
t.Fatal("Init with bad propagator should fail")
|
||
}
|
||
|
||
// otel 全局 provider 仍可用：StartSpan 不 panic
|
||
tr := otel.Tracer("test")
|
||
_, span := tr.Start(context.Background(), "after-failure")
|
||
span.End()
|
||
}
|