Allow custom display name format for spans (#45)

exporter/trace/cloudtrace.go

@@ -32,6 +32,10 @@ import (
 // Option is function type that is passed to the exporter initialization function.
 type Option func(*options)
 
+// DisplayNameFormatter is is a function that produces the display name of a span
+// given its SpanData
+type DisplayNameFormatter func(*export.SpanData) string
+
 // options contains options for configuring the exporter.
 type options struct {
 	// ProjectID is the identifier of the Stackdriver
@@ -107,6 +111,11 @@ type options struct {
 	// to Stackdriver Monitoring. This is only used for Proto metrics export
 	// for now. The minimum number of workers is 1.
 	NumberOfWorkers int
+
+	// DisplayNameFormatter is a function that produces the display name of a span
+	// given its SpanData.
+	// Optional. Default format for SpanData s is "Span.{s.SpanKind}-{s.Name}"
+	DisplayNameFormatter
 }
 
 // WithProjectID sets Google Cloud Platform project as projectID.
@@ -151,6 +160,14 @@ func WithTimeout(t time.Duration) func(o *options) {
 	}
 }
 
+// WithDisplayNameFormatter sets the way span's display names will be 
+// generated from SpanData
+func WithDisplayNameFormatter(f DisplayNameFormatter) func(o *options) {
+	return func(o *options) {
+		o.DisplayNameFormatter = f
+	}
+}
+
 func (o *options) handleError(err error) {
 	if o.OnError != nil {
 		o.OnError(err)

exporter/trace/cloudtrace_test.go

@@ -33,6 +33,7 @@ import (
 
 	"go.opentelemetry.io/otel/api/global"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	export "go.opentelemetry.io/otel/sdk/export/trace"
 )
 
 type mockTraceServer struct {
@@ -122,6 +123,45 @@ func TestExporter_ExportSpans(t *testing.T) {
 	assert.EqualValues(t, 1, mockTrace.len())
 }
 
+func TestExporter_DisplayNameFormatter(t *testing.T) {
+	// Initial test precondition
+	mockTrace.spansUploaded = nil
+	mockTrace.delay = 0
+
+	spanName := "span1234"
+	format := func(s *export.SpanData) string {
+		return "TEST_FORMAT" + s.Name
+	}
+
+	// Create Google Cloud Trace Exporter
+	exp, err := texporter.NewExporter(
+		texporter.WithProjectID("PROJECT_ID_NOT_REAL"),
+		texporter.WithTraceClientOptions(clientOpt),
+		// uncomment when exporter is using bundler
+		// texporter.WithBundleCountThreshold(1),
+		texporter.WithDisplayNameFormatter(format),
+	)
+	assert.NoError(t, err)
+
+	tp, err := sdktrace.NewProvider(
+		sdktrace.WithConfig(sdktrace.Config{DefaultSampler: sdktrace.AlwaysSample()}),
+		sdktrace.WithBatcher(exp, // add following two options to ensure flush
+			sdktrace.WithScheduleDelayMillis(1),
+			sdktrace.WithMaxExportBatchSize(1),
+		))
+	assert.NoError(t, err)
+
+	global.SetTraceProvider(tp)
+	_, span := global.TraceProvider().Tracer("test-tracer").Start(context.Background(), spanName)
+	span.End()
+	assert.True(t, span.SpanContext().IsValid())
+
+	// wait exporter to flush
+	time.Sleep(20 * time.Millisecond)
+	assert.EqualValues(t, 1, mockTrace.len())
+	assert.EqualValues(t, "TEST_FORMAT" + spanName, mockTrace.spansUploaded[0].DisplayName.Value)
+}
+
 func TestExporter_Timeout(t *testing.T) {
 	// Initial test precondition
 	mockTrace.spansUploaded = nil

exporter/trace/trace.go

@@ -50,15 +50,15 @@ func newTraceExporter(o *options) (*traceExporter, error) {
 
 // ExportSpan exports a SpanData to Stackdriver Trace.
 func (e *traceExporter) ExportSpan(ctx context.Context, sd *export.SpanData) {
-	protoSpan := protoFromSpanData(sd, e.projectID)
+	protoSpan := protoFromSpanData(sd, e.projectID, e.o.DisplayNameFormatter)
 	e.uploadFn(ctx, []*tracepb.Span{protoSpan})
 }
 
 // ExportSpans exports a slice of SpanData to Stackdriver Trace in batch
 func (e *traceExporter) ExportSpans(ctx context.Context, sds []*export.SpanData) {
 	pbSpans := make([]*tracepb.Span, len(sds))
 	for i, sd := range sds {
-		pbSpans[i] = protoFromSpanData(sd, e.projectID)
+		pbSpans[i] = protoFromSpanData(sd, e.projectID, e.o.DisplayNameFormatter)
 	}
 	e.uploadFn(ctx, pbSpans)
 }

exporter/trace/trace_proto.go

@@ -60,25 +60,33 @@ const (
 
 var userAgent = fmt.Sprintf("opentelemetry-go %s; cloudtrace-exporter %s", opentelemetry.Version(), version)
 
-func protoFromSpanData(s *export.SpanData, projectID string) *tracepb.Span {
+func generateDisplayName(s *export.SpanData, format DisplayNameFormatter) (displayName string) {
+	if format == nil {
+		switch s.SpanKind {
+		// TODO(ymotongpoo): add cases for "Send" and "Recv".
+		default:
+			displayName = fmt.Sprintf("Span.%s-%s", s.SpanKind, s.Name)
+		}
+	} else {
+		displayName = format(s)
+	}
+	return
+}
+
+func protoFromSpanData(s *export.SpanData, projectID string, format DisplayNameFormatter) *tracepb.Span {
 	if s == nil {
 		return nil
 	}
 
 	traceIDString := s.SpanContext.TraceID.String()
 	spanIDString := s.SpanContext.SpanID.String()
 
-	name := s.Name
-	switch s.SpanKind {
-	// TODO(ymotongpoo): add cases for "Send" and "Recv".
-	default:
-		name = fmt.Sprintf("Span.%s-%s", s.SpanKind, name)
-	}
+	displayName := generateDisplayName(s, format)
 
 	sp := &tracepb.Span{
 		Name:                    "projects/" + projectID + "/traces/" + traceIDString + "/spans/" + spanIDString,
 		SpanId:                  spanIDString,
-		DisplayName:             trunc(name, 128),
+		DisplayName:             trunc(displayName, 128),
 		StartTime:               timestampProto(s.StartTime),
 		EndTime:                 timestampProto(s.EndTime),
 		SameProcessAsParentSpan: &wrapperspb.BoolValue{Value: !s.HasRemoteParent},