ddtrace/tracer: add service version to tracer.

contrib/google.golang.org/grpc/stats_client_test.go

@@ -48,15 +48,14 @@ func TestClientStatsHandler(t *testing.T) {
 	assert.NotZero(span.StartTime())
 	assert.True(span.FinishTime().After(span.StartTime()))
 	assert.Equal("grpc.client", span.OperationName())
-	assert.Equal(map[string]interface{}{
-		"span.type":     ext.AppTypeRPC,
-		"grpc.code":     codes.OK.String(),
-		"service.name":  serviceName,
-		"resource.name": "/grpc.Fixture/Ping",
-		tagMethodName:   "/grpc.Fixture/Ping",
-		ext.TargetHost:  "127.0.0.1",
-		ext.TargetPort:  server.port,
-	}, span.Tags())
+	tags := span.Tags()
+	assert.Equal(ext.AppTypeRPC, tags["span.type"])
+	assert.Equal(codes.OK.String(), tags["grpc.code"])
+	assert.Equal(serviceName, tags["service.name"])
+	assert.Equal("/grpc.Fixture/Ping", tags["resource.name"])
+	assert.Equal("/grpc.Fixture/Ping", tags[tagMethodName])
+	assert.Equal("127.0.0.1", tags[ext.TargetHost])
+	assert.Equal(server.port, tags[ext.TargetPort])
 }
 
 func newClientStatsHandlerTestServer(statsHandler stats.Handler) (*rig, error) {

contrib/google.golang.org/grpc/stats_server_test.go

@@ -44,14 +44,13 @@ func TestServerStatsHandler(t *testing.T) {
 	assert.NotZero(span.StartTime())
 	assert.True(span.FinishTime().After(span.StartTime()))
 	assert.Equal("grpc.server", span.OperationName())
-	assert.Equal(map[string]interface{}{
-		"span.type":     ext.AppTypeRPC,
-		"grpc.code":     codes.OK.String(),
-		"service.name":  serviceName,
-		"resource.name": "/grpc.Fixture/Ping",
-		tagMethodName:   "/grpc.Fixture/Ping",
-		"_dd.measured":  1,
-	}, span.Tags())
+	tags := span.Tags()
+	assert.Equal(ext.AppTypeRPC, tags["span.type"])
+	assert.Equal(codes.OK.String(), tags["grpc.code"])
+	assert.Equal(serviceName, tags["service.name"])
+	assert.Equal("/grpc.Fixture/Ping", tags["resource.name"])
+	assert.Equal("/grpc.Fixture/Ping", tags[tagMethodName])
+	assert.Equal(1, tags["_dd.measured"])
 }
 
 func newServerStatsHandlerTestServer(statsHandler stats.Handler) (*rig, error) {

ddtrace/ext/tags.go

@@ -43,6 +43,9 @@ const (
 	// ServiceName defines the Service name for this Span.
 	ServiceName = "service.name"
 
+	// Version is a tag that specifies the current application version.
+	Version = "version"
+
 	// ResourceName defines the Resource name for the Span.
 	ResourceName = "resource.name"
 

ddtrace/tracer/option.go

@@ -30,6 +30,9 @@ type config struct {
 	// serviceName specifies the name of this application.
 	serviceName string
 
+	// version specifies the version of this application
+	version string
+
 	// sampler specifies the sampler that will be used for sampling traces.
 	sampler Sampler
 
@@ -110,6 +113,9 @@ func defaults(c *config) {
 	} else {
 		c.serviceName = filepath.Base(os.Args[0])
 	}
+	if ver := os.Getenv("DD_VERSION"); ver != "" {
+		c.version = ver
+	}
 	if v := os.Getenv("DD_TAGS"); v != "" {
 		for _, tag := range strings.Split(v, ",") {
 			tag = strings.TrimSpace(tag)
@@ -283,6 +289,14 @@ func WithSamplingRules(rules []SamplingRule) StartOption {
 	}
 }
 
+// WithServiceVersion specifies the version of the service that is running. This will
+// be included in spans from this service in the "version" tag.
+func WithServiceVersion(version string) StartOption {
+	return func(cfg *config) {
+		cfg.version = version
+	}
+}
+
 // StartSpanOption is a configuration option for StartSpan. It is aliased in order
 // to help godoc group all the functions returning it together. It is considered
 // more correct to refer to it as the type as the origin, ddtrace.StartSpanOption.

ddtrace/tracer/tracer.go

@@ -321,6 +321,9 @@ func (t *tracer) StartSpan(operationName string, options ...ddtrace.StartSpanOpt
 	for k, v := range t.config.globalTags {
 		span.SetTag(k, v)
 	}
+	if t.config.version != "" && span.Service == t.config.serviceName {
+		span.SetTag(ext.Version, t.config.version)
+	}
 	if context == nil {
 		// this is a brand new trace, sample it
 		t.sample(span)

ddtrace/tracer/tracer_test.go

@@ -1014,6 +1014,93 @@ func TestTracerReportsHostname(t *testing.T) {
 	})
 }
 
+func TestEnvTags(t *testing.T) {
+	t.Run("service", func(t *testing.T) {
+		os.Setenv("DD_SERVICE", "servenv")
+		defer os.Unsetenv("DD_SERVICE")
+
+		tracer, _, _, stop := startTestTracer(t)
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request").(*span)
+		assert.Equal("servenv", sp.Service)
+	})
+
+	t.Run("version", func(t *testing.T) {
+		os.Setenv("DD_VERSION", "1.2.3")
+		defer os.Unsetenv("DD_VERSION")
+
+		tracer, _, _, stop := startTestTracer(t)
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request").(*span)
+		v := sp.Meta[ext.Version]
+		assert.Equal("1.2.3", v)
+	})
+
+	t.Run("noversion", func(t *testing.T) {
+		os.Setenv("DD_VERSION", "1.2.3")
+		defer os.Unsetenv("DD_VERSION")
+
+		tracer, _, _, stop := startTestTracer(t, WithService("servenv"))
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request", ServiceName("otherservenv")).(*span)
+		_, ok := sp.Meta[ext.Version]
+		assert.False(ok)
+	})
+
+	t.Run("noversion2", func(t *testing.T) {
+		os.Setenv("DD_SERVICE", "servenv")
+		os.Setenv("DD_VERSION", "1.2.3")
+		defer os.Unsetenv("DD_VERSION")
+		defer os.Unsetenv("DD_SERVICE")
+
+		tracer, _, _, stop := startTestTracer(t)
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request", ServiceName("otherservenv")).(*span)
+		_, ok := sp.Meta[ext.Version]
+		assert.False(ok)
+	})
+
+	t.Run("noversion3", func(t *testing.T) {
+		os.Setenv("DD_SERVICE", "servenv")
+		os.Setenv("DD_VERSION", "1.2.3")
+		defer os.Unsetenv("DD_VERSION")
+		defer os.Unsetenv("DD_SERVICE")
+
+		// WithGlobalTag sets ext.ServiceName on each individual span, so version will not be set.
+		tracer, _, _, stop := startTestTracer(t, WithGlobalTag(ext.ServiceName, "otherservenv"))
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request").(*span)
+		_, ok := sp.Meta[ext.Version]
+		assert.False(ok)
+	})
+
+	t.Run("serviceOverride", func(t *testing.T) {
+		os.Setenv("DD_SERVICE", "servenv")
+		os.Setenv("DD_VERSION", "1.2.3")
+		defer os.Unsetenv("DD_VERSION")
+		defer os.Unsetenv("DD_SERVICE")
+
+		tracer, _, _, stop := startTestTracer(t, WithService("otherservenv"))
+		defer stop()
+
+		assert := assert.New(t)
+		sp := tracer.StartSpan("http.request").(*span)
+		assert.Equal("otherservenv", sp.Service)
+		v := sp.Meta[ext.Version]
+		assert.Equal("1.2.3", v)
+	})
+}
+
 // BenchmarkConcurrentTracing tests the performance of spawning a lot of
 // goroutines where each one creates a trace with a parent and a child.
 func BenchmarkConcurrentTracing(b *testing.B) {