OpenTelemetry Logs and Access Logs
Co-authored-by: Kevin Pollet <pollet.kevin@gmail.com>
This commit is contained in:
Romain
GitHub
parent
33c1d700c0
commit
826a2b74aa
33 changed files with 2297 additions and 475 deletions
|
|
@ -1,164 +0,0 @@
|
|||
package opentelemetry
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
"net"
|
||||
"net/url"
|
||||
"time"
|
||||
|
||||
"github.com/rs/zerolog/log"
|
||||
"github.com/traefik/traefik/v3/pkg/types"
|
||||
"github.com/traefik/traefik/v3/pkg/version"
|
||||
"go.opentelemetry.io/otel"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
|
||||
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
|
||||
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
|
||||
"go.opentelemetry.io/otel/sdk/resource"
|
||||
sdktrace "go.opentelemetry.io/otel/sdk/trace"
|
||||
semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
|
||||
"go.opentelemetry.io/otel/trace"
|
||||
"google.golang.org/grpc/credentials"
|
||||
"google.golang.org/grpc/encoding/gzip"
|
||||
)
|
||||
|
||||
// Config provides configuration settings for the open-telemetry tracer.
|
||||
type Config struct {
|
||||
GRPC *types.OtelGRPC `description:"gRPC configuration for the OpenTelemetry collector." json:"grpc,omitempty" toml:"grpc,omitempty" yaml:"grpc,omitempty" label:"allowEmpty" file:"allowEmpty" export:"true"`
|
||||
HTTP *types.OtelHTTP `description:"HTTP configuration for the OpenTelemetry collector." json:"http,omitempty" toml:"http,omitempty" yaml:"http,omitempty" label:"allowEmpty" file:"allowEmpty" export:"true"`
|
||||
}
|
||||
|
||||
// SetDefaults sets the default values.
|
||||
func (c *Config) SetDefaults() {
|
||||
c.HTTP = &types.OtelHTTP{}
|
||||
c.HTTP.SetDefaults()
|
||||
}
|
||||
|
||||
// Setup sets up the tracer.
|
||||
func (c *Config) Setup(serviceName string, sampleRate float64, globalAttributes map[string]string) (trace.Tracer, io.Closer, error) {
|
||||
var (
|
||||
err error
|
||||
exporter *otlptrace.Exporter
|
||||
)
|
||||
if c.GRPC != nil {
|
||||
exporter, err = c.setupGRPCExporter()
|
||||
} else {
|
||||
exporter, err = c.setupHTTPExporter()
|
||||
}
|
||||
if err != nil {
|
||||
return nil, nil, fmt.Errorf("setting up exporter: %w", err)
|
||||
}
|
||||
|
||||
attr := []attribute.KeyValue{
|
||||
semconv.ServiceNameKey.String(serviceName),
|
||||
semconv.ServiceVersionKey.String(version.Version),
|
||||
}
|
||||
|
||||
for k, v := range globalAttributes {
|
||||
attr = append(attr, attribute.String(k, v))
|
||||
}
|
||||
|
||||
res, err := resource.New(context.Background(),
|
||||
resource.WithAttributes(attr...),
|
||||
resource.WithFromEnv(),
|
||||
resource.WithTelemetrySDK(),
|
||||
resource.WithOSType(),
|
||||
resource.WithProcessCommandArgs(),
|
||||
)
|
||||
if err != nil {
|
||||
return nil, nil, fmt.Errorf("building resource: %w", err)
|
||||
}
|
||||
|
||||
// Register the trace exporter with a TracerProvider, using a batch
|
||||
// span processor to aggregate spans before export.
|
||||
bsp := sdktrace.NewBatchSpanProcessor(exporter)
|
||||
tracerProvider := sdktrace.NewTracerProvider(
|
||||
sdktrace.WithSampler(sdktrace.TraceIDRatioBased(sampleRate)),
|
||||
sdktrace.WithResource(res),
|
||||
sdktrace.WithSpanProcessor(bsp),
|
||||
)
|
||||
|
||||
otel.SetTracerProvider(tracerProvider)
|
||||
|
||||
log.Debug().Msg("OpenTelemetry tracer configured")
|
||||
|
||||
return tracerProvider.Tracer("github.com/traefik/traefik"), &tpCloser{provider: tracerProvider}, err
|
||||
}
|
||||
|
||||
func (c *Config) setupHTTPExporter() (*otlptrace.Exporter, error) {
|
||||
endpoint, err := url.Parse(c.HTTP.Endpoint)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid collector endpoint %q: %w", c.HTTP.Endpoint, err)
|
||||
}
|
||||
|
||||
opts := []otlptracehttp.Option{
|
||||
otlptracehttp.WithEndpoint(endpoint.Host),
|
||||
otlptracehttp.WithHeaders(c.HTTP.Headers),
|
||||
otlptracehttp.WithCompression(otlptracehttp.GzipCompression),
|
||||
}
|
||||
|
||||
if endpoint.Scheme == "http" {
|
||||
opts = append(opts, otlptracehttp.WithInsecure())
|
||||
}
|
||||
|
||||
if endpoint.Path != "" {
|
||||
opts = append(opts, otlptracehttp.WithURLPath(endpoint.Path))
|
||||
}
|
||||
|
||||
if c.HTTP.TLS != nil {
|
||||
tlsConfig, err := c.HTTP.TLS.CreateTLSConfig(context.Background())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("creating TLS client config: %w", err)
|
||||
}
|
||||
|
||||
opts = append(opts, otlptracehttp.WithTLSClientConfig(tlsConfig))
|
||||
}
|
||||
|
||||
return otlptrace.New(context.Background(), otlptracehttp.NewClient(opts...))
|
||||
}
|
||||
|
||||
func (c *Config) setupGRPCExporter() (*otlptrace.Exporter, error) {
|
||||
host, port, err := net.SplitHostPort(c.GRPC.Endpoint)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid collector endpoint %q: %w", c.GRPC.Endpoint, err)
|
||||
}
|
||||
|
||||
opts := []otlptracegrpc.Option{
|
||||
otlptracegrpc.WithEndpoint(fmt.Sprintf("%s:%s", host, port)),
|
||||
otlptracegrpc.WithHeaders(c.GRPC.Headers),
|
||||
otlptracegrpc.WithCompressor(gzip.Name),
|
||||
}
|
||||
|
||||
if c.GRPC.Insecure {
|
||||
opts = append(opts, otlptracegrpc.WithInsecure())
|
||||
}
|
||||
|
||||
if c.GRPC.TLS != nil {
|
||||
tlsConfig, err := c.GRPC.TLS.CreateTLSConfig(context.Background())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("creating TLS client config: %w", err)
|
||||
}
|
||||
|
||||
opts = append(opts, otlptracegrpc.WithTLSCredentials(credentials.NewTLS(tlsConfig)))
|
||||
}
|
||||
|
||||
return otlptrace.New(context.Background(), otlptracegrpc.NewClient(opts...))
|
||||
}
|
||||
|
||||
// tpCloser converts a TraceProvider into an io.Closer.
|
||||
type tpCloser struct {
|
||||
provider *sdktrace.TracerProvider
|
||||
}
|
||||
|
||||
func (t *tpCloser) Close() error {
|
||||
if t == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(5*time.Second))
|
||||
defer cancel()
|
||||
|
||||
return t.provider.Shutdown(ctx)
|
||||
}
|
||||
|
|
@ -1,324 +0,0 @@
|
|||
package opentelemetry_test
|
||||
|
||||
import (
|
||||
"compress/gzip"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/containous/alice"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
"github.com/traefik/traefik/v3/pkg/config/static"
|
||||
"github.com/traefik/traefik/v3/pkg/middlewares/observability"
|
||||
"github.com/traefik/traefik/v3/pkg/tracing"
|
||||
"github.com/traefik/traefik/v3/pkg/tracing/opentelemetry"
|
||||
"github.com/traefik/traefik/v3/pkg/types"
|
||||
"go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp"
|
||||
)
|
||||
|
||||
func TestTracing(t *testing.T) {
|
||||
tests := []struct {
|
||||
desc string
|
||||
propagators string
|
||||
headers map[string]string
|
||||
wantServiceHeadersFn func(t *testing.T, headers http.Header)
|
||||
assertFn func(*testing.T, string)
|
||||
}{
|
||||
{
|
||||
desc: "service name and version",
|
||||
assertFn: func(t *testing.T, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `({"key":"service.name","value":{"stringValue":"traefik"}})`, trace)
|
||||
assert.Regexp(t, `({"key":"service.version","value":{"stringValue":"dev"}})`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000001")`, trace)
|
||||
assert.Regexp(t, `("traceState":"foo=bar")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000002")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000002")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"5759e988bd862e3fe1be46a994272793")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "no propagation",
|
||||
propagators: "none",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Empty(t, headers)
|
||||
},
|
||||
assertFn: func(t *testing.T, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
traceCh := make(chan string)
|
||||
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)
|
||||
|
||||
marshalledReq, err := json.Marshal(req)
|
||||
require.NoError(t, err)
|
||||
|
||||
traceCh <- string(marshalledReq)
|
||||
}))
|
||||
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 := tracing.TracerFromContext(r.Context())
|
||||
ctx, span := tracer.Start(r.Context(), "service")
|
||||
defer span.End()
|
||||
|
||||
r = r.WithContext(ctx)
|
||||
|
||||
tracing.InjectContextIntoCarrier(r)
|
||||
|
||||
if test.wantServiceHeadersFn != nil {
|
||||
test.wantServiceHeadersFn(t, r.Header)
|
||||
}
|
||||
})
|
||||
|
||||
tracingConfig := &static.Tracing{
|
||||
ServiceName: "traefik",
|
||||
SampleRate: 1.0,
|
||||
OTLP: &opentelemetry.Config{
|
||||
HTTP: &types.OtelHTTP{
|
||||
Endpoint: collector.URL,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
newTracing, closer, err := tracing.NewTracing(tracingConfig)
|
||||
require.NoError(t, err)
|
||||
t.Cleanup(func() {
|
||||
_ = closer.Close()
|
||||
})
|
||||
|
||||
chain := alice.New(observability.WrapEntryPointHandler(context.Background(), newTracing, nil, "test"))
|
||||
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 trace := <-traceCh:
|
||||
assert.Equal(t, http.StatusOK, rw.Code)
|
||||
if test.assertFn != nil {
|
||||
test.assertFn(t, trace)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -13,7 +13,7 @@ import (
|
|||
|
||||
"github.com/rs/zerolog/log"
|
||||
"github.com/traefik/traefik/v3/pkg/config/static"
|
||||
"github.com/traefik/traefik/v3/pkg/tracing/opentelemetry"
|
||||
"github.com/traefik/traefik/v3/pkg/types"
|
||||
"go.opentelemetry.io/contrib/propagators/autoprop"
|
||||
"go.opentelemetry.io/otel"
|
||||
"go.opentelemetry.io/otel/attribute"
|
||||
|
|
@ -38,7 +38,7 @@ func NewTracing(conf *static.Tracing) (*Tracer, io.Closer, error) {
|
|||
|
||||
if backend == nil {
|
||||
log.Debug().Msg("Could not initialize tracing, using OpenTelemetry by default")
|
||||
defaultBackend := &opentelemetry.Config{}
|
||||
defaultBackend := &types.OTelTracing{}
|
||||
backend = defaultBackend
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,10 +1,22 @@
|
|||
package tracing
|
||||
|
||||
import (
|
||||
"compress/gzip"
|
||||
"encoding/json"
|
||||
"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"
|
||||
"github.com/traefik/traefik/v3/pkg/types"
|
||||
"go.opentelemetry.io/collector/pdata/ptrace/ptraceotlp"
|
||||
"go.opentelemetry.io/otel/trace"
|
||||
)
|
||||
|
||||
func Test_safeFullURL(t *testing.T) {
|
||||
|
|
@ -55,3 +67,315 @@ func Test_safeFullURL(t *testing.T) {
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTracing(t *testing.T) {
|
||||
tests := []struct {
|
||||
desc string
|
||||
propagators string
|
||||
headers map[string]string
|
||||
wantServiceHeadersFn func(t *testing.T, headers http.Header)
|
||||
assertFn func(*testing.T, string)
|
||||
}{
|
||||
{
|
||||
desc: "service name and version",
|
||||
assertFn: func(t *testing.T, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `({"key":"service.name","value":{"stringValue":"traefik"}})`, trace)
|
||||
assert.Regexp(t, `({"key":"service.version","value":{"stringValue":"dev"}})`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000001")`, trace)
|
||||
assert.Regexp(t, `("traceState":"foo=bar")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000002")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"0000000000000002")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"00000000000000000000000000000001")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"5759e988bd862e3fe1be46a994272793")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
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, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
{
|
||||
desc: "no propagation",
|
||||
propagators: "none",
|
||||
wantServiceHeadersFn: func(t *testing.T, headers http.Header) {
|
||||
t.Helper()
|
||||
|
||||
assert.Empty(t, headers)
|
||||
},
|
||||
assertFn: func(t *testing.T, trace string) {
|
||||
t.Helper()
|
||||
|
||||
assert.Regexp(t, `("traceId":"\w{32}")`, trace)
|
||||
assert.Regexp(t, `("parentSpanId":"\w{16}")`, trace)
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
traceCh := make(chan string)
|
||||
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)
|
||||
|
||||
marshalledReq, err := json.Marshal(req)
|
||||
require.NoError(t, err)
|
||||
|
||||
traceCh <- string(marshalledReq)
|
||||
}))
|
||||
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,
|
||||
OTLP: &types.OTelTracing{
|
||||
HTTP: &types.OTelHTTP{
|
||||
Endpoint: collector.URL,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
tracer, closer, err := NewTracing(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 trace := <-traceCh:
|
||||
assert.Equal(t, http.StatusOK, rw.Code)
|
||||
if test.assertFn != nil {
|
||||
test.assertFn(t, trace)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue