tracer and logger improvements

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

tracer/memory/memory.go

@@ -0,0 +1,139 @@
+package memory
+
+import (
+	"context"
+	"time"
+
+	"go.unistack.org/micro/v3/tracer"
+	"go.unistack.org/micro/v3/util/id"
+)
+
+var _ tracer.Tracer = (*Tracer)(nil)
+
+type Tracer struct {
+	opts  tracer.Options
+	spans []tracer.Span
+}
+
+func (t *Tracer) Spans() []tracer.Span {
+	return t.spans
+}
+
+func (t *Tracer) Start(ctx context.Context, name string, opts ...tracer.SpanOption) (context.Context, tracer.Span) {
+	options := tracer.NewSpanOptions(opts...)
+	span := &Span{
+		name:      name,
+		ctx:       ctx,
+		tracer:    t,
+		kind:      options.Kind,
+		startTime: time.Now(),
+	}
+	span.spanID.s, _ = id.New()
+	span.traceID.s, _ = id.New()
+	if span.ctx == nil {
+		span.ctx = context.Background()
+	}
+	t.spans = append(t.spans, span)
+	return tracer.NewSpanContext(ctx, span), span
+}
+
+func (t *Tracer) Flush(_ context.Context) error {
+	return nil
+}
+
+func (t *Tracer) Init(opts ...tracer.Option) error {
+	for _, o := range opts {
+		o(&t.opts)
+	}
+	return nil
+}
+
+func (t *Tracer) Name() string {
+	return t.opts.Name
+}
+
+type noopStringer struct {
+	s string
+}
+
+func (s noopStringer) String() string {
+	return s.s
+}
+
+type Span struct {
+	ctx        context.Context
+	tracer     tracer.Tracer
+	name       string
+	statusMsg  string
+	startTime  time.Time
+	finishTime time.Time
+	traceID    noopStringer
+	spanID     noopStringer
+	events     []*Event
+	labels     []interface{}
+	logs       []interface{}
+	kind       tracer.SpanKind
+	status     tracer.SpanStatus
+}
+
+func (s *Span) Finish(_ ...tracer.SpanOption) {
+	s.finishTime = time.Now()
+}
+
+func (s *Span) Context() context.Context {
+	return s.ctx
+}
+
+func (s *Span) Tracer() tracer.Tracer {
+	return s.tracer
+}
+
+type Event struct {
+	name   string
+	labels []interface{}
+}
+
+func (s *Span) AddEvent(name string, opts ...tracer.EventOption) {
+	options := tracer.NewEventOptions(opts...)
+	s.events = append(s.events, &Event{name: name, labels: options.Labels})
+}
+
+func (s *Span) SetName(name string) {
+	s.name = name
+}
+
+func (s *Span) AddLogs(kv ...interface{}) {
+	s.logs = append(s.logs, kv...)
+}
+
+func (s *Span) AddLabels(kv ...interface{}) {
+	s.labels = append(s.labels, kv...)
+}
+
+func (s *Span) Kind() tracer.SpanKind {
+	return s.kind
+}
+
+func (s *Span) TraceID() string {
+	return s.traceID.String()
+}
+
+func (s *Span) SpanID() string {
+	return s.spanID.String()
+}
+
+func (s *Span) Status() (tracer.SpanStatus, string) {
+	return s.status, s.statusMsg
+}
+
+func (s *Span) SetStatus(st tracer.SpanStatus, msg string) {
+	s.status = st
+	s.statusMsg = msg
+}
+
+// NewTracer returns new memory tracer
+func NewTracer(opts ...tracer.Option) *Tracer {
+	return &Tracer{
+		opts: tracer.NewOptions(opts...),
+	}
+}

tracer/memory/memory_test.go

@@ -0,0 +1,38 @@
+package memory
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/logger/slog"
+	"go.unistack.org/micro/v3/tracer"
+)
+
+func TestLoggerWithTracer(t *testing.T) {
+	ctx := context.TODO()
+	buf := bytes.NewBuffer(nil)
+	logger.DefaultLogger = slog.NewLogger(logger.WithOutput(buf))
+
+	if err := logger.Init(); err != nil {
+		t.Fatal(err)
+	}
+	var span tracer.Span
+	tr := NewTracer()
+	ctx, span = tr.Start(ctx, "test1")
+
+	logger.Error(ctx, "my test error", fmt.Errorf("error"))
+
+	if !strings.Contains(buf.String(), span.TraceID()) {
+		t.Fatalf("log does not contains trace id: %s", buf.Bytes())
+	}
+
+	_, _ = tr.Start(ctx, "test2")
+
+	for _, s := range tr.Spans() {
+		_ = s
+	}
+}

tracer/noop.go

@@ -2,6 +2,8 @@ package tracer
 
 import (
 	"context"
+
+	"go.unistack.org/micro/v3/util/id"
 )
 
 var _ Tracer = (*noopTracer)(nil)
@@ -24,6 +26,8 @@ func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption)
 		labels: options.Labels,
 		kind:   options.Kind,
 	}
+	span.spanID.s, _ = id.New()
+	span.traceID.s, _ = id.New()
 	if span.ctx == nil {
 		span.ctx = context.Background()
 	}
@@ -31,6 +35,14 @@ func (t *noopTracer) Start(ctx context.Context, name string, opts ...SpanOption)
 	return NewSpanContext(ctx, span), span
 }
 
+type noopStringer struct {
+	s string
+}
+
+func (s noopStringer) String() string {
+	return s.s
+}
+
 func (t *noopTracer) Flush(ctx context.Context) error {
 	return nil
 }
@@ -56,6 +68,8 @@ type noopSpan struct {
 	tracer    Tracer
 	name      string
 	statusMsg string
+	traceID   noopStringer
+	spanID    noopStringer
 	events    []*noopEvent
 	labels    []interface{}
 	logs      []interface{}
@@ -63,7 +77,15 @@ type noopSpan struct {
 	status    SpanStatus
 }
 
-func (s *noopSpan) Finish(opts ...SpanOption) {
+func (s *noopSpan) TraceID() string {
+	return s.traceID.String()
+}
+
+func (s *noopSpan) SpanID() string {
+	return s.spanID.String()
+}
+
+func (s *noopSpan) Finish(_ ...SpanOption) {
 }
 
 func (s *noopSpan) Context() context.Context {

tracer/tracer.go

@@ -5,11 +5,33 @@ import (
 	"context"
 	"fmt"
 	"sort"
+
+	"go.unistack.org/micro/v3/logger"
 )
 
 // DefaultTracer is the global default tracer
 var DefaultTracer = NewTracer()
 
+var (
+	// TraceIDKey is the key used for the trace id in the log call
+	TraceIDKey = "trace-id"
+	// SpanIDKey is the key used for the span id in the log call
+	SpanIDKey = "span-id"
+)
+
+func init() {
+	logger.DefaultContextAttrFuncs = append(logger.DefaultContextAttrFuncs,
+		func(ctx context.Context) []interface{} {
+			if span, ok := SpanFromContext(ctx); ok {
+				return []interface{}{
+					TraceIDKey, span.TraceID(),
+					SpanIDKey, span.SpanID(),
+				}
+			}
+			return nil
+		})
+}
+
 // Tracer is an interface for distributed tracing
 type Tracer interface {
 	// Name return tracer name
@@ -43,6 +65,10 @@ type Span interface {
 	AddLogs(kv ...interface{})
 	// Kind returns span kind
 	Kind() SpanKind
+	// TraceID returns trace id
+	TraceID() string
+	// SpanID returns span id
+	SpanID() string
 }
 
 // sort labels alphabeticaly by label name