Support ForeachBaggageItem (#85)

* Support ForeachBaggageItem
* Return bool from handler

Makefile

@@ -6,6 +6,10 @@
 test:
 	go test -v -cover ./...
 
+.PHONY: fmt
+fmt:
+	go fmt ./...
+
 .PHONY: lint
 lint:
 	golint ./...
@@ -16,7 +20,3 @@ lint:
 vet:
 	go vet ./...
 
-.PHONY: example
-example:
-	go build -o build/dapperish-example ./examples/dapperish.go
-	./build/dapperish-example

ext/tags.go

@@ -33,7 +33,7 @@ var (
 	// Component name
 	//////////////////////////////////////////////////////////////////////
 
-	// Component is a low-cardinality identifier of the module, library, 
+	// Component is a low-cardinality identifier of the module, library,
 	// or package that is generating a span.
 	Component = stringTag("component")
 

ext/tags_test.go

@@ -4,8 +4,8 @@ import (
 	"reflect"
 	"testing"
 
-	opentracing "github.com/opentracing/opentracing-go"
 	"github.com/opentracing/opentracing-go/ext"
+	"github.com/opentracing/opentracing-go/mocktracer"
 )
 
 func assertEqual(t *testing.T, expected, actual interface{}) {
@@ -19,7 +19,7 @@ func TestPeerTags(t *testing.T) {
 	if ext.PeerService != "peer.service" {
 		t.Fatalf("Invalid PeerService %v", ext.PeerService)
 	}
-	tracer := noopTracer{}
+	tracer := mocktracer.New()
 	span := tracer.StartSpan("my-trace")
 	ext.PeerService.Set(span, "my-service")
 	ext.PeerHostname.Set(span, "my-hostname")
@@ -31,7 +31,7 @@ func TestPeerTags(t *testing.T) {
 	ext.SpanKind.Set(span, ext.SpanKindRPCClient)
 	span.Finish()
 
-	rawSpan := span.(*noopSpan)
+	rawSpan := span.(*mocktracer.MockSpan)
 	assertEqual(t, "my-service", rawSpan.Tags["peer.service"])
 	assertEqual(t, "my-hostname", rawSpan.Tags["peer.hostname"])
 	assertEqual(t, uint32(127<<24|1), rawSpan.Tags["peer.ipv4"])
@@ -40,68 +40,30 @@ func TestPeerTags(t *testing.T) {
 }
 
 func TestHTTPTags(t *testing.T) {
-	tracer := noopTracer{}
+	tracer := mocktracer.New()
 	span := tracer.StartSpan("my-trace")
 	ext.HTTPUrl.Set(span, "test.biz/uri?protocol=false")
 	ext.HTTPMethod.Set(span, "GET")
 	ext.HTTPStatusCode.Set(span, 301)
 	span.Finish()
 
-	rawSpan := span.(*noopSpan)
+	rawSpan := span.(*mocktracer.MockSpan)
 	assertEqual(t, "test.biz/uri?protocol=false", rawSpan.Tags["http.url"])
 	assertEqual(t, "GET", rawSpan.Tags["http.method"])
 	assertEqual(t, uint16(301), rawSpan.Tags["http.status_code"])
 }
 
 func TestMiscTags(t *testing.T) {
-	tracer := noopTracer{}
+	tracer := mocktracer.New()
 	span := tracer.StartSpan("my-trace")
 	ext.Component.Set(span, "my-awesome-library")
 	ext.SamplingPriority.Set(span, 1)
 	ext.Error.Set(span, true)
 
 	span.Finish()
 
-	rawSpan := span.(*noopSpan)
+	rawSpan := span.(*mocktracer.MockSpan)
 	assertEqual(t, "my-awesome-library", rawSpan.Tags["component"])
 	assertEqual(t, uint16(1), rawSpan.Tags["sampling.priority"])
 	assertEqual(t, true, rawSpan.Tags["error"])
 }
-
-// noopTracer and noopSpan with span tags implemented
-type noopTracer struct{}
-
-type noopSpan struct {
-	Tags opentracing.Tags
-}
-
-func (n noopSpan) SetTag(key string, value interface{}) opentracing.Span {
-	n.Tags[key] = value
-	return n
-}
-
-func (n noopSpan) Finish()                                                {}
-func (n noopSpan) FinishWithOptions(opts opentracing.FinishOptions)       {}
-func (n noopSpan) SetBaggageItem(key, val string) opentracing.Span        { return n }
-func (n noopSpan) BaggageItem(key string) string                          { return "" }
-func (n noopSpan) LogEvent(event string)                                  {}
-func (n noopSpan) LogEventWithPayload(event string, payload interface{})  {}
-func (n noopSpan) Log(data opentracing.LogData)                           {}
-func (n noopSpan) SetOperationName(operationName string) opentracing.Span { return n }
-func (n noopSpan) Tracer() opentracing.Tracer                             { return nil }
-
-func (n noopTracer) StartSpan(operationName string) opentracing.Span {
-	return &noopSpan{Tags: make(opentracing.Tags)}
-}
-
-func (n noopTracer) StartSpanWithOptions(opts opentracing.StartSpanOptions) opentracing.Span {
-	return noopSpan{Tags: make(opentracing.Tags)}
-}
-
-func (n noopTracer) Inject(sp opentracing.Span, format interface{}, carrier interface{}) error {
-	panic("not implemented")
-}
-
-func (n noopTracer) Join(operationName string, format interface{}, carrier interface{}) (opentracing.Span, error) {
-	panic("not implemented")
-}

mocktracer/mocktracer.go

@@ -170,6 +170,15 @@ func (s *MockSpan) BaggageItem(key string) string {
 	return s.Baggage[key]
 }
 
+// ForeachBaggageItem belongs to the Span interface
+func (s *MockSpan) ForeachBaggageItem(handler func(k, v string) bool) {
+	for k, v := range s.Baggage {
+		if !handler(k, v) {
+			break
+		}
+	}
+}
+
 // LogEvent belongs to the Span interface
 func (s *MockSpan) LogEvent(event string) {
 	s.Log(opentracing.LogData{

noop.go

@@ -21,6 +21,7 @@ func (n noopSpan) Finish()                                               {}
 func (n noopSpan) FinishWithOptions(opts FinishOptions)                  {}
 func (n noopSpan) SetBaggageItem(key, val string) Span                   { return n }
 func (n noopSpan) BaggageItem(key string) string                         { return emptyString }
+func (n noopSpan) ForeachBaggageItem(handler func(k, v string) bool)     {}
 func (n noopSpan) LogEvent(event string)                                 {}
 func (n noopSpan) LogEventWithPayload(event string, payload interface{}) {}
 func (n noopSpan) Log(data LogData)                                      {}

propagation.go

@@ -131,7 +131,6 @@ func (c TextMapCarrier) Set(key, val string) {
 	c[key] = val
 }
 
-
 // HTTPHeaderTextMapCarrier satisfies both TextMapWriter and TextMapReader.
 type HTTPHeaderTextMapCarrier http.Header
 

span.go

@@ -87,6 +87,14 @@ type Span interface {
 	// See the `SetBaggageItem` notes about `restrictedKey`.
 	BaggageItem(restrictedKey string) string
 
+	// ForeachBaggageItem allows reading all baggage items stored in the span.
+	// The handler function will be called for each baggage key/value pair.
+	// The bool return value indicates if the handler wants to continue iterating
+	// through the rest of the baggage items; for example if the handler is trying to
+	// find some baggage item by pattern matching the name, it can return false
+	// as soon as the item is found to stop further iterations.
+	ForeachBaggageItem(handler func(k, v string) bool)
+
 	// Provides access to the Tracer that created this Span.
 	Tracer() Tracer
 }

testtracer_test.go

@@ -30,6 +30,7 @@ func (n testSpan) Finish()                                               {}
 func (n testSpan) FinishWithOptions(opts FinishOptions)                  {}
 func (n testSpan) SetBaggageItem(key, val string) Span                   { return n }
 func (n testSpan) BaggageItem(key string) string                         { return "" }
+func (n testSpan) ForeachBaggageItem(handler func(k, v string) bool)     {}
 func (n testSpan) LogEvent(event string)                                 {}
 func (n testSpan) LogEventWithPayload(event string, payload interface{}) {}
 func (n testSpan) Log(data LogData)                                      {}