Instana tracer implementation

vendor/github.com/opentracing/basictracer-go/span.go

@@ -0,0 +1,274 @@
+package basictracer
+
+import (
+	"sync"
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go/ext"
+	"github.com/opentracing/opentracing-go/log"
+)
+
+// Span provides access to the essential details of the span, for use
+// by basictracer consumers.  These methods may only be called prior
+// to (*opentracing.Span).Finish().
+type Span interface {
+	opentracing.Span
+
+	// Operation names the work done by this span instance
+	Operation() string
+
+	// Start indicates when the span began
+	Start() time.Time
+}
+
+// Implements the `Span` interface. Created via tracerImpl (see
+// `basictracer.New()`).
+type spanImpl struct {
+	tracer     *tracerImpl
+	event      func(SpanEvent)
+	sync.Mutex // protects the fields below
+	raw        RawSpan
+	// The number of logs dropped because of MaxLogsPerSpan.
+	numDroppedLogs int
+}
+
+var spanPool = &sync.Pool{New: func() interface{} {
+	return &spanImpl{}
+}}
+
+func (s *spanImpl) reset() {
+	s.tracer, s.event = nil, nil
+	// Note: Would like to do the following, but then the consumer of RawSpan
+	// (the recorder) needs to make sure that they're not holding on to the
+	// baggage or logs when they return (i.e. they need to copy if they care):
+	//
+	//     logs, baggage := s.raw.Logs[:0], s.raw.Baggage
+	//     for k := range baggage {
+	//         delete(baggage, k)
+	//     }
+	//     s.raw.Logs, s.raw.Baggage = logs, baggage
+	//
+	// That's likely too much to ask for. But there is some magic we should
+	// be able to do with `runtime.SetFinalizer` to reclaim that memory into
+	// a buffer pool when GC considers them unreachable, which should ease
+	// some of the load. Hard to say how quickly that would be in practice
+	// though.
+	s.raw = RawSpan{
+		Context: SpanContext{},
+	}
+}
+
+func (s *spanImpl) SetOperationName(operationName string) opentracing.Span {
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Operation = operationName
+	return s
+}
+
+func (s *spanImpl) trim() bool {
+	return !s.raw.Context.Sampled && s.tracer.options.TrimUnsampledSpans
+}
+
+func (s *spanImpl) SetTag(key string, value interface{}) opentracing.Span {
+	defer s.onTag(key, value)
+	s.Lock()
+	defer s.Unlock()
+	if key == string(ext.SamplingPriority) {
+		if v, ok := value.(uint16); ok {
+			s.raw.Context.Sampled = v != 0
+			return s
+		}
+	}
+	if s.trim() {
+		return s
+	}
+
+	if s.raw.Tags == nil {
+		s.raw.Tags = opentracing.Tags{}
+	}
+	s.raw.Tags[key] = value
+	return s
+}
+
+func (s *spanImpl) LogKV(keyValues ...interface{}) {
+	fields, err := log.InterleavedKVToFields(keyValues...)
+	if err != nil {
+		s.LogFields(log.Error(err), log.String("function", "LogKV"))
+		return
+	}
+	s.LogFields(fields...)
+}
+
+func (s *spanImpl) appendLog(lr opentracing.LogRecord) {
+	maxLogs := s.tracer.options.MaxLogsPerSpan
+	if maxLogs == 0 || len(s.raw.Logs) < maxLogs {
+		s.raw.Logs = append(s.raw.Logs, lr)
+		return
+	}
+
+	// We have too many logs. We don't touch the first numOld logs; we treat the
+	// rest as a circular buffer and overwrite the oldest log among those.
+	numOld := (maxLogs - 1) / 2
+	numNew := maxLogs - numOld
+	s.raw.Logs[numOld+s.numDroppedLogs%numNew] = lr
+	s.numDroppedLogs++
+}
+
+func (s *spanImpl) LogFields(fields ...log.Field) {
+	lr := opentracing.LogRecord{
+		Fields: fields,
+	}
+	defer s.onLogFields(lr)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+	if lr.Timestamp.IsZero() {
+		lr.Timestamp = time.Now()
+	}
+	s.appendLog(lr)
+}
+
+func (s *spanImpl) LogEvent(event string) {
+	s.Log(opentracing.LogData{
+		Event: event,
+	})
+}
+
+func (s *spanImpl) LogEventWithPayload(event string, payload interface{}) {
+	s.Log(opentracing.LogData{
+		Event:   event,
+		Payload: payload,
+	})
+}
+
+func (s *spanImpl) Log(ld opentracing.LogData) {
+	defer s.onLog(ld)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+
+	if ld.Timestamp.IsZero() {
+		ld.Timestamp = time.Now()
+	}
+
+	s.appendLog(ld.ToLogRecord())
+}
+
+func (s *spanImpl) Finish() {
+	s.FinishWithOptions(opentracing.FinishOptions{})
+}
+
+// rotateLogBuffer rotates the records in the buffer: records 0 to pos-1 move at
+// the end (i.e. pos circular left shifts).
+func rotateLogBuffer(buf []opentracing.LogRecord, pos int) {
+	// This algorithm is described in:
+	//    http://www.cplusplus.com/reference/algorithm/rotate
+	for first, middle, next := 0, pos, pos; first != middle; {
+		buf[first], buf[next] = buf[next], buf[first]
+		first++
+		next++
+		if next == len(buf) {
+			next = middle
+		} else if first == middle {
+			middle = next
+		}
+	}
+}
+
+func (s *spanImpl) FinishWithOptions(opts opentracing.FinishOptions) {
+	finishTime := opts.FinishTime
+	if finishTime.IsZero() {
+		finishTime = time.Now()
+	}
+	duration := finishTime.Sub(s.raw.Start)
+
+	s.Lock()
+	defer s.Unlock()
+
+	for _, lr := range opts.LogRecords {
+		s.appendLog(lr)
+	}
+	for _, ld := range opts.BulkLogData {
+		s.appendLog(ld.ToLogRecord())
+	}
+
+	if s.numDroppedLogs > 0 {
+		// We dropped some log events, which means that we used part of Logs as a
+		// circular buffer (see appendLog). De-circularize it.
+		numOld := (len(s.raw.Logs) - 1) / 2
+		numNew := len(s.raw.Logs) - numOld
+		rotateLogBuffer(s.raw.Logs[numOld:], s.numDroppedLogs%numNew)
+
+		// Replace the log in the middle (the oldest "new" log) with information
+		// about the dropped logs. This means that we are effectively dropping one
+		// more "new" log.
+		numDropped := s.numDroppedLogs + 1
+		s.raw.Logs[numOld] = opentracing.LogRecord{
+			// Keep the timestamp of the last dropped event.
+			Timestamp: s.raw.Logs[numOld].Timestamp,
+			Fields: []log.Field{
+				log.String("event", "dropped Span logs"),
+				log.Int("dropped_log_count", numDropped),
+				log.String("component", "basictracer"),
+			},
+		}
+	}
+
+	s.raw.Duration = duration
+
+	s.onFinish(s.raw)
+	s.tracer.options.Recorder.RecordSpan(s.raw)
+
+	// Last chance to get options before the span is possibly reset.
+	poolEnabled := s.tracer.options.EnableSpanPool
+	if s.tracer.options.DebugAssertUseAfterFinish {
+		// This makes it much more likely to catch a panic on any subsequent
+		// operation since s.tracer is accessed on every call to `Lock`.
+		// We don't call `reset()` here to preserve the logs in the Span
+		// which are printed when the assertion triggers.
+		s.tracer = nil
+	}
+
+	if poolEnabled {
+		spanPool.Put(s)
+	}
+}
+
+func (s *spanImpl) Tracer() opentracing.Tracer {
+	return s.tracer
+}
+
+func (s *spanImpl) Context() opentracing.SpanContext {
+	return s.raw.Context
+}
+
+func (s *spanImpl) SetBaggageItem(key, val string) opentracing.Span {
+	s.onBaggage(key, val)
+	if s.trim() {
+		return s
+	}
+
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Context = s.raw.Context.WithBaggageItem(key, val)
+	return s
+}
+
+func (s *spanImpl) BaggageItem(key string) string {
+	s.Lock()
+	defer s.Unlock()
+	return s.raw.Context.Baggage[key]
+}
+
+func (s *spanImpl) Operation() string {
+	return s.raw.Operation
+}
+
+func (s *spanImpl) Start() time.Time {
+	return s.raw.Start
+}