Revert "ddtrace/tracer: removed dependency between discovery flag and…

… single span sampling"

This reverts commit 7748843.

ddtrace/tracer/rules_sampler.go

@@ -360,7 +360,7 @@ func (rs *singleSpanRulesSampler) apply(span *span) bool {
 			}
 			var sampled bool
 			if rule.limiter != nil {
-				sampled, rate = rule.limiter.allowOne(nowTime())
+				sampled, rate = rule.limiter.allowOne(time.Now())
 				if !sampled {
 					return false
 				}

ddtrace/tracer/sampler_test.go

@@ -355,6 +355,7 @@ func TestRulesSampler(t *testing.T) {
 	makeSpan := func(op string, svc string) *span {
 		return newSpan(op, svc, "", 0, 0, 0)
 	}
+
 	t.Run("no-rules", func(t *testing.T) {
 		assert := assert.New(t)
 		rs := newRulesSampler(nil, nil)
@@ -448,46 +449,6 @@ func TestRulesSampler(t *testing.T) {
 		}
 	})
 
-	t.Run("matching-span-rules", func(t *testing.T) {
-		defer os.Unsetenv("DD_SPAN_SAMPLING_RULES")
-		for _, tt := range []struct {
-			rules    string
-			spanSrv  string
-			spanName string
-		}{
-			{
-				rules:    `[{"name": "abcd?", "sample_rate": 1.0, "max_per_second":100}]`,
-				spanSrv:  "test-service",
-				spanName: "abcde",
-			},
-			{
-				rules:    `[{"service": "*abcd","max_per_second":100, "sample_rate": 1.0}]`,
-				spanSrv:  "xyzabcd",
-				spanName: "abcde",
-			},
-			{
-				rules:    `[{"service": "?*", "sample_rate": 1.0, "max_per_second":100}]`,
-				spanSrv:  "test-service",
-				spanName: "abcde",
-			},
-		} {
-			t.Run("", func(t *testing.T) {
-				os.Setenv("DD_SPAN_SAMPLING_RULES", tt.rules)
-				_, rules, _ := samplingRulesFromEnv()
-
-				assert := assert.New(t)
-				rs := newRulesSampler(nil, rules)
-
-				span := makeFinishedSpan(tt.spanName, tt.spanSrv)
-				result := rs.SampleSpan(span)
-				assert.True(result)
-				assert.Contains(span.Metrics, keySpanSamplingMechanism)
-				assert.Contains(span.Metrics, keySingleSpanSamplingRuleRate)
-				assert.Contains(span.Metrics, keySingleSpanSamplingMPS)
-			})
-		}
-	})
-
 	t.Run("not-matching-span-rules-from-env", func(t *testing.T) {
 		defer os.Unsetenv("DD_SPAN_SAMPLING_RULES")
 		for _, tt := range []struct {

ddtrace/tracer/spancontext.go

@@ -341,6 +341,6 @@ func (t *trace) finishedOne(s *span) {
 	atomic.AddUint32(&tr.spansFinished, uint32(len(t.spans)))
 	tr.pushTrace(&finishedTrace{
 		spans:    t.spans,
-		willSend: decisionKeep == samplingDecision(atomic.LoadUint32((*uint32)(&t.samplingDecision))),
+		decision: samplingDecision(atomic.LoadUint32((*uint32)(&t.samplingDecision))),
 	})
 }

ddtrace/tracer/time.go

@@ -10,8 +10,7 @@ package tracer
 
 import "time"
 
-// nowTime returns the current time, as computed by Time.Now().
-var nowTime func() time.Time = func() time.Time { return time.Now() }
-
 // now returns the current UNIX time in nanoseconds, as computed by Time.UnixNano().
-var now func() int64 = func() int64 { return time.Now().UnixNano() }
+func now() int64 {
+	return time.Now().UnixNano()
+}

ddtrace/tracer/time_windows.go

@@ -26,23 +26,15 @@ func lowPrecisionNow() int64 {
 	return time.Now().UnixNano()
 }
 
-// We use this method of initializing now over an init function due to dependency issues. The init
-// function may run after other declarations, such as that in payload_test:19, which results in a
-// nil dereference panic.
-var now func() int64 = func() func() int64 {
-	if err := windows.LoadGetSystemTimePreciseAsFileTime(); err != nil {
-		log.Warn("Unable to load high precison timer, defaulting to time.Now()")
-		return lowPrecisionNow
-	} else {
-		return highPrecisionNow
-	}
-}()
+var now func() int64
 
-var nowTime func() time.Time = func() func() time.Time {
+// If GetSystemTimePreciseAsFileTime is not available we default to the less
+// precise implementation based on time.Now()
+func init() {
 	if err := windows.LoadGetSystemTimePreciseAsFileTime(); err != nil {
 		log.Warn("Unable to load high precison timer, defaulting to time.Now()")
-		return func() time.Time { return time.Unix(0, lowPrecisionNow()) }
+		now = lowPrecisionNow
 	} else {
-		return func() time.Time { return time.Unix(0, highPrecisionNow()) }
+		now = highPrecisionNow
 	}
-}()
+}

ddtrace/tracer/tracer.go

@@ -323,16 +323,13 @@ func (t *tracer) worker(tick <-chan time.Time) {
 // finishedTrace holds information about a trace that has finished, including its spans.
 type finishedTrace struct {
 	spans    []*span
-	willSend bool // willSend indicates whether the trace will be sent to the agent.
+	decision samplingDecision
 }
 
 // sampleFinishedTrace applies single-span sampling to the provided trace, which is considered to be finished.
 func (t *tracer) sampleFinishedTrace(info *finishedTrace) {
-	if len(info.spans) > 0 {
-		if p, ok := info.spans[0].context.samplingPriority(); ok && p > 0 {
-			// The trace is kept, no need to run single span sampling rules.
-			return
-		}
+	if info.decision == decisionKeep {
+		return
 	}
 	var kept []*span
 	if t.rulesSampling.HasSpanRules() {
@@ -351,9 +348,7 @@ func (t *tracer) sampleFinishedTrace(info *finishedTrace) {
 		atomic.AddUint32(&t.droppedP0Traces, 1)
 	}
 	atomic.AddUint32(&t.droppedP0Spans, uint32(len(info.spans)-len(kept)))
-	if !info.willSend {
-		info.spans = kept
-	}
+	info.spans = kept
 }
 
 func (t *tracer) pushTrace(trace *finishedTrace) {