fix: otel not working without USER
This commit is contained in:
Michael
GitHub
parent
ad566ee9ef
commit
c5ed376d5f
127 changed files with 347 additions and 305 deletions
504
pkg/observability/tracing/tracing_test.go
Normal file
504
pkg/observability/tracing/tracing_test.go
Normal file
|
|
@ -0,0 +1,504 @@
|
|||
package tracing
|
||||
|
||||
import (
|
||||
"compress/gzip"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/containous/alice"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"github.com/traefik/traefik/v3/pkg/config/static"
|
||||
otypes "github.com/traefik/traefik/v3/pkg/observability/types"
|
||||
"go.opentelemetry.io/collector/pdata/pcommon"
|
||||
"go.opentelemetry.io/collector/pdata/ptrace"
|
||||
"go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp"
|
||||
"go.opentelemetry.io/otel/trace"
|
||||
"go.opentelemetry.io/otel/trace/noop"
|
||||
)
|
||||
|
||||
func Test_safeFullURL(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
safeQueryParams []string
|
||||
originalURL *url.URL
|
||||
expectedURL *url.URL
|
||||
}{
|
||||
{
|
||||
desc: "Nil URL",
|
||||
originalURL: nil,
|
||||
expectedURL: nil,
|
||||
},
|
||||
{
|
||||
desc: "No query parameters",
|
||||
originalURL: &url.URL{Scheme: "https", Host: "example.com"},
|
||||
expectedURL: &url.URL{Scheme: "https", Host: "example.com"},
|
||||
},
|
||||
{
|
||||
desc: "All query parameters redacted",
|
||||
originalURL: &url.URL{Scheme: "https", Host: "example.com", RawQuery: "foo=bar&baz=qux"},
|
||||
expectedURL: &url.URL{Scheme: "https", Host: "example.com", RawQuery: "baz=REDACTED&foo=REDACTED"},
|
||||
},
|
||||
{
|
||||
desc: "Some query parameters unredacted",
|
||||
safeQueryParams: []string{"foo"},
|
||||
originalURL: &url.URL{Scheme: "https", Host: "example.com", RawQuery: "foo=bar&baz=qux"},
|
||||
expectedURL: &url.URL{Scheme: "https", Host: "example.com", RawQuery: "baz=REDACTED&foo=bar"},
|
||||
},
|
||||
{
|
||||
desc: "User info and some query parameters redacted",
|
||||
safeQueryParams: []string{"foo"},
|
||||
originalURL: &url.URL{Scheme: "https", Host: "example.com", User: url.UserPassword("username", "password"), RawQuery: "foo=bar&baz=qux"},
|
||||
expectedURL: &url.URL{Scheme: "https", Host: "example.com", User: url.UserPassword("REDACTED", "REDACTED"), RawQuery: "baz=REDACTED&foo=bar"},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
tr := NewTracer(nil, nil, nil, test.safeQueryParams)
|
||||
|
||||
gotURL := tr.safeURL(test.originalURL)
|
||||
|
||||
assert.Equal(t, test.expectedURL, gotURL)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTracing(t *testing.T) {
|
||||
tests := []struct {
|
||||
desc string
|
||||
propagators string
|
||||
headers map[string]string
|
||||
resourceAttributes map[string]string
|
||||
wantServiceHeadersFn func(t *testing.T, headers http.Header)
|
||||
assertFn func(*testing.T, ptrace.Traces)
|
||||
}{
|
||||
{
|
||||
desc: "service name and version",
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
attributes := resourceAttributes(traces)
|
||||
assert.Equal(t, "traefik", attributes["service.name"])
|
||||
assert.Equal(t, "dev", attributes["service.version"])
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "resource attributes must be propagated",
|
||||
resourceAttributes: map[string]string{
|
||||
"service.environment": "custom",
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
attributes := resourceAttributes(traces)
|
||||
assert.Equal(t, "custom", attributes["service.environment"])
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "TraceContext propagation",
|
||||
propagators: "tracecontext",
|
||||
headers: map[string]string{
|
||||
"traceparent": "00-00000000000000000000000000000001-0000000000000001-01",
|
||||
"tracestate": "foo=bar",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(00-00000000000000000000000000000001-\w{16}-01)`, headers["Traceparent"][0])
|
||||
assert.Equal(t, []string{"foo=bar"}, headers["Tracestate"])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Equal(t, "00000000000000000000000000000001", span.TraceID().String())
|
||||
assert.Equal(t, "0000000000000001", span.ParentSpanID().String())
|
||||
assert.Equal(t, "foo=bar", span.TraceState().AsRaw())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "root span TraceContext propagation",
|
||||
propagators: "tracecontext",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(00-\w{32}-\w{16}-01)`, headers["Traceparent"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "B3 propagation",
|
||||
propagators: "b3",
|
||||
headers: map[string]string{
|
||||
"b3": "00000000000000000000000000000001-0000000000000002-1-0000000000000001",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(00000000000000000000000000000001-\w{16}-1)`, headers["B3"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Equal(t, "00000000000000000000000000000001", span.TraceID().String())
|
||||
assert.Equal(t, "0000000000000002", span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "root span B3 propagation",
|
||||
propagators: "b3",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(\w{32}-\w{16}-1)`, headers["B3"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "B3 propagation Multiple Headers",
|
||||
propagators: "b3multi",
|
||||
headers: map[string]string{
|
||||
"x-b3-traceid": "00000000000000000000000000000001",
|
||||
"x-b3-parentspanid": "0000000000000001",
|
||||
"x-b3-spanid": "0000000000000002",
|
||||
"x-b3-sampled": "1",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Equal(t, "00000000000000000000000000000001", headers["X-B3-Traceid"][0])
|
||||
assert.Equal(t, "0000000000000001", headers["X-B3-Parentspanid"][0])
|
||||
assert.Equal(t, "1", headers["X-B3-Sampled"][0])
|
||||
assert.Len(t, headers["X-B3-Spanid"][0], 16)
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Equal(t, "00000000000000000000000000000001", span.TraceID().String())
|
||||
assert.Equal(t, "0000000000000002", span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "root span B3 propagation Multiple Headers",
|
||||
propagators: "b3multi",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(\w{32})`, headers["X-B3-Traceid"][0])
|
||||
assert.Equal(t, "1", headers["X-B3-Sampled"][0])
|
||||
assert.Regexp(t, `(\w{16})`, headers["X-B3-Spanid"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "Baggage propagation",
|
||||
propagators: "baggage",
|
||||
headers: map[string]string{
|
||||
"baggage": "userId=id",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Equal(t, []string{"userId=id"}, headers["Baggage"])
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "Jaeger propagation",
|
||||
propagators: "jaeger",
|
||||
headers: map[string]string{
|
||||
"uber-trace-id": "00000000000000000000000000000001:0000000000000002:0000000000000001:1",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(00000000000000000000000000000001:\w{16}:0:1)`, headers["Uber-Trace-Id"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Equal(t, "00000000000000000000000000000001", span.TraceID().String())
|
||||
assert.Len(t, span.ParentSpanID().String(), 16)
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "root span Jaeger propagation",
|
||||
propagators: "jaeger",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(\w{32}:\w{16}:0:1)`, headers["Uber-Trace-Id"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "XRay propagation",
|
||||
propagators: "xray",
|
||||
headers: map[string]string{
|
||||
"X-Amzn-Trace-Id": "Root=1-5759e988-bd862e3fe1be46a994272793;Parent=53995c3f42cd8ad8;Sampled=1",
|
||||
},
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(Root=1-5759e988-bd862e3fe1be46a994272793;Parent=\w{16};Sampled=1)`, headers["X-Amzn-Trace-Id"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Equal(t, "5759e988bd862e3fe1be46a994272793", span.TraceID().String())
|
||||
assert.Len(t, span.ParentSpanID().String(), 16)
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "root span XRay propagation",
|
||||
propagators: "xray",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `(Root=1-\w{8}-\w{24};Parent=\w{16};Sampled=1)`, headers["X-Amzn-Trace-Id"][0])
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "no propagation",
|
||||
propagators: "none",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Empty(t, headers)
|
||||
},
|
||||
assertFn: func(t *testing.T, traces ptrace.Traces) {
|
||||
t.Helper()
|
||||
|
||||
span := mainSpan(traces)
|
||||
assert.Len(t, span.TraceID().String(), 32)
|
||||
assert.Empty(t, span.ParentSpanID().String())
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
traceCh := make(chan ptrace.Traces)
|
||||
collector := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
gzr, err := gzip.NewReader(r.Body)
|
||||
require.NoError(t, err)
|
||||
|
||||
body, err := io.ReadAll(gzr)
|
||||
require.NoError(t, err)
|
||||
|
||||
req := ptraceotlp.NewExportRequest()
|
||||
err = req.UnmarshalProto(body)
|
||||
require.NoError(t, err)
|
||||
|
||||
traceCh <- req.Traces()
|
||||
}))
|
||||
t.Cleanup(collector.Close)
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Setenv("OTEL_PROPAGATORS", test.propagators)
|
||||
|
||||
service := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
tracer := TracerFromContext(r.Context())
|
||||
ctx, span := tracer.Start(r.Context(), "service")
|
||||
defer span.End()
|
||||
|
||||
r = r.WithContext(ctx)
|
||||
|
||||
InjectContextIntoCarrier(r)
|
||||
|
||||
if test.wantServiceHeadersFn != nil {
|
||||
test.wantServiceHeadersFn(t, r.Header)
|
||||
}
|
||||
})
|
||||
|
||||
tracingConfig := &static.Tracing{
|
||||
ServiceName: "traefik",
|
||||
SampleRate: 1.0,
|
||||
ResourceAttributes: test.resourceAttributes,
|
||||
OTLP: &otypes.OTelTracing{
|
||||
HTTP: &otypes.OTelHTTP{
|
||||
Endpoint: collector.URL,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tracer, closer, err := NewTracing(t.Context(), tracingConfig)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() {
|
||||
_ = closer.Close()
|
||||
})
|
||||
|
||||
chain := alice.New(func(next http.Handler) (http.Handler, error) {
|
||||
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
tracingCtx := ExtractCarrierIntoContext(r.Context(), r.Header)
|
||||
start := time.Now()
|
||||
tracingCtx, span := tracer.Start(tracingCtx, "test", trace.WithSpanKind(trace.SpanKindServer), trace.WithTimestamp(start))
|
||||
end := time.Now()
|
||||
span.End(trace.WithTimestamp(end))
|
||||
next.ServeHTTP(w, r.WithContext(tracingCtx))
|
||||
}), nil
|
||||
})
|
||||
|
||||
epHandler, err := chain.Then(service)
|
||||
require.NoError(t, err)
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "http://www.test.com", nil)
|
||||
for k, v := range test.headers {
|
||||
req.Header.Set(k, v)
|
||||
}
|
||||
|
||||
rw := httptest.NewRecorder()
|
||||
|
||||
epHandler.ServeHTTP(rw, req)
|
||||
|
||||
select {
|
||||
case <-time.After(10 * time.Second):
|
||||
t.Error("Trace not exported")
|
||||
|
||||
case traces := <-traceCh:
|
||||
assert.Equal(t, http.StatusOK, rw.Code)
|
||||
if test.assertFn != nil {
|
||||
test.assertFn(t, traces)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestTracerProvider ensures that Tracer returns a valid TracerProvider
|
||||
// when using the default Traefik Tracer and a custom one.
|
||||
func TestTracerProvider(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
otlpConfig := &otypes.OTelTracing{}
|
||||
otlpConfig.SetDefaults()
|
||||
|
||||
config := &static.Tracing{OTLP: otlpConfig}
|
||||
tracer, closer, err := NewTracing(t.Context(), config)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
closer.Close()
|
||||
|
||||
_, span := tracer.Start(t.Context(), "test")
|
||||
defer span.End()
|
||||
|
||||
span.TracerProvider().Tracer("github.com/traefik/traefik")
|
||||
span.TracerProvider().Tracer("other")
|
||||
}
|
||||
|
||||
// TestNewTracer_HeadersCanonicalization tests that NewTracer properly canonicalizes headers.
|
||||
func TestNewTracer_HeadersCanonicalization(t *testing.T) {
|
||||
testCases := []struct {
|
||||
desc string
|
||||
inputHeaders []string
|
||||
expectedCanonicalHeaders []string
|
||||
}{
|
||||
{
|
||||
desc: "Empty headers",
|
||||
inputHeaders: []string{},
|
||||
expectedCanonicalHeaders: []string{},
|
||||
},
|
||||
{
|
||||
desc: "Already canonical headers",
|
||||
inputHeaders: []string{"Content-Type", "User-Agent", "Accept-Encoding"},
|
||||
expectedCanonicalHeaders: []string{"Content-Type", "User-Agent", "Accept-Encoding"},
|
||||
},
|
||||
{
|
||||
desc: "Lowercase headers",
|
||||
inputHeaders: []string{"content-type", "user-agent", "accept-encoding"},
|
||||
expectedCanonicalHeaders: []string{"Content-Type", "User-Agent", "Accept-Encoding"},
|
||||
},
|
||||
{
|
||||
desc: "Mixed case headers",
|
||||
inputHeaders: []string{"CoNtEnT-tYpE", "uSeR-aGeNt", "aCcEpT-eNcOdInG"},
|
||||
expectedCanonicalHeaders: []string{"Content-Type", "User-Agent", "Accept-Encoding"},
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range testCases {
|
||||
t.Run(test.desc, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Create a mock tracer using a no-op tracer from OpenTelemetry
|
||||
mockTracer := noop.NewTracerProvider().Tracer("test")
|
||||
|
||||
// Test capturedRequestHeaders
|
||||
tracer := NewTracer(mockTracer, test.inputHeaders, nil, nil)
|
||||
assert.Equal(t, test.expectedCanonicalHeaders, tracer.capturedRequestHeaders)
|
||||
assert.Nil(t, tracer.capturedResponseHeaders)
|
||||
|
||||
// Test capturedResponseHeaders
|
||||
tracer = NewTracer(mockTracer, nil, test.inputHeaders, nil)
|
||||
assert.Equal(t, test.expectedCanonicalHeaders, tracer.capturedResponseHeaders)
|
||||
assert.Nil(t, tracer.capturedRequestHeaders)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// resourceAttributes extracts resource attributes as a map.
|
||||
func resourceAttributes(traces ptrace.Traces) map[string]string {
|
||||
attributes := make(map[string]string)
|
||||
if traces.ResourceSpans().Len() > 0 {
|
||||
resource := traces.ResourceSpans().At(0).Resource()
|
||||
resource.Attributes().Range(func(k string, v pcommon.Value) bool {
|
||||
if v.Type() == pcommon.ValueTypeStr {
|
||||
attributes[k] = v.Str()
|
||||
}
|
||||
return true
|
||||
})
|
||||
}
|
||||
return attributes
|
||||
}
|
||||
|
||||
// mainSpan gets the main span from traces (assumes single span for testing).
|
||||
func mainSpan(traces ptrace.Traces) ptrace.Span {
|
||||
for _, resourceSpans := range traces.ResourceSpans().All() {
|
||||
for _, scopeSpans := range resourceSpans.ScopeSpans().All() {
|
||||
if scopeSpans.Spans().Len() > 0 {
|
||||
return scopeSpans.Spans().At(0)
|
||||
}
|
||||
}
|
||||
}
|
||||
return ptrace.NewSpan()
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue