Encapsulate the internal representation of the ids. Ensure we don't leak it by mistake (#2946)

Signed-off-by: Bogdan Drutu <[email protected]>

Author: bogdandrutu

cmd/pdatagen/internal/base_fields.go

@@ -76,6 +76,16 @@ func (ms ${structName}) ${fieldName}() ${returnType} {
 	return ${returnType}((*ms.orig).${originFieldName})
 }`
 
+const accessorsPrimitiveStructTemplate = `// ${fieldName} returns the ${lowerFieldName} associated with this ${structName}.
+func (ms ${structName}) ${fieldName}() ${returnType} {
+	return ${returnType}{orig: ((*ms.orig).${originFieldName})}
+}
+
+// Set${fieldName} replaces the ${lowerFieldName} associated with this ${structName}.
+func (ms ${structName}) Set${fieldName}(v ${returnType}) {
+	(*ms.orig).${originFieldName} = v.orig
+}`
+
 type baseField interface {
 	generateAccessors(ms baseStruct, sb *strings.Builder)
 
@@ -305,6 +315,62 @@ func (ptf *primitiveTypedField) generateCopyToValue(sb *strings.Builder) {
 
 var _ baseField = (*primitiveTypedField)(nil)
 
+// Types that has defined a custom type (e.g. "type TraceID struct {}")
+type primitiveStructField struct {
+	fieldName       string
+	originFieldName string
+	returnType      string
+	defaultVal      string
+	testVal         string
+}
+
+func (ptf *primitiveStructField) generateAccessors(ms baseStruct, sb *strings.Builder) {
+	template := accessorsPrimitiveStructTemplate
+	sb.WriteString(os.Expand(template, func(name string) string {
+		switch name {
+		case "structName":
+			return ms.getName()
+		case "fieldName":
+			return ptf.fieldName
+		case "lowerFieldName":
+			return strings.ToLower(ptf.fieldName)
+		case "returnType":
+			return ptf.returnType
+		case "originFieldName":
+			return ptf.originFieldName
+		default:
+			panic(name)
+		}
+	}))
+}
+
+func (ptf *primitiveStructField) generateAccessorsTest(ms baseStruct, sb *strings.Builder) {
+	sb.WriteString(os.Expand(accessorsPrimitiveTestTemplate, func(name string) string {
+		switch name {
+		case "structName":
+			return ms.getName()
+		case "defaultVal":
+			return ptf.defaultVal
+		case "fieldName":
+			return ptf.fieldName
+		case "testValue":
+			return ptf.testVal
+		default:
+			panic(name)
+		}
+	}))
+}
+
+func (ptf *primitiveStructField) generateSetWithTestValue(sb *strings.Builder) {
+	sb.WriteString("\ttv.Set" + ptf.fieldName + "(" + ptf.testVal + ")")
+}
+
+func (ptf *primitiveStructField) generateCopyToValue(sb *strings.Builder) {
+	sb.WriteString("\tdest.Set" + ptf.fieldName + "(ms." + ptf.fieldName + "())")
+}
+
+var _ baseField = (*primitiveStructField)(nil)
+
 // oneofField is used in case where the proto defines an "oneof".
 type oneofField struct {
 	copyFuncName    string

cmd/pdatagen/internal/trace_structs.go

@@ -206,29 +206,26 @@ var spanStatus = &messageValueStruct{
 	},
 }
 
-var traceIDField = &primitiveTypedField{
+var traceIDField = &primitiveStructField{
 	fieldName:       "TraceID",
 	originFieldName: "TraceId",
 	returnType:      "TraceID",
-	rawType:         "data.TraceID",
 	defaultVal:      "NewTraceID([16]byte{})",
 	testVal:         "NewTraceID([16]byte{1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1})",
 }
 
-var spanIDField = &primitiveTypedField{
+var spanIDField = &primitiveStructField{
 	fieldName:       "SpanID",
 	originFieldName: "SpanId",
 	returnType:      "SpanID",
-	rawType:         "data.SpanID",
 	defaultVal:      "NewSpanID([8]byte{})",
 	testVal:         "NewSpanID([8]byte{1, 2, 3, 4, 5, 6, 7, 8})",
 }
 
-var parentSpanIDField = &primitiveTypedField{
+var parentSpanIDField = &primitiveStructField{
 	fieldName:       "ParentSpanID",
 	originFieldName: "ParentSpanId",
 	returnType:      "SpanID",
-	rawType:         "data.SpanID",
 	defaultVal:      "NewSpanID([8]byte{})",
 	testVal:         "NewSpanID([8]byte{8, 7, 6, 5, 4, 3, 2, 1})",
 }

consumer/pdata/generated_log.go

@@ -19,29 +19,31 @@ import (
 )
 
 // SpanID is an alias of OTLP SpanID data type.
-type SpanID data.SpanID
+type SpanID struct {
+	orig data.SpanID
+}
 
 // InvalidSpanID returns an empty (all zero bytes) SpanID.
 func InvalidSpanID() SpanID {
-	return SpanID(data.NewSpanID([8]byte{}))
+	return SpanID{orig: data.NewSpanID([8]byte{})}
 }
 
 // NewSpanID returns a new SpanID from the given byte array.
 func NewSpanID(bytes [8]byte) SpanID {
-	return SpanID(data.NewSpanID(bytes))
+	return SpanID{orig: data.NewSpanID(bytes)}
 }
 
 // Bytes returns the byte array representation of the SpanID.
 func (t SpanID) Bytes() [8]byte {
-	return data.SpanID(t).Bytes()
+	return t.orig.Bytes()
 }
 
 // HexString returns hex representation of the SpanID.
 func (t SpanID) HexString() string {
-	return data.SpanID(t).HexString()
+	return t.orig.HexString()
 }
 
 // IsEmpty returns true if id doesn't contain at least one non-zero byte.
 func (t SpanID) IsEmpty() bool {
-	return data.SpanID(t).IsEmpty()
+	return t.orig.IsEmpty()
 }

consumer/pdata/generated_trace.go

@@ -19,29 +19,31 @@ import (
 )
 
 // TraceID is an alias of OTLP TraceID data type.
-type TraceID data.TraceID
+type TraceID struct {
+	orig data.TraceID
+}
 
 // InvalidTraceID returns an empty (all zero bytes) TraceID.
 func InvalidTraceID() TraceID {
-	return TraceID(data.NewTraceID([16]byte{}))
+	return TraceID{orig: data.NewTraceID([16]byte{})}
 }
 
 // NewTraceID returns a new TraceID from the given byte array.
 func NewTraceID(bytes [16]byte) TraceID {
-	return TraceID(data.NewTraceID(bytes))
+	return TraceID{orig: data.NewTraceID(bytes)}
 }
 
 // Bytes returns the byte array representation of the TraceID.
 func (t TraceID) Bytes() [16]byte {
-	return data.TraceID(t).Bytes()
+	return t.orig.Bytes()
 }
 
 // HexString returns hex representation of the TraceID.
 func (t TraceID) HexString() string {
-	return data.TraceID(t).HexString()
+	return t.orig.HexString()
 }
 
 // IsEmpty returns true if id doesn't contain at least one non-zero byte.
 func (t TraceID) IsEmpty() bool {
-	return data.TraceID(t).IsEmpty()
+	return t.orig.IsEmpty()
 }

consumer/pdata/spanid.go

@@ -217,15 +217,15 @@ func zTagsToSpanLinks(tags map[string]string, dest pdata.SpanLinkSlice) error {
 		if errTrace != nil {
 			return errTrace
 		}
-		link.SetTraceID(pdata.TraceID(rawTrace))
+		link.SetTraceID(pdata.NewTraceID(rawTrace.Bytes()))
 
 		// Convert span id.
 		rawSpan := data.SpanID{}
 		errSpan := rawSpan.UnmarshalJSON([]byte(parts[1]))
 		if errSpan != nil {
 			return errSpan
 		}
-		link.SetSpanID(pdata.SpanID(rawSpan))
+		link.SetSpanID(pdata.NewSpanID(rawSpan.Bytes()))
 
 		link.SetTraceState(pdata.TraceState(parts[2]))