initial dev of golden data span generator

internal/goldendataset/span_generator.go

@@ -58,6 +58,14 @@ const (
 	SpanAttrInternal          = "Internal"
 )
 
+const (
+	SpanChildCountNil   = "Nil"
+	SpanChildCountEmpty = "Empty"
+	SpanChildCountOne   = "One"
+	SpanChildCountTwo   = "Two"
+	SpanChildCountEight = "Eight"
+)
+
 const (
 	SpanStatusNil                = "Nil"
 	SpanStatusOk                 = "Ok"
@@ -127,7 +135,7 @@ func constructStatusMessageMap() map[string]string {
 }
 
 func GenerateSpan(traceID []byte, tracestate string, parentID []byte, spanName string, kind string, spanTypeID string,
-	statusStr string) *otlptrace.Span {
+	eventCnt string, linkCnt string, statusStr string) *otlptrace.Span {
 	endTime := time.Now().Add(-50 * time.Microsecond)
 	return &otlptrace.Span{
 		TraceId:                traceID,
@@ -140,14 +148,23 @@ func GenerateSpan(traceID []byte, tracestate string, parentID []byte, spanName s
 		EndTimeUnixNano:        uint64(endTime.UnixNano()),
 		Attributes:             generateSpanAttributes(spanTypeID),
 		DroppedAttributesCount: 0,
-		Events:                 nil,
+		Events:                 generateSpanEvents(eventCnt),
 		DroppedEventsCount:     0,
-		Links:                  nil,
+		Links:                  generateSpanLinks(linkCnt),
 		DroppedLinksCount:      0,
 		Status:                 generateStatus(statusStr),
 	}
 }
 
+func generateTraceID() []byte {
+	var r [16]byte
+	_, err := rand.Read(r[:])
+	if err != nil {
+		panic(err)
+	}
+	return r[:]
+}
+
 func generateSpanID() []byte {
 	var r [8]byte
 	_, err := rand.Read(r[:])
@@ -388,3 +405,77 @@ func generateInternalAttributes() map[string]interface{} {
 	attrMap[conventions.AttributeEnduserID] = "unittest"
 	return attrMap
 }
+
+func generateSpanEvents(eventCnt string) []*otlptrace.Span_Event {
+	if SpanChildCountNil == eventCnt {
+		return nil
+	}
+	listSize := calculateListSize(eventCnt)
+	eventList := make([]*otlptrace.Span_Event, listSize)
+	for i := 0; i < listSize; i++ {
+		eventList[i] = generateSpanEvent(i)
+	}
+	return eventList
+}
+
+func generateSpanLinks(linkCnt string) []*otlptrace.Span_Link {
+	if SpanChildCountNil == linkCnt {
+		return nil
+	}
+	listSize := calculateListSize(linkCnt)
+	linkList := make([]*otlptrace.Span_Link, listSize)
+	for i := 0; i < listSize; i++ {
+		linkList[i] = generateSpanLink(i)
+	}
+	return linkList
+}
+
+func calculateListSize(listCnt string) int {
+	if SpanChildCountOne == listCnt {
+		return 1
+	} else if SpanChildCountTwo == listCnt {
+		return 2
+	} else if SpanChildCountEight == listCnt {
+		return 8
+	} else {
+		return 0
+	}
+}
+
+func generateSpanEvent(index int) *otlptrace.Span_Event {
+	t := time.Now().Add(-75 * time.Microsecond)
+	return &otlptrace.Span_Event{
+		TimeUnixNano:           uint64(t.UnixNano()),
+		Name:                   "message",
+		Attributes:             generateEventAttributes(index),
+		DroppedAttributesCount: 0,
+	}
+}
+
+func generateEventAttributes(index int) []*otlpcommon.AttributeKeyValue {
+	attrMap := make(map[string]interface{})
+	if index%2 == 0 {
+		attrMap[conventions.AttributeMessageType] = "SENT"
+	} else {
+		attrMap[conventions.AttributeMessageType] = "RECEIVED"
+	}
+	attrMap[conventions.AttributeMessageID] = int64(index)
+	attrMap[conventions.AttributeMessageCompressedSize] = int64(17 * index)
+	attrMap[conventions.AttributeMessageUncompressedSize] = int64(24 * index)
+	return convertMapToAttributeKeyValues(attrMap)
+}
+
+func generateSpanLink(index int) *otlptrace.Span_Link {
+	return &otlptrace.Span_Link{
+		TraceId:                generateTraceID(),
+		SpanId:                 generateSpanID(),
+		TraceState:             "",
+		Attributes:             generateLinkAttributes(index),
+		DroppedAttributesCount: 0,
+	}
+}
+
+func generateLinkAttributes(index int) []*otlpcommon.AttributeKeyValue {
+	attrMap := generateMessagingConsumerAttributes()
+	return convertMapToAttributeKeyValues(attrMap)
+}

internal/goldendataset/span_generator_test.go

@@ -25,13 +25,24 @@ import (
 func TestGenerateParentSpan(t *testing.T) {
 	traceID := generateTestTraceID()
 	span := GenerateSpan(traceID, "", nil, "/gotest-parent", SpanKindServer,
-		SpanAttrHTTPServer, SpanStatusOk)
+		SpanAttrHTTPServer, SpanChildCountTwo, SpanChildCountOne, SpanStatusOk)
 	assert.Equal(t, traceID, span.TraceId)
 	assert.Nil(t, span.ParentSpanId)
 	assert.Equal(t, 11, len(span.Attributes))
 	assert.Equal(t, otlptrace.Status_Ok, span.Status.Code)
 }
 
+func TestGenerateChildSpan(t *testing.T) {
+	traceID := generateTestTraceID()
+	parentID := generateTestSpanID()
+	span := GenerateSpan(traceID, "", parentID, "get_test_info", SpanKindClient,
+		SpanAttrDatabaseSQL, SpanChildCountEmpty, SpanChildCountNil, SpanStatusOk)
+	assert.Equal(t, traceID, span.TraceId)
+	assert.Equal(t, parentID, span.ParentSpanId)
+	assert.Equal(t, 8, len(span.Attributes))
+	assert.Equal(t, otlptrace.Status_Ok, span.Status.Code)
+}
+
 func generateTestTraceID() []byte {
 	var r [16]byte
 	_, err := rand.Read(r[:])
@@ -40,3 +51,12 @@ func generateTestTraceID() []byte {
 	}
 	return r[:]
 }
+
+func generateTestSpanID() []byte {
+	var r [8]byte
+	_, err := rand.Read(r[:])
+	if err != nil {
+		panic(err)
+	}
+	return r[:]
+}