Upgraded DataDog tracing library to 1.14.0

vendor/gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer/spancontext.go

@@ -25,10 +25,9 @@ type spanContext struct {
 	traceID uint64
 	spanID  uint64
 
-	mu          sync.RWMutex // guards below fields
-	baggage     map[string]string
-	priority    int
-	hasPriority bool
+	mu      sync.RWMutex // guards below fields
+	baggage map[string]string
+	origin  string // e.g. "synthetics"
 }
 
 // newSpanContext creates a new SpanContext to serve as context for the given
@@ -42,15 +41,10 @@ func newSpanContext(span *span, parent *spanContext) *spanContext {
 		spanID:  span.SpanID,
 		span:    span,
 	}
-	if v, ok := span.Metrics[samplingPriorityKey]; ok {
-		context.hasPriority = true
-		context.priority = int(v)
-	}
 	if parent != nil {
 		context.trace = parent.trace
 		context.drop = parent.drop
-		context.hasPriority = parent.hasSamplingPriority()
-		context.priority = parent.samplingPriority()
+		context.origin = parent.origin
 		parent.ForeachBaggageItem(func(k, v string) bool {
 			context.setBaggageItem(k, v)
 			return true
@@ -59,6 +53,10 @@ func newSpanContext(span *span, parent *spanContext) *spanContext {
 	if context.trace == nil {
 		context.trace = newTrace()
 	}
+	if context.trace.root == nil {
+		// first span in the trace can safely be assumed to be the root
+		context.trace.root = span
+	}
 	// put span in context's trace
 	context.trace.push(span)
 	return context
@@ -82,22 +80,21 @@ func (c *spanContext) ForeachBaggageItem(handler func(k, v string) bool) {
 }
 
 func (c *spanContext) setSamplingPriority(p int) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	c.priority = p
-	c.hasPriority = true
+	if c.trace == nil {
+		c.trace = newTrace()
+	}
+	c.trace.setSamplingPriority(float64(p))
 }
 
 func (c *spanContext) samplingPriority() int {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	return c.priority
+	if c.trace == nil {
+		return 0
+	}
+	return c.trace.samplingPriority()
 }
 
 func (c *spanContext) hasSamplingPriority() bool {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	return c.hasPriority
+	return c.trace != nil && c.trace.hasSamplingPriority()
 }
 
 func (c *spanContext) setBaggageItem(key, val string) {
@@ -116,15 +113,23 @@ func (c *spanContext) baggageItem(key string) string {
 }
 
 // finish marks this span as finished in the trace.
-func (c *spanContext) finish() { c.trace.ackFinish() }
+func (c *spanContext) finish() { c.trace.finishedOne(c.span) }
 
-// trace holds information about a specific trace. This structure is shared
-// between all spans in a trace.
+// trace contains shared context information about a trace, such as sampling
+// priority, the root reference and a buffer of the spans which are part of the
+// trace, if these exist.
 type trace struct {
 	mu       sync.RWMutex // guards below fields
 	spans    []*span      // all the spans that are part of this trace
 	finished int          // the number of finished spans
 	full     bool         // signifies that the span buffer is full
+	priority *float64     // sampling priority
+	locked   bool         // specifies if the sampling priority can be altered
+
+	// root specifies the root of the trace, if known; it is nil when a span
+	// context is extracted from a carrier, at which point there are no spans in
+	// the trace yet.
+	root *span
 }
 
 var (
@@ -146,6 +151,42 @@ func newTrace() *trace {
 	return &trace{spans: make([]*span, 0, traceStartSize)}
 }
 
+func (t *trace) hasSamplingPriority() bool {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	return t.priority != nil
+}
+
+func (t *trace) samplingPriority() int {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+	if t.priority == nil {
+		return 0
+	}
+	return int(*t.priority)
+}
+
+func (t *trace) setSamplingPriority(p float64) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+	t.setSamplingPriorityLocked(p)
+}
+
+func (t *trace) setSamplingPriorityLocked(p float64) {
+	if t.locked {
+		return
+	}
+	if t.root == nil {
+		// this trace is distributed (no local root); modifications
+		// to the sampling priority are not allowed.
+		t.locked = true
+	}
+	if t.priority == nil {
+		t.priority = new(float64)
+	}
+	*t.priority = p
+}
+
 // push pushes a new span into the trace. If the buffer is full, it returns
 // a errBufferFull error.
 func (t *trace) push(sp *span) {
@@ -164,12 +205,16 @@ func (t *trace) push(sp *span) {
 		}
 		return
 	}
+	if v, ok := sp.Metrics[keySamplingPriority]; ok {
+		t.setSamplingPriorityLocked(v)
+	}
 	t.spans = append(t.spans, sp)
 }
 
-// ackFinish aknowledges that another span in the trace has finished, and checks
-// if the trace is complete, in which case it calls the onFinish function.
-func (t *trace) ackFinish() {
+// finishedOne aknowledges that another span in the trace has finished, and checks
+// if the trace is complete, in which case it calls the onFinish function. It uses
+// the given priority, if non-nil, to mark the root span.
+func (t *trace) finishedOne(s *span) {
 	t.mu.Lock()
 	defer t.mu.Unlock()
 	if t.full {
@@ -180,6 +225,13 @@ func (t *trace) ackFinish() {
 		return
 	}
 	t.finished++
+	if s == t.root && t.priority != nil {
+		// after the root has finished we lock down the priority;
+		// we won't be able to make changes to a span after finishing
+		// without causing a race condition.
+		t.root.Metrics[keySamplingPriority] = *t.priority
+		t.locked = true
+	}
 	if len(t.spans) != t.finished {
 		return
 	}