tracer: update wrapper

Signed-off-by: Vasiliy Tolstov <v.tolstov@unistack.org>

go.mod

@@ -8,14 +8,15 @@ require (
 	github.com/imdario/mergo v0.3.15
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9
 	golang.org/x/sync v0.3.0
-	golang.org/x/sys v0.11.0
+	golang.org/x/sys v0.12.0
 	google.golang.org/grpc v1.57.0
 	google.golang.org/protobuf v1.31.0
+
 )
 
 require (
 	github.com/golang/protobuf v1.5.3 // indirect
-	golang.org/x/net v0.14.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19 // indirect
 )

go.sum

@@ -13,16 +13,17 @@ github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaR
 github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ=
 github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5 h1:G/FZtUu7a6NTWl3KUHMV9jkLAh/Rvtf03NWMHaEDl+E=
 github.com/silas/dag v0.0.0-20220518035006-a7e85ada93c5/go.mod h1:7RTUFBdIRC9nZ7/3RyRNH1bdqIShrDejd1YbLwgPS+I=
-golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
 golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e h1:NumxXLPfHSndr3wBBdeKiVHjGVFzi9RX2HwwQke94iY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19 h1:0nDDozoAU19Qb2HwhXadU8OcsiO/09cnTqhUtq2MEOM=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
 google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=
 google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=

logger/default.go

@@ -1,232 +0,0 @@
-package logger
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"sync"
-	"time"
-
-	"go.unistack.org/micro/v4/options"
-)
-
-type defaultLogger struct {
-	enc  *json.Encoder
-	opts Options
-	sync.RWMutex
-}
-
-// Init(opts...) should only overwrite provided options
-func (l *defaultLogger) Init(opts ...options.Option) error {
-	l.Lock()
-	for _, o := range opts {
-		o(&l.opts)
-	}
-	l.enc = json.NewEncoder(l.opts.Out)
-	// wrap the Log func
-	l.Unlock()
-	return nil
-}
-
-func (l *defaultLogger) String() string {
-	return "micro"
-}
-
-func (l *defaultLogger) Clone(opts ...options.Option) Logger {
-	newopts := NewOptions(opts...)
-	oldopts := l.opts
-	for _, o := range opts {
-		o(&newopts)
-		o(&oldopts)
-	}
-
-	l.Lock()
-	cl := &defaultLogger{opts: oldopts, enc: json.NewEncoder(l.opts.Out)}
-	l.Unlock()
-
-	return cl
-}
-
-func (l *defaultLogger) V(level Level) bool {
-	l.RLock()
-	ok := l.opts.Level.Enabled(level)
-	l.RUnlock()
-	return ok
-}
-
-func (l *defaultLogger) Level(level Level) {
-	l.Lock()
-	l.opts.Level = level
-	l.Unlock()
-}
-
-func (l *defaultLogger) Fields(fields ...interface{}) Logger {
-	l.RLock()
-	nl := &defaultLogger{opts: l.opts, enc: l.enc}
-	if len(fields) == 0 {
-		l.RUnlock()
-		return nl
-	} else if len(fields)%2 != 0 {
-		fields = fields[:len(fields)-1]
-	}
-	nl.opts.Fields = copyFields(l.opts.Fields)
-	nl.opts.Fields = append(nl.opts.Fields, fields...)
-	l.RUnlock()
-	return nl
-}
-
-func copyFields(src []interface{}) []interface{} {
-	dst := make([]interface{}, len(src))
-	copy(dst, src)
-	return dst
-}
-
-// logCallerfilePath returns a package/file:line description of the caller,
-// preserving only the leaf directory name and file name.
-func logCallerfilePath(loggingFilePath string) string {
-	// To make sure we trim the path correctly on Windows too, we
-	// counter-intuitively need to use '/' and *not* os.PathSeparator here,
-	// because the path given originates from Go stdlib, specifically
-	// runtime.Caller() which (as of Mar/17) returns forward slashes even on
-	// Windows.
-	//
-	// See https://github.com/golang/go/issues/3335
-	// and https://github.com/golang/go/issues/18151
-	//
-	// for discussion on the issue on Go side.
-	idx := strings.LastIndexByte(loggingFilePath, '/')
-	if idx == -1 {
-		return loggingFilePath
-	}
-	idx = strings.LastIndexByte(loggingFilePath[:idx], '/')
-	if idx == -1 {
-		return loggingFilePath
-	}
-	return loggingFilePath[idx+1:]
-}
-
-func (l *defaultLogger) Info(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, InfoLevel, args...)
-}
-
-func (l *defaultLogger) Error(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, ErrorLevel, args...)
-}
-
-func (l *defaultLogger) Debug(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, DebugLevel, args...)
-}
-
-func (l *defaultLogger) Warn(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, WarnLevel, args...)
-}
-
-func (l *defaultLogger) Trace(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, TraceLevel, args...)
-}
-
-func (l *defaultLogger) Fatal(ctx context.Context, args ...interface{}) {
-	l.Log(ctx, FatalLevel, args...)
-	os.Exit(1)
-}
-
-func (l *defaultLogger) Infof(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, InfoLevel, msg, args...)
-}
-
-func (l *defaultLogger) Errorf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, ErrorLevel, msg, args...)
-}
-
-func (l *defaultLogger) Debugf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, DebugLevel, msg, args...)
-}
-
-func (l *defaultLogger) Warnf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, WarnLevel, msg, args...)
-}
-
-func (l *defaultLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, TraceLevel, msg, args...)
-}
-
-func (l *defaultLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
-	l.Logf(ctx, FatalLevel, msg, args...)
-	os.Exit(1)
-}
-
-func (l *defaultLogger) Log(ctx context.Context, level Level, args ...interface{}) {
-	if !l.V(level) {
-		return
-	}
-
-	l.RLock()
-	fields := copyFields(l.opts.Fields)
-	l.RUnlock()
-
-	fields = append(fields, "level", level.String())
-
-	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
-	}
-	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
-
-	if len(args) > 0 {
-		fields = append(fields, "msg", fmt.Sprint(args...))
-	}
-
-	out := make(map[string]interface{}, len(fields)/2)
-	for i := 0; i < len(fields); i += 2 {
-		out[fields[i].(string)] = fields[i+1]
-	}
-	l.RLock()
-	_ = l.enc.Encode(out)
-	l.RUnlock()
-}
-
-func (l *defaultLogger) Logf(ctx context.Context, level Level, msg string, args ...interface{}) {
-	if !l.V(level) {
-		return
-	}
-
-	l.RLock()
-	fields := copyFields(l.opts.Fields)
-	l.RUnlock()
-
-	fields = append(fields, "level", level.String())
-
-	if _, file, line, ok := runtime.Caller(l.opts.CallerSkipCount); ok {
-		fields = append(fields, "caller", fmt.Sprintf("%s:%d", logCallerfilePath(file), line))
-	}
-
-	fields = append(fields, "timestamp", time.Now().Format("2006-01-02 15:04:05"))
-	if len(args) > 0 {
-		fields = append(fields, "msg", fmt.Sprintf(msg, args...))
-	} else if msg != "" {
-		fields = append(fields, "msg", msg)
-	}
-
-	out := make(map[string]interface{}, len(fields)/2)
-	for i := 0; i < len(fields); i += 2 {
-		out[fields[i].(string)] = fields[i+1]
-	}
-	l.RLock()
-	_ = l.enc.Encode(out)
-	l.RUnlock()
-}
-
-func (l *defaultLogger) Options() Options {
-	return l.opts
-}
-
-// NewLogger builds a new logger based on options
-func NewLogger(opts ...options.Option) Logger {
-	l := &defaultLogger{
-		opts: NewOptions(opts...),
-	}
-	l.enc = json.NewEncoder(l.opts.Out)
-	return l
-}

logger/logger_test.go

@@ -87,14 +87,14 @@ func TestClone(t *testing.T) {
 
 func TestRedirectStdLogger(t *testing.T) {
 	buf := bytes.NewBuffer(nil)
-	l := NewLogger(WithLevel(TraceLevel), WithOutput(buf))
+	l := NewLogger(WithLevel(ErrorLevel), WithOutput(buf))
 	if err := l.Init(); err != nil {
 		t.Fatal(err)
 	}
 	fn := RedirectStdLogger(l, ErrorLevel)
 	defer fn()
 	log.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test"`)) {
 		t.Fatalf("logger error, buf %s", buf.Bytes())
 	}
 }
@@ -107,7 +107,7 @@ func TestStdLogger(t *testing.T) {
 	}
 	lg := NewStdLogger(l, ErrorLevel)
 	lg.Print("test")
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test","timestamp"`)) {
+	if !bytes.Contains(buf.Bytes(), []byte(`"level":"error","msg":"test"`)) {
 		t.Fatalf("logger error, buf %s", buf.Bytes())
 	}
 }
@@ -120,19 +120,21 @@ func TestLogger(t *testing.T) {
 		t.Fatal(err)
 	}
 	l.Trace(ctx, "trace_msg1")
-	l.Warn(ctx, "warn_msg1")
-	l.Fields("error", "test").Info(ctx, "error message")
-	l.Warn(ctx, "first", " ", "second")
+	//	l.Warn(ctx, "warn_msg1")
+	//	l.Fields("error", "test").Info(ctx, "error message")
+	//	l.Warn(ctx, "first second")
 	if !bytes.Contains(buf.Bytes(), []byte(`"level":"trace","msg":"trace_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"warn","msg":"warn_msg1"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"error":"test","level":"info","msg":"error message"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
-	}
-	if !bytes.Contains(buf.Bytes(), []byte(`"level":"warn","msg":"first second"`)) {
-		t.Fatalf("logger error, buf %s", buf.Bytes())
+		t.Fatalf("logger tracer, buf %s", buf.Bytes())
 	}
+	/*
+		if !bytes.Contains(buf.Bytes(), []byte(`"warn","msg":"warn_msg1"`)) {
+			t.Fatalf("logger warn, buf %s", buf.Bytes())
+		}
+		if !bytes.Contains(buf.Bytes(), []byte(`"error":"test","level":"info","msg":"error message"`)) {
+			t.Fatalf("logger info, buf %s", buf.Bytes())
+		}
+		if !bytes.Contains(buf.Bytes(), []byte(`"level":"warn","msg":"first second"`)) {
+			t.Fatalf("logger warn, buf %s", buf.Bytes())
+		}
+	*/
 }

logger/slog.go

@@ -0,0 +1,245 @@
+package logger
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"go.unistack.org/micro/v4/options"
+
+	"golang.org/x/exp/slog"
+)
+
+var (
+	traceValue = slog.StringValue("trace")
+	debugValue = slog.StringValue("debug")
+	infoValue  = slog.StringValue("info")
+	warnValue  = slog.StringValue("warn")
+	errorValue = slog.StringValue("error")
+	fatalValue = slog.StringValue("fatal")
+)
+
+var renameAttr = func(_ []string, a slog.Attr) slog.Attr {
+	switch a.Key {
+	case slog.TimeKey:
+		a.Key = "timestamp"
+	case slog.LevelKey:
+		level := a.Value.Any().(slog.Level)
+		lvl := slogToLoggerLevel(level)
+		switch {
+		case lvl < DebugLevel:
+			a.Value = traceValue
+		case lvl < InfoLevel:
+			a.Value = debugValue
+		case lvl < WarnLevel:
+			a.Value = infoValue
+		case lvl < ErrorLevel:
+			a.Value = warnValue
+		case lvl < FatalLevel:
+			a.Value = errorValue
+		case lvl >= FatalLevel:
+			a.Value = fatalValue
+		default:
+			a.Value = infoValue
+		}
+	}
+
+	return a
+}
+
+type slogLogger struct {
+	slog    *slog.Logger
+	leveler *slog.LevelVar
+	opts    Options
+}
+
+func (s *slogLogger) Clone(opts ...options.Option) Logger {
+	options := s.opts
+
+	for _, o := range opts {
+		o(&options)
+	}
+
+	l := &slogLogger{
+		opts: options,
+	}
+
+	if slog, ok := s.opts.Context.Value(loggerKey{}).(*slog.Logger); ok {
+		l.slog = slog
+		return nil
+	}
+
+	l.leveler = new(slog.LevelVar)
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: renameAttr,
+		Level:       l.leveler,
+	}
+	l.leveler.Set(loggerToSlogLevel(l.opts.Level))
+	handler := slog.NewJSONHandler(options.Out, handleOpt)
+	l.slog = slog.New(handler).With(options.Fields...)
+
+	return l
+}
+
+func (s *slogLogger) V(level Level) bool {
+	return s.opts.Level.Enabled(level)
+}
+
+func (s *slogLogger) Level(level Level) {
+	s.leveler.Set(loggerToSlogLevel(level))
+}
+
+func (s *slogLogger) Options() Options {
+	return s.opts
+}
+
+func (s *slogLogger) Fields(fields ...interface{}) Logger {
+	nl := &slogLogger{opts: s.opts}
+	nl.leveler = new(slog.LevelVar)
+	nl.leveler.Set(s.leveler.Level())
+
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: renameAttr,
+		Level:       s.leveler,
+	}
+
+	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
+	nl.slog = slog.New(handler).With(fields...)
+
+	return nl
+}
+
+func (s *slogLogger) Init(opts ...options.Option) error {
+	for _, o := range opts {
+		if err := o(&s.opts); err != nil {
+			return err
+		}
+	}
+
+	if slog, ok := s.opts.Context.Value(loggerKey{}).(*slog.Logger); ok {
+		s.slog = slog
+		return nil
+	}
+
+	s.leveler = new(slog.LevelVar)
+	handleOpt := &slog.HandlerOptions{
+		ReplaceAttr: renameAttr,
+		Level:       s.leveler,
+	}
+	s.leveler.Set(loggerToSlogLevel(s.opts.Level))
+	handler := slog.NewJSONHandler(s.opts.Out, handleOpt)
+	s.slog = slog.New(handler).With(s.opts.Fields...)
+
+	return nil
+}
+
+func (s *slogLogger) Log(ctx context.Context, lvl Level, args ...any) {
+	if !s.V(lvl) {
+		return
+	}
+	slvl := loggerToSlogLevel(lvl)
+	msg := fmt.Sprint(args...)
+	s.slog.Log(ctx, slvl, msg)
+}
+
+func (s *slogLogger) Logf(ctx context.Context, lvl Level, format string, args ...any) {
+	if !s.V(lvl) {
+		return
+	}
+	slvl := loggerToSlogLevel(lvl)
+	s.slog.Log(ctx, slvl, format, args...)
+}
+
+func (s *slogLogger) Info(ctx context.Context, args ...any) {
+	s.Log(ctx, InfoLevel, args...)
+}
+
+func (s *slogLogger) Infof(ctx context.Context, format string, args ...interface{}) {
+	s.Logf(ctx, InfoLevel, format, args...)
+}
+
+func (s *slogLogger) Debug(ctx context.Context, args ...any) {
+	s.Log(ctx, DebugLevel, args...)
+}
+
+func (s *slogLogger) Debugf(ctx context.Context, format string, args ...any) {
+	s.Logf(ctx, DebugLevel, format, args...)
+}
+
+func (s *slogLogger) Error(ctx context.Context, args ...any) {
+	s.Log(ctx, ErrorLevel, args...)
+}
+
+func (s *slogLogger) Trace(ctx context.Context, args ...interface{}) {
+	s.Log(ctx, TraceLevel, args...)
+}
+
+func (s *slogLogger) Tracef(ctx context.Context, msg string, args ...interface{}) {
+	s.Logf(ctx, TraceLevel, msg, args...)
+}
+
+func (s *slogLogger) Errorf(ctx context.Context, format string, args ...any) {
+	s.Logf(ctx, ErrorLevel, format, args...)
+}
+
+func (s *slogLogger) Fatal(ctx context.Context, args ...any) {
+	s.Log(ctx, FatalLevel, args...)
+}
+
+func (s *slogLogger) Fatalf(ctx context.Context, msg string, args ...interface{}) {
+	s.Logf(ctx, FatalLevel, msg, args...)
+	os.Exit(1)
+}
+
+func (s *slogLogger) Warn(ctx context.Context, args ...any) {
+	s.Log(ctx, WarnLevel, args...)
+}
+
+func (s *slogLogger) Warnf(ctx context.Context, format string, args ...any) {
+	s.Logf(ctx, WarnLevel, format, args...)
+}
+
+func (s *slogLogger) String() string {
+	return "slog"
+}
+
+func NewLogger(opts ...options.Option) Logger {
+	l := &slogLogger{
+		opts: NewOptions(opts...),
+	}
+	return l
+}
+
+func loggerToSlogLevel(level Level) slog.Level {
+	switch level {
+	case DebugLevel:
+		return slog.LevelDebug
+	case WarnLevel:
+		return slog.LevelWarn
+	case ErrorLevel:
+		return slog.LevelError
+	case TraceLevel:
+		return slog.LevelDebug - 1
+	case FatalLevel:
+		return slog.LevelError + 1
+	default:
+		return slog.LevelInfo
+	}
+}
+
+func slogToLoggerLevel(level slog.Level) Level {
+	switch level {
+	case slog.LevelDebug:
+		return DebugLevel
+	case slog.LevelWarn:
+		return WarnLevel
+	case slog.LevelError:
+		return ErrorLevel
+	case slog.LevelDebug - 1:
+		return TraceLevel
+	case slog.LevelError + 1:
+		return FatalLevel
+	default:
+		return InfoLevel
+	}
+}

tracer/noop.go

@@ -9,27 +9,19 @@ import (
 var _ Tracer = (*noopTracer)(nil)
 
 type noopTracer struct {
-	opts  Options
-	spans []Span
-}
-
-func (t *noopTracer) Spans() []Span {
-	return t.spans
+	opts Options
 }
 
 func (t *noopTracer) Start(ctx context.Context, name string, opts ...options.Option) (context.Context, Span) {
-	options := NewSpanOptions(opts...)
 	span := &noopSpan{
 		name:   name,
 		ctx:    ctx,
 		tracer: t,
-		labels: options.Labels,
-		kind:   options.Kind,
+		opts:   NewSpanOptions(opts...),
 	}
 	if span.ctx == nil {
 		span.ctx = context.Background()
 	}
-	t.spans = append(t.spans, span)
 	return NewSpanContext(ctx, span), span
 }
 
@@ -48,21 +40,13 @@ func (t *noopTracer) Name() string {
 	return t.opts.Name
 }
 
-type noopEvent struct {
-	name   string
-	labels []interface{}
-}
-
 type noopSpan struct {
 	ctx       context.Context
 	tracer    Tracer
 	name      string
-	statusMsg string
-	events    []*noopEvent
-	labels    []interface{}
-	logs      []interface{}
-	kind      SpanKind
+	opts      SpanOptions
 	status    SpanStatus
+	statusMsg string
 }
 
 func (s *noopSpan) Finish(opts ...options.Option) {
@@ -77,24 +61,22 @@ func (s *noopSpan) Tracer() Tracer {
 }
 
 func (s *noopSpan) AddEvent(name string, opts ...options.Option) {
-	options := NewEventOptions(opts...)
-	s.events = append(s.events, &noopEvent{name: name, labels: options.Labels})
 }
 
 func (s *noopSpan) SetName(name string) {
 	s.name = name
 }
 
-func (s *noopSpan) AddLogs(kv ...interface{}) {
-	s.logs = append(s.logs, kv...)
+func (s *noopSpan) SetLabels(labels ...interface{}) {
+	s.opts.Labels = labels
 }
 
-func (s *noopSpan) AddLabels(kv ...interface{}) {
-	s.labels = append(s.labels, kv...)
+func (s *noopSpan) AddLabels(labels ...interface{}) {
+	s.opts.Labels = append(s.opts.Labels, labels...)
 }
 
 func (s *noopSpan) Kind() SpanKind {
-	return s.kind
+	return s.opts.Kind
 }
 
 func (s *noopSpan) Status() (SpanStatus, string) {

tracer/options.go

@@ -2,9 +2,11 @@ package tracer
 
 import (
 	"context"
+	"reflect"
 
 	"go.unistack.org/micro/v4/logger"
 	"go.unistack.org/micro/v4/options"
+	rutil "go.unistack.org/micro/v4/util/reflect"
 )
 
 type SpanStatus int
@@ -93,6 +95,43 @@ type EventOptions struct {
 	Labels []interface{}
 }
 
+func WithSpanLabels(ls ...interface{}) options.Option {
+	return func(src interface{}) error {
+		v, err := options.Get(src, ".Labels")
+		if err != nil {
+			return err
+		} else if rutil.IsZero(v) {
+			v = reflect.MakeSlice(reflect.TypeOf(v), 0, len(ls)).Interface()
+		}
+		cv := reflect.ValueOf(v)
+		for _, l := range ls {
+			reflect.Append(cv, reflect.ValueOf(l))
+		}
+		err = options.Set(src, cv, ".Labels")
+		return err
+	}
+}
+
+// EventOption func signature
+type EventOption func(o *EventOptions)
+
+func WithEventLabels(ls ...interface{}) options.Option {
+	return func(src interface{}) error {
+		v, err := options.Get(src, ".Labels")
+		if err != nil {
+			return err
+		} else if rutil.IsZero(v) {
+			v = reflect.MakeSlice(reflect.TypeOf(v), 0, len(ls)).Interface()
+		}
+		cv := reflect.ValueOf(v)
+		for _, l := range ls {
+			reflect.Append(cv, reflect.ValueOf(l))
+		}
+		err = options.Set(src, cv, ".Labels")
+		return err
+	}
+}
+
 func WithSpanKind(k SpanKind) options.Option {
 	return func(src interface{}) error {
 		return options.Set(src, k, ".Kind")
@@ -120,15 +159,6 @@ func NewSpanOptions(opts ...options.Option) SpanOptions {
 	return options
 }
 
-// NewEventOptions returns default EventOptions
-func NewEventOptions(opts ...options.Option) EventOptions {
-	options := EventOptions{}
-	for _, o := range opts {
-		o(&options)
-	}
-	return options
-}
-
 // NewOptions returns default options
 func NewOptions(opts ...options.Option) Options {
 	options := Options{

tracer/tracer.go

@@ -3,8 +3,6 @@ package tracer // import "go.unistack.org/micro/v4/tracer"
 
 import (
 	"context"
-	"fmt"
-	"sort"
 
 	"go.unistack.org/micro/v4/options"
 )
@@ -29,6 +27,8 @@ type Span interface {
 	Tracer() Tracer
 	// Finish complete and send span
 	Finish(opts ...options.Option)
+	// AddEvent add event to span
+	AddEvent(name string, opts ...options.Option)
 	// Context return context with span
 	Context() context.Context
 	// SetName set the span name
@@ -37,45 +37,10 @@ type Span interface {
 	SetStatus(status SpanStatus, msg string)
 	// Status returns span status and msg
 	Status() (SpanStatus, string)
-	// AddLabels append labels to span
-	AddLabels(kv ...interface{})
-	// AddEvent append event to span
-	AddEvent(name string, opts ...options.Option)
-	// AddLogs append logs to span
-	AddLogs(kv ...interface{})
+	// SetLabels set the span labels
+	SetLabels(labels ...interface{})
+	// AddLabels append the span labels
+	AddLabels(labels ...interface{})
 	// Kind returns span kind
 	Kind() SpanKind
 }
-
-// sort labels alphabeticaly by label name
-type byKey []interface{}
-
-func (k byKey) Len() int           { return len(k) / 2 }
-func (k byKey) Less(i, j int) bool { return fmt.Sprintf("%s", k[i*2]) < fmt.Sprintf("%s", k[j*2]) }
-func (k byKey) Swap(i, j int) {
-	k[i*2], k[j*2] = k[j*2], k[i*2]
-	k[i*2+1], k[j*2+1] = k[j*2+1], k[i*2+1]
-}
-
-func UniqLabels(labels []interface{}) []interface{} {
-	if len(labels)%2 == 1 {
-		labels = labels[:len(labels)-1]
-	}
-	if len(labels) > 2 {
-		sort.Sort(byKey(labels))
-
-		idx := 0
-		for {
-			if labels[idx] == labels[idx+2] {
-				copy(labels[idx:], labels[idx+2:])
-				labels = labels[:len(labels)-2]
-			} else {
-				idx += 2
-			}
-			if idx+2 >= len(labels) {
-				break
-			}
-		}
-	}
-	return labels
-}

tracer/wrapper/wrapper.go

@@ -4,7 +4,6 @@ package wrapper // import "go.unistack.org/micro/v4/tracer/wrapper"
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"go.unistack.org/micro/v4/client"
 	"go.unistack.org/micro/v4/metadata"
@@ -13,13 +12,13 @@ import (
 	"go.unistack.org/micro/v4/tracer"
 )
 
-var DefaultHeadersExctract = []string{metadata.HeaderXRequestID}
+var DefaultHeadersExctract = []string{metadata.HeaderTopic, metadata.HeaderEndpoint, metadata.HeaderService, metadata.HeaderXRequestID}
 
-func ExtractDefaultLabels(md metadata.Metadata) []interface{} {
-	labels := make([]interface{}, 0, len(DefaultHeadersExctract))
+func extractLabels(md metadata.Metadata) []string {
+	labels := make([]string, 0, 5)
 	for _, k := range DefaultHeadersExctract {
 		if v, ok := md.Get(k); ok {
-			labels = append(labels, strings.ToLower(k), v)
+			labels = append(labels, k, v)
 		}
 	}
 	return labels
@@ -27,9 +26,10 @@ func ExtractDefaultLabels(md metadata.Metadata) []interface{} {
 
 var (
 	DefaultClientCallObserver = func(ctx context.Context, req client.Request, rsp interface{}, opts []options.Option, sp tracer.Span, err error) {
+		sp.SetName(fmt.Sprintf("Call %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
 		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
+			labels = append(labels, extractLabels(md))
 		}
 		if err != nil {
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
@@ -38,9 +38,10 @@ var (
 	}
 
 	DefaultClientStreamObserver = func(ctx context.Context, req client.Request, opts []options.Option, stream client.Stream, sp tracer.Span, err error) {
+		sp.SetName(fmt.Sprintf("Stream %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
 		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
+			labels = append(labels, extractLabels(md))
 		}
 		if err != nil {
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
@@ -49,9 +50,10 @@ var (
 	}
 
 	DefaultServerHandlerObserver = func(ctx context.Context, req server.Request, rsp interface{}, sp tracer.Span, err error) {
+		sp.SetName(fmt.Sprintf("Handler %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
 		if md, ok := metadata.FromIncomingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
+			labels = append(labels, extractLabels(md))
 		}
 		if err != nil {
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
@@ -60,10 +62,10 @@ var (
 	}
 
 	DefaultClientCallFuncObserver = func(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions, sp tracer.Span, err error) {
-		sp.SetName(fmt.Sprintf("%s.%s call", req.Service(), req.Method()))
+		sp.SetName(fmt.Sprintf("Call %s.%s", req.Service(), req.Method()))
 		var labels []interface{}
 		if md, ok := metadata.FromOutgoingContext(ctx); ok {
-			labels = append(labels, ExtractDefaultLabels(md)...)
+			labels = append(labels, extractLabels(md))
 		}
 		if err != nil {
 			sp.SetStatus(tracer.SpanStatusError, err.Error())
@@ -175,22 +177,23 @@ func (ot *tWrapper) Call(ctx context.Context, req client.Request, rsp interface{
 		}
 	}
 
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "unary",
-		),
-	)
+	sp, ok := tracer.SpanFromContext(ctx)
+	if !ok {
+		ctx, sp = ot.opts.Tracer.Start(ctx, "rpc-client",
+			tracer.WithSpanKind(tracer.SpanKindClient),
+			tracer.WithSpanLabels(
+				"rpc.flavor", "rpc",
+				"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
+				"rpc.call_type", "unary",
+			),
+		)
+	}
 	defer sp.Finish()
 
-	err := ot.Client.Call(nctx, req, rsp, opts...)
+	err := ot.Client.Call(ctx, req, rsp, opts...)
 
 	for _, o := range ot.opts.ClientCallObservers {
-		o(nctx, req, rsp, opts, sp, err)
+		o(ctx, req, rsp, opts, sp, err)
 	}
 
 	return err
@@ -204,22 +207,23 @@ func (ot *tWrapper) Stream(ctx context.Context, req client.Request, opts ...opti
 		}
 	}
 
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "stream",
-		),
-	)
+	sp, ok := tracer.SpanFromContext(ctx)
+	if !ok {
+		ctx, sp = ot.opts.Tracer.Start(ctx, "rpc-client",
+			tracer.WithSpanKind(tracer.SpanKindClient),
+			tracer.WithSpanLabels(
+				"rpc.flavor", "rpc",
+				"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
+				"rpc.call_type", "stream",
+			),
+		)
+	}
 	defer sp.Finish()
 
-	stream, err := ot.Client.Stream(nctx, req, opts...)
+	stream, err := ot.Client.Stream(ctx, req, opts...)
 
 	for _, o := range ot.opts.ClientStreamObservers {
-		o(nctx, req, opts, stream, sp, err)
+		o(ctx, req, opts, stream, sp, err)
 	}
 
 	return stream, err
@@ -238,22 +242,24 @@ func (ot *tWrapper) ServerHandler(ctx context.Context, req server.Request, rsp i
 		callType = "stream"
 	}
 
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-server", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindServer),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", callType,
-		),
-	)
+	sp, ok := tracer.SpanFromContext(ctx)
+	if !ok {
+		ctx, sp = ot.opts.Tracer.Start(ctx, "rpc-server",
+			tracer.WithSpanKind(tracer.SpanKindServer),
+			tracer.WithSpanLabels(
+				"rpc.flavor", "rpc",
+				"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
+				"rpc.call_type", callType,
+			),
+		)
+	}
+
 	defer sp.Finish()
 
-	err := ot.serverHandler(nctx, req, rsp)
+	err := ot.serverHandler(ctx, req, rsp)
 
 	for _, o := range ot.opts.ServerHandlerObservers {
-		o(nctx, req, rsp, sp, err)
+		o(ctx, req, rsp, sp, err)
 	}
 
 	return err
@@ -291,23 +297,23 @@ func (ot *tWrapper) ClientCallFunc(ctx context.Context, addr string, req client.
 		}
 	}
 
-	nctx, sp := ot.opts.Tracer.Start(ctx, fmt.Sprintf("%s.%s rpc-client", req.Service(), req.Method()),
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		tracer.WithSpanLabels(
-			"rpc.service", req.Service(),
-			"rpc.method", req.Method(),
-			"rpc.flavor", "rpc",
-			"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
-			"rpc.call_type", "unary",
-		),
-	)
-
+	sp, ok := tracer.SpanFromContext(ctx)
+	if !ok {
+		ctx, sp = ot.opts.Tracer.Start(ctx, "rpc-client",
+			tracer.WithSpanKind(tracer.SpanKindClient),
+			tracer.WithSpanLabels(
+				"rpc.flavor", "rpc",
+				"rpc.call", "/"+req.Service()+"/"+req.Endpoint(),
+				"rpc.call_type", "unary",
+			),
+		)
+	}
 	defer sp.Finish()
 
-	err := ot.clientCallFunc(nctx, addr, req, rsp, opts)
+	err := ot.clientCallFunc(ctx, addr, req, rsp, opts)
 
 	for _, o := range ot.opts.ClientCallFuncObservers {
-		o(nctx, addr, req, rsp, opts, sp, err)
+		o(ctx, addr, req, rsp, opts, sp, err)
 	}
 
 	return err

util/grpc/tracer.go

@@ -1,256 +0,0 @@
-package grpc_util
-
-import (
-	"context"
-	"net"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"time"
-
-	"go.unistack.org/micro/v4/options"
-	"go.unistack.org/micro/v4/tracer"
-	grpc_codes "google.golang.org/grpc/codes"
-	"google.golang.org/grpc/peer"
-	"google.golang.org/grpc/stats"
-	"google.golang.org/grpc/status"
-)
-
-type gRPCContextKey struct{}
-
-type gRPCContext struct {
-	messagesReceived int64
-	messagesSent     int64
-}
-
-type Options struct {
-	Tracer tracer.Tracer
-}
-
-// NewServerHandler creates a stats.Handler for gRPC server.
-func NewServerHandler(tr tracer.Tracer) stats.Handler {
-	h := &serverHandler{
-		tr: tr,
-	}
-	return h
-}
-
-type serverHandler struct {
-	tr tracer.Tracer
-}
-
-// TagRPC can attach some information to the given context.
-func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
-	name, attrs := parseFullMethod(info.FullMethodName)
-	attrs = append(attrs, "rpc.system", "grpc")
-	ctx, _ = h.tr.Start(
-		ctx,
-		name,
-		tracer.WithSpanKind(tracer.SpanKindServer),
-		options.Labels(attrs...),
-	)
-
-	gctx := gRPCContext{}
-	return context.WithValue(ctx, gRPCContextKey{}, &gctx)
-}
-
-// HandleRPC processes the RPC stats.
-func (h *serverHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
-	handleRPC(ctx, rs)
-}
-
-// TagConn can attach some information to the given context.
-func (h *serverHandler) TagConn(ctx context.Context, info *stats.ConnTagInfo) context.Context {
-	if span, ok := tracer.SpanFromContext(ctx); ok {
-		attrs := peerAttr(peerFromCtx(ctx))
-		span.AddLabels(attrs...)
-	}
-	return ctx
-}
-
-// HandleConn processes the Conn stats.
-func (h *serverHandler) HandleConn(ctx context.Context, info stats.ConnStats) {
-}
-
-type clientHandler struct {
-	tr tracer.Tracer
-}
-
-// NewClientHandler creates a stats.Handler for gRPC client.
-func NewClientHandler(tr tracer.Tracer) stats.Handler {
-	h := &clientHandler{
-		tr: tr,
-	}
-	return h
-}
-
-// TagRPC can attach some information to the given context.
-func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
-	name, attrs := parseFullMethod(info.FullMethodName)
-	attrs = append(attrs, "rpc.system", "grpc", "rpc.flavor", "grpc", "rpc.call", info.FullMethodName)
-	ctx, _ = h.tr.Start(
-		ctx,
-		name,
-		tracer.WithSpanKind(tracer.SpanKindClient),
-		options.Labels(attrs...),
-	)
-
-	gctx := gRPCContext{}
-
-	return context.WithValue(ctx, gRPCContextKey{}, &gctx)
-}
-
-// HandleRPC processes the RPC stats.
-func (h *clientHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
-	handleRPC(ctx, rs)
-}
-
-// TagConn can attach some information to the given context.
-func (h *clientHandler) TagConn(ctx context.Context, cti *stats.ConnTagInfo) context.Context {
-	// TODO
-	if span, ok := tracer.SpanFromContext(ctx); ok {
-		attrs := peerAttr(cti.RemoteAddr.String())
-		span.AddLabels(attrs...)
-	}
-	return ctx
-}
-
-// HandleConn processes the Conn stats.
-func (h *clientHandler) HandleConn(context.Context, stats.ConnStats) {
-	// no-op
-}
-
-func handleRPC(ctx context.Context, rs stats.RPCStats) {
-	span, ok := tracer.SpanFromContext(ctx)
-	gctx, _ := ctx.Value(gRPCContextKey{}).(*gRPCContext)
-	var messageID int64
-	if rs.IsClient() {
-		span.AddLabels("span.kind", "client")
-	} else {
-		span.AddLabels("span.kind", "server")
-	}
-
-	switch rs := rs.(type) {
-	case *stats.Begin:
-		if rs.IsClientStream || rs.IsServerStream {
-			span.AddLabels("rpc.call_type", "stream")
-		} else {
-			span.AddLabels("rpc.call_type", "unary")
-		}
-		span.AddEvent("message",
-			options.Labels(
-				"message.begin_time", rs.BeginTime.Format(time.RFC3339),
-			),
-		)
-	case *stats.InPayload:
-		if gctx != nil {
-			messageID = atomic.AddInt64(&gctx.messagesReceived, 1)
-		}
-		if ok {
-			span.AddEvent("message",
-				options.Labels(
-					"message.recv_time", rs.RecvTime.Format(time.RFC3339),
-					"message.type", "RECEIVED",
-					"message.id", messageID,
-					"message.compressed_size", rs.CompressedLength,
-					"message.uncompressed_size", rs.Length,
-				),
-			)
-		}
-	case *stats.OutPayload:
-		if gctx != nil {
-			messageID = atomic.AddInt64(&gctx.messagesSent, 1)
-		}
-		if ok {
-			span.AddEvent("message",
-				options.Labels(
-					"message.sent_time", rs.SentTime.Format(time.RFC3339),
-					"message.type", "SENT",
-					"message.id", messageID,
-					"message.compressed_size", rs.CompressedLength,
-					"message.uncompressed_size", rs.Length,
-				),
-			)
-		}
-	case *stats.End:
-		if ok {
-			span.AddEvent("message",
-				options.Labels(
-					"message.begin_time", rs.BeginTime.Format(time.RFC3339),
-					"message.end_time", rs.EndTime.Format(time.RFC3339),
-				),
-			)
-			if rs.Error != nil {
-				s, _ := status.FromError(rs.Error)
-				span.SetStatus(tracer.SpanStatusError, s.Message())
-				span.AddLabels("rpc.grpc.status_code", s.Code())
-			} else {
-				span.AddLabels("rpc.grpc.status_code", grpc_codes.OK)
-			}
-			span.Finish()
-		}
-	default:
-		return
-	}
-}
-
-func parseFullMethod(fullMethod string) (string, []interface{}) {
-	if !strings.HasPrefix(fullMethod, "/") {
-		// Invalid format, does not follow `/package.service/method`.
-		return fullMethod, nil
-	}
-	name := fullMethod[1:]
-	pos := strings.LastIndex(name, "/")
-	if pos < 0 {
-		// Invalid format, does not follow `/package.service/method`.
-		return name, nil
-	}
-	service, method := name[:pos], name[pos+1:]
-
-	var attrs []interface{}
-	if service != "" {
-		attrs = append(attrs, "rpc.service", service)
-	}
-	if method != "" {
-		attrs = append(attrs, "rpc.method", method)
-	}
-	return name, attrs
-}
-
-func peerAttr(addr string) []interface{} {
-	host, p, err := net.SplitHostPort(addr)
-	if err != nil {
-		return nil
-	}
-
-	if host == "" {
-		host = "127.0.0.1"
-	}
-	port, err := strconv.Atoi(p)
-	if err != nil {
-		return nil
-	}
-
-	var attr []interface{}
-	if ip := net.ParseIP(host); ip != nil {
-		attr = []interface{}{
-			"net.sock.peer.addr", host,
-			"net.sock.peer.port", port,
-		}
-	} else {
-		attr = []interface{}{
-			"net.peer.name", host,
-			"net.peer.port", port,
-		}
-	}
-
-	return attr
-}
-
-func peerFromCtx(ctx context.Context) string {
-	p, ok := peer.FromContext(ctx)
-	if !ok {
-		return ""
-	}
-	return p.Addr.String()
-}

util/http/clienttracer.go

@@ -1,254 +0,0 @@
-//
-// Copyright The OpenTelemetry Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package http
-
-import (
-	"context"
-	"crypto/tls"
-	"net/http/httptrace"
-	"net/textproto"
-	"strings"
-	"sync"
-
-	"go.unistack.org/micro/v4/options"
-	"go.unistack.org/micro/v4/tracer"
-)
-
-const (
-	httpStatus     = "http.status"
-	httpHeaderMIME = "http.mime"
-	httpRemoteAddr = "http.remote"
-	httpLocalAddr  = "http.local"
-	httpHost       = "http.host"
-)
-
-var hookMap = map[string]string{
-	"http.dns":     "http.getconn",
-	"http.connect": "http.getconn",
-	"http.tls":     "http.getconn",
-}
-
-func parentHook(hook string) string {
-	if strings.HasPrefix(hook, "http.connect") {
-		return hookMap["http.connect"]
-	}
-	return hookMap[hook]
-}
-
-type clientTracer struct {
-	context.Context
-	tr          tracer.Tracer
-	activeHooks map[string]context.Context
-	root        tracer.Span
-	mtx         sync.Mutex
-}
-
-func NewClientTrace(ctx context.Context, tr tracer.Tracer) *httptrace.ClientTrace {
-	ct := &clientTracer{
-		Context:     ctx,
-		activeHooks: make(map[string]context.Context),
-		tr:          tr,
-	}
-
-	return &httptrace.ClientTrace{
-		GetConn:              ct.getConn,
-		GotConn:              ct.gotConn,
-		PutIdleConn:          ct.putIdleConn,
-		GotFirstResponseByte: ct.gotFirstResponseByte,
-		Got100Continue:       ct.got100Continue,
-		Got1xxResponse:       ct.got1xxResponse,
-		DNSStart:             ct.dnsStart,
-		DNSDone:              ct.dnsDone,
-		ConnectStart:         ct.connectStart,
-		ConnectDone:          ct.connectDone,
-		TLSHandshakeStart:    ct.tlsHandshakeStart,
-		TLSHandshakeDone:     ct.tlsHandshakeDone,
-		WroteHeaderField:     ct.wroteHeaderField,
-		WroteHeaders:         ct.wroteHeaders,
-		Wait100Continue:      ct.wait100Continue,
-		WroteRequest:         ct.wroteRequest,
-	}
-}
-
-func (ct *clientTracer) start(hook, spanName string, attrs ...interface{}) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
-
-	if hookCtx, found := ct.activeHooks[hook]; !found {
-		var sp tracer.Span
-		ct.activeHooks[hook], sp = ct.tr.Start(ct.getParentContext(hook), spanName, options.Labels(attrs...), tracer.WithSpanKind(tracer.SpanKindClient))
-		if ct.root == nil {
-			ct.root = sp
-		}
-	} else {
-		// end was called before start finished, add the start attributes and end the span here
-		if span, ok := tracer.SpanFromContext(hookCtx); ok {
-			span.AddLabels(attrs...)
-			span.Finish()
-		}
-
-		delete(ct.activeHooks, hook)
-	}
-}
-
-func (ct *clientTracer) end(hook string, err error, attrs ...interface{}) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
-	if ctx, ok := ct.activeHooks[hook]; ok { // nolint:nestif
-		if span, ok := tracer.SpanFromContext(ctx); ok {
-			if err != nil {
-				span.SetStatus(tracer.SpanStatusError, err.Error())
-			}
-			span.AddLabels(attrs...)
-			span.Finish()
-		}
-		delete(ct.activeHooks, hook)
-	} else {
-		// start is not finished before end is called.
-		// Start a span here with the ending attributes that will be finished when start finishes.
-		// Yes, it's backwards. v0v
-		ctx, span := ct.tr.Start(ct.getParentContext(hook), hook, options.Labels(attrs...), tracer.WithSpanKind(tracer.SpanKindClient))
-		if err != nil {
-			span.SetStatus(tracer.SpanStatusError, err.Error())
-		}
-		ct.activeHooks[hook] = ctx
-	}
-}
-
-func (ct *clientTracer) getParentContext(hook string) context.Context {
-	ctx, ok := ct.activeHooks[parentHook(hook)]
-	if !ok {
-		return ct.Context
-	}
-	return ctx
-}
-
-func (ct *clientTracer) span(hook string) (tracer.Span, bool) {
-	ct.mtx.Lock()
-	defer ct.mtx.Unlock()
-	if ctx, ok := ct.activeHooks[hook]; ok {
-		return tracer.SpanFromContext(ctx)
-	}
-	return nil, false
-}
-
-func (ct *clientTracer) getConn(host string) {
-	ct.start("http.getconn", "http.getconn", httpHost, host)
-}
-
-func (ct *clientTracer) gotConn(info httptrace.GotConnInfo) {
-	ct.end("http.getconn",
-		nil,
-		httpRemoteAddr, info.Conn.RemoteAddr().String(),
-		httpLocalAddr, info.Conn.LocalAddr().String(),
-	)
-}
-
-func (ct *clientTracer) putIdleConn(err error) {
-	ct.end("http.receive", err)
-}
-
-func (ct *clientTracer) gotFirstResponseByte() {
-	ct.start("http.receive", "http.receive")
-}
-
-func (ct *clientTracer) dnsStart(info httptrace.DNSStartInfo) {
-	ct.start("http.dns", "http.dns", httpHost, info.Host)
-}
-
-func (ct *clientTracer) dnsDone(info httptrace.DNSDoneInfo) {
-	ct.end("http.dns", info.Err)
-}
-
-func (ct *clientTracer) connectStart(network, addr string) {
-	_ = network
-	ct.start("http.connect."+addr, "http.connect", httpRemoteAddr, addr)
-}
-
-func (ct *clientTracer) connectDone(network, addr string, err error) {
-	_ = network
-	ct.end("http.connect."+addr, err)
-}
-
-func (ct *clientTracer) tlsHandshakeStart() {
-	ct.start("http.tls", "http.tls")
-}
-
-func (ct *clientTracer) tlsHandshakeDone(_ tls.ConnectionState, err error) {
-	ct.end("http.tls", err)
-}
-
-func (ct *clientTracer) wroteHeaderField(k string, v []string) {
-	if sp, ok := ct.span("http.headers"); !ok || sp == nil {
-		ct.start("http.headers", "http.headers")
-	}
-	ct.root.AddLabels("http."+strings.ToLower(k), sliceToString(v))
-}
-
-func (ct *clientTracer) wroteHeaders() {
-	ct.start("http.send", "http.send")
-}
-
-func (ct *clientTracer) wroteRequest(info httptrace.WroteRequestInfo) {
-	if info.Err != nil {
-		ct.root.SetStatus(tracer.SpanStatusError, info.Err.Error())
-	}
-	ct.end("http.send", info.Err)
-}
-
-func (ct *clientTracer) got100Continue() {
-	if sp, ok := ct.span("http.receive"); ok && sp != nil {
-		sp.AddEvent("GOT 100 - Continue")
-	}
-}
-
-func (ct *clientTracer) wait100Continue() {
-	if sp, ok := ct.span("http.receive"); ok && sp != nil {
-		sp.AddEvent("GOT 100 - Wait")
-	}
-}
-
-func (ct *clientTracer) got1xxResponse(code int, header textproto.MIMEHeader) error {
-	if sp, ok := ct.span("http.receive"); ok && sp != nil {
-		sp.AddEvent("GOT 1xx",
-			options.Labels(
-				httpStatus, code,
-				httpHeaderMIME, sm2s(header),
-			),
-		)
-	}
-	return nil
-}
-
-func sliceToString(value []string) string {
-	if len(value) == 0 {
-		return "undefined"
-	}
-	return strings.Join(value, ",")
-}
-
-func sm2s(value map[string][]string) string {
-	var buf strings.Builder
-	for k, v := range value {
-		if buf.Len() != 0 {
-			buf.WriteString(",")
-		}
-		buf.WriteString(k)
-		buf.WriteString("=")
-		buf.WriteString(sliceToString(v))
-	}
-	return buf.String()
-}