Add WithClock TracerProviderOption

CHANGELOG.md

@@ -15,6 +15,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 ### Changed
 
 - The `SpanModels` function is now exported from the `go.opentelemetry.io/otel/exporters/zipkin` package to convert OpenTelemetry spans into Zipkin model spans. (#2027)
+- Now `TraceProvider` includes a `Clock` field to provide span startTime/endTime generation. This defaults to use `time` module but users can provide their own implemention by calling `SetClock` to change it. (#2043)
 
 ### Deprecated
 

sdk/internal/internal.go

@@ -18,6 +18,8 @@ import (
 	"fmt"
 	"time"
 
+	tracetime "go.opentelemetry.io/otel/sdk/trace/time"
+
 	"go.opentelemetry.io/otel"
 )
 
@@ -32,6 +34,6 @@ var UserAgent = fmt.Sprintf("opentelemetry-go/%s", otel.Version())
 // the duration since start added back to start gives
 // end as a monotonic time.
 // See https://golang.org/pkg/time/#hdr-Monotonic_Clocks
-func MonotonicEndTime(start time.Time) time.Time {
-	return start.Add(time.Since(start))
+func MonotonicEndTime(start time.Time, clock tracetime.Clock) time.Time {
+	return start.Add(clock.Since(start))
 }

sdk/trace/provider.go

@@ -25,6 +25,7 @@ import (
 
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	"go.opentelemetry.io/otel/sdk/resource"
+	tracetime "go.opentelemetry.io/otel/sdk/trace/time"
 )
 
 const (
@@ -61,6 +62,7 @@ type TracerProvider struct {
 	idGenerator    IDGenerator
 	spanLimits     SpanLimits
 	resource       *resource.Resource
+	clock          tracetime.Clock
 }
 
 var _ trace.TracerProvider = &TracerProvider{}
@@ -90,6 +92,7 @@ func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
 		idGenerator: o.idGenerator,
 		spanLimits:  o.spanLimits,
 		resource:    o.resource,
+		clock:       tracetime.DefaultClock{},
 	}
 
 	for _, sp := range o.processors {
@@ -99,6 +102,14 @@ func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
 	return tp
 }
 
+// SetClock supports setting a mock clock for testing or some clock with custom
+// time correction logic.
+func (p *TracerProvider) SetClock(clock tracetime.Clock) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	p.clock = clock
+}
+
 // Tracer returns a Tracer with the given name and options. If a Tracer for
 // the given name and options does not exist it is created, otherwise the
 // existing Tracer is returned.

sdk/trace/span.go

@@ -227,7 +227,7 @@ func (s *span) End(options ...trace.SpanEndOption) {
 
 	// Store the end time as soon as possible to avoid artificially increasing
 	// the span's duration in case some operation below takes a while.
-	et := internal.MonotonicEndTime(s.startTime)
+	et := internal.MonotonicEndTime(s.startTime, s.tracer.provider.clock)
 
 	// Do relative expensive check now that we have an end time and see if we
 	// need to do any more processing.
@@ -610,7 +610,7 @@ func startSpanInternal(ctx context.Context, tr *tracer, name string, o *trace.Sp
 
 	startTime := o.Timestamp()
 	if startTime.IsZero() {
-		startTime = time.Now()
+		startTime = tr.provider.clock.Now()
 	}
 	span.startTime = startTime
 

sdk/trace/time/time.go

@@ -0,0 +1,36 @@
+// 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 time
+
+import (
+	lib "time"
+)
+
+type Clock interface {
+	Now() lib.Time
+	Since(t lib.Time) lib.Duration
+}
+
+type DefaultClock struct {
+}
+
+func (c DefaultClock) Now() lib.Time {
+	return lib.Now()
+}
+func (c DefaultClock) Since(t lib.Time) lib.Duration {
+	return lib.Since(t)
+}
+
+var _ Clock = DefaultClock{}

sdk/trace/trace_test.go

@@ -1605,6 +1605,50 @@ func TestAddLinksWithMoreAttributesThanLimit(t *testing.T) {
 	}
 }
 
+type FrozenClock struct {
+	now time.Time
+}
+
+// NewFrozenClock returns a clock which stops at time t
+func NewFrozenClock(t time.Time) FrozenClock {
+	return FrozenClock{
+		now: t,
+	}
+}
+
+func (c FrozenClock) Now() time.Time {
+	return c.now
+}
+
+func (c FrozenClock) Since(time.Time) time.Duration {
+	return 0
+}
+
+func TestCustomClock(t *testing.T) {
+	te := NewTestExporter()
+	tp := NewTracerProvider(WithSyncer(te), WithResource(resource.Empty()))
+	tracer := tp.Tracer("custom-clock")
+	now := time.Now()
+	time.Sleep(time.Microsecond * 3)
+	_, span := tracer.Start(context.Background(), "test-original-clock")
+	time.Sleep(time.Microsecond * 3)
+	span.End()
+	got := te.Spans()[0]
+	assert.True(t, now.Before(got.StartTime()))
+	assert.True(t, got.StartTime().Before(got.EndTime()))
+
+	te.Reset()
+
+	tp.SetClock(NewFrozenClock(now))
+	time.Sleep(time.Microsecond * 3)
+	_, span = tracer.Start(context.Background(), "test-frozen-clock")
+	time.Sleep(time.Microsecond * 3)
+	span.End()
+	got = te.Spans()[0]
+	assert.Equal(t, now, got.StartTime())
+	assert.Equal(t, now, got.EndTime())
+}
+
 type stateSampler struct {
 	prefix string
 	f      func(trace.TraceState) trace.TraceState