Store span warnings as tags in Cassandra

plugin/storage/cassandra/spanstore/dbmodel/converter.go

@@ -17,10 +17,16 @@ package dbmodel
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/jaegertracing/jaeger/model"
 )
 
+const (
+	// warningStringPrefix is a magic string prefix for tag names to store span warnings.
+	warningStringPrefix = "$$span.warning."
+)
+
 var (
 	dbToDomainRefMap = map[string]model.SpanRefType{
 		childOf:     model.SpanRefType_CHILD_OF,
@@ -57,11 +63,14 @@ type converter struct{}
 
 func (c converter) fromDomain(span *model.Span) *Span {
 	tags := c.toDBTags(span.Tags)
+	warnings := c.toDBWarnings(span.Warnings)
 	logs := c.toDBLogs(span.Logs)
 	refs := c.toDBRefs(span.References)
 	udtProcess := c.toDBProcess(span.Process)
 	spanHash, _ := model.HashCode(span)
 
+	tags = append(tags, warnings...)
+
 	return &Span{
 		TraceID:       TraceIDFromDomain(span.TraceID),
 		SpanID:        int64(span.SpanID),
@@ -83,6 +92,10 @@ func (c converter) toDomain(dbSpan *Span) (*model.Span, error) {
 	if err != nil {
 		return nil, err
 	}
+	warnings, err := c.fromDBWarnings(dbSpan.Tags)
+	if err != nil {
+		return nil, err
+	}
 	logs, err := c.fromDBLogs(dbSpan.Logs)
 	if err != nil {
 		return nil, err
@@ -105,20 +118,38 @@ func (c converter) toDomain(dbSpan *Span) (*model.Span, error) {
 		StartTime:     model.EpochMicrosecondsAsTime(uint64(dbSpan.StartTime)),
 		Duration:      model.MicrosecondsAsDuration(uint64(dbSpan.Duration)),
 		Tags:          tags,
+		Warnings:      warnings,
 		Logs:          logs,
 		Process:       process,
 	}
 	return span, nil
 }
 
 func (c converter) fromDBTags(tags []KeyValue) ([]model.KeyValue, error) {
-	retMe := make([]model.KeyValue, len(tags))
-	for i := range tags {
-		kv, err := c.fromDBTag(&tags[i])
+	var retMe []model.KeyValue
+	for _, tag := range tags {
+		kv, err := c.fromDBTag(&tag)
 		if err != nil {
 			return nil, err
 		}
-		retMe[i] = kv
+		// Ignore the warnings that were saved as tags.
+		if !strings.HasPrefix(kv.Key, warningStringPrefix) {
+			retMe = append(retMe, kv)
+		}
+	}
+	return retMe, nil
+}
+
+func (c converter) fromDBWarnings(tags []KeyValue) ([]string, error) {
+	var retMe []string
+	for _, tag := range tags {
+		kv, err := c.fromDBTag(&tag)
+		if err != nil {
+			return nil, err
+		}
+		if strings.HasPrefix(kv.Key, warningStringPrefix) && kv.VType == model.StringType {
+			retMe = append(retMe, kv.VStr)
+		}
 	}
 	return retMe, nil
 }
@@ -198,6 +229,23 @@ func (c converter) toDBTags(tags []model.KeyValue) []KeyValue {
 	return retMe
 }
 
+func (c converter) toDBWarnings(warnings []string) []KeyValue {
+	retMe := make([]KeyValue, len(warnings))
+	for i, w := range warnings {
+		kv := model.String(fmt.Sprintf("%s%d", warningStringPrefix, i+1), w)
+		retMe[i] = KeyValue{
+			Key:          kv.Key,
+			ValueType:    domainToDBValueTypeMap[kv.VType],
+			ValueString:  kv.VStr,
+			ValueBool:    kv.Bool(),
+			ValueInt64:   kv.Int64(),
+			ValueFloat64: kv.Float64(),
+			ValueBinary:  kv.Binary(),
+		}
+	}
+	return retMe
+}
+
 func (c converter) toDBLogs(logs []model.Log) []Log {
 	retMe := make([]Log, len(logs))
 	for i, l := range logs {

plugin/storage/cassandra/spanstore/dbmodel/converter_test.go

@@ -53,7 +53,8 @@ var (
 		model.Float64(someDoubleTagKey, someDoubleTagValue),
 		model.Binary(someBinaryTagKey, someBinaryTagValue),
 	}
-	someDBTags = []KeyValue{
+	someWarnings = []string{"warning text 1", "warning text 2"}
+	someDBTags   = []KeyValue{
 		{
 			Key:         someStringTagKey,
 			ValueType:   stringType,
@@ -288,3 +289,52 @@ func TestGenerateHashCode(t *testing.T) {
 	assert.NotEqual(t, hc1, hc2)
 	assert.NoError(t, err2)
 }
+
+func TestFromDBTagsWithoutWarnings(t *testing.T) {
+	span := getTestJaegerSpan()
+	dbSpan := FromDomain(span)
+
+	tags, err := converter{}.fromDBTags(dbSpan.Tags)
+	assert.NoError(t, err)
+	assert.Equal(t, tags, span.Tags)
+}
+
+func TestFromDBTagsWithWarnings(t *testing.T) {
+	span := getTestJaegerSpan()
+	span.Warnings = someWarnings
+	dbSpan := FromDomain(span)
+
+	tags, err := converter{}.fromDBTags(dbSpan.Tags)
+	assert.NoError(t, err)
+	assert.Equal(t, tags, span.Tags)
+}
+
+func TestFromDBLogsWithWarnings(t *testing.T) {
+	span := getTestJaegerSpan()
+	span.Warnings = someWarnings
+	dbSpan := FromDomain(span)
+
+	logs, err := converter{}.fromDBLogs(dbSpan.Logs)
+	assert.NoError(t, err)
+	assert.Equal(t, logs, span.Logs)
+}
+
+func TestFromDBProcessWithWarnings(t *testing.T) {
+	span := getTestJaegerSpan()
+	span.Warnings = someWarnings
+	dbSpan := FromDomain(span)
+
+	process, err := converter{}.fromDBProcess(dbSpan.Process)
+	assert.NoError(t, err)
+	assert.Equal(t, process, span.Process)
+}
+
+func TestFromDBWarnings(t *testing.T) {
+	span := getTestJaegerSpan()
+	span.Warnings = someWarnings
+	dbSpan := FromDomain(span)
+
+	warnings, err := converter{}.fromDBWarnings(dbSpan.Tags)
+	assert.NoError(t, err)
+	assert.Equal(t, warnings, span.Warnings)
+}