[tracer] allowing SetMeta at tracer level

tracer/span.go

@@ -68,6 +68,7 @@ func NewSpan(name, service, resource string, spanID, traceID, parentID uint64, t
 		Name:     name,
 		Service:  service,
 		Resource: resource,
+		Meta:     tracer.getAllMeta(),
 		SpanID:   spanID,
 		TraceID:  traceID,
 		ParentID: parentID,

tracer/tracer.go

@@ -40,6 +40,9 @@ type Tracer struct {
 	enabled             bool // defines if the Tracer is enabled or not
 	enableMu            sync.RWMutex
 
+	meta   map[string]string
+	metaMu sync.RWMutex
+
 	services         map[string]Service // name -> service
 	servicesModified bool
 	serviceChan      chan Service
@@ -133,6 +136,42 @@ func (t *Tracer) SetServiceInfo(name, app, appType string) {
 	}
 }
 
+// SetMeta adds an arbitrary meta field at the tracer level.
+// This will append those tags to each span created by the tracer.
+func (t *Tracer) SetMeta(key, value string) {
+	if t == nil { // Defensive, span could be initialized with nil tracer
+		return
+	}
+
+	t.metaMu.Lock()
+	if t.meta == nil {
+		t.meta = make(map[string]string)
+	}
+	t.meta[key] = value
+	t.metaMu.Unlock()
+}
+
+// getAllMeta returns all the meta set by this tracer.
+// In most cases, it is nil.
+func (t *Tracer) getAllMeta() map[string]string {
+	if t == nil { // Defensive, span could be initialized with nil tracer
+		return nil
+	}
+
+	var meta map[string]string
+
+	t.metaMu.RLock()
+	if t.meta != nil {
+		meta = make(map[string]string, len(t.meta))
+		for key, value := range t.meta {
+			meta[key] = value
+		}
+	}
+	t.metaMu.RUnlock()
+
+	return meta
+}
+
 // NewRootSpan creates a span with no parent. Its ids will be randomly
 // assigned.
 func (t *Tracer) NewRootSpan(name, service, resource string) *Span {

tracer/tracer_test.go

@@ -282,6 +282,42 @@ func TestTracerServicesDisabled(t *testing.T) {
 	assert.Equal(0, len(transport.services))
 }
 
+func TestTracerMeta(t *testing.T) {
+	assert := assert.New(t)
+
+	var nilTracer *Tracer
+	nilTracer.SetMeta("key", "value")
+	assert.Nil(nilTracer.getAllMeta(), "nil tracer should return nil meta")
+
+	tracer, _ := getTestTracer()
+	assert.Nil(tracer.getAllMeta(), "by default, no meta")
+	tracer.SetMeta("env", "staging")
+
+	span := tracer.NewRootSpan("pylons.request", "pylons", "/")
+	assert.Equal("staging", span.GetMeta("env"))
+	assert.Equal("", span.GetMeta("component"))
+	span.Finish()
+	assert.Equal(map[string]string{"env": "staging"}, tracer.getAllMeta(), "there should be one meta")
+
+	tracer.SetMeta("component", "core")
+	span = tracer.NewRootSpan("pylons.request", "pylons", "/")
+	assert.Equal("staging", span.GetMeta("env"))
+	assert.Equal("core", span.GetMeta("component"))
+	span.Finish()
+	assert.Equal(map[string]string{"env": "staging", "component": "core"}, tracer.getAllMeta(), "there should be two entries")
+
+	tracer.SetMeta("env", "prod")
+	span = tracer.NewRootSpan("pylons.request", "pylons", "/")
+	assert.Equal("prod", span.GetMeta("env"))
+	assert.Equal("core", span.GetMeta("component"))
+	span.SetMeta("env", "sandbox")
+	assert.Equal("sandbox", span.GetMeta("env"))
+	assert.Equal("core", span.GetMeta("component"))
+	span.Finish()
+
+	assert.Equal(map[string]string{"env": "prod", "component": "core"}, tracer.getAllMeta(), "key1 should have been updated")
+}
+
 // 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) {