Generate marshal JSON without gogo proto jsonpb

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

Author: bogdandrutu

internal/cmd/pdatagen/internal/base_fields.go

@@ -0,0 +1,119 @@
+package internal
+
+import (
+	"strings"
+	"text/template"
+)
+
+const optionalPrimitiveAccessorsTemplate = `// {{ .fieldName }} returns the {{ .lowerFieldName }} associated with this {{ .structName }}.
+func (ms {{ .structName }}) {{ .fieldName }}() {{ .returnType }} {
+	return ms.orig.Get{{ .fieldName }}()
+}
+
+// Has{{ .fieldName }} returns true if the {{ .structName }} contains a
+// {{ .fieldName }} value, false otherwise.
+func (ms {{ .structName }}) Has{{ .fieldName }}() bool {
+	return ms.orig.{{ .fieldName }}_ != nil
+}
+
+// Set{{ .fieldName }} replaces the {{ .lowerFieldName }} associated with this {{ .structName }}.
+func (ms {{ .structName }}) Set{{ .fieldName }}(v {{ .returnType }}) {
+	ms.state.AssertMutable()
+	ms.orig.{{ .fieldName }}_ = &{{ .originStructType }}{{ "{" }}{{ .fieldName }}: v}
+}
+
+// Remove{{ .fieldName }} removes the {{ .lowerFieldName }} associated with this {{ .structName }}.
+func (ms {{ .structName }}) Remove{{ .fieldName }}() {
+	ms.state.AssertMutable()
+	ms.orig.{{ .fieldName }}_ = nil
+}`
+
+const optionalPrimitiveAccessorsTestTemplate = `func Test{{ .structName }}_{{ .fieldName }}(t *testing.T) {
+	ms := New{{ .structName }}()
+	{{- if eq .returnType "float64" }}
+	assert.InDelta(t, {{ .defaultVal }}, ms.{{ .fieldName }}() , 0.01)
+	{{- else }}
+	assert.Equal(t, {{ .defaultVal }}, ms.{{ .fieldName }}())
+	{{- end }}
+	ms.Set{{ .fieldName }}({{ .testValue }})
+	assert.True(t, ms.Has{{ .fieldName }}())
+	{{- if eq .returnType "float64" }}
+	assert.InDelta(t, {{.testValue }}, ms.{{ .fieldName }}(), 0.01)
+	{{- else }}
+	assert.Equal(t, {{ .testValue }}, ms.{{ .fieldName }}())
+	{{- end }}
+	ms.Remove{{ .fieldName }}()
+	assert.False(t, ms.Has{{ .fieldName }}())
+	dest := New{{ .structName }}()
+	dest.Set{{ .fieldName }}({{ .testValue }})
+	ms.CopyTo(dest)
+	assert.False(t, dest.Has{{ .fieldName }}())
+}`
+
+const optionalPrimitiveSetTestTemplate = `tv.orig.{{ .fieldName }}_ = &{{ .originStructType }}{
+{{- .fieldName }}: {{ .testValue }}}`
+
+const optionalPrimitiveCopyOrigTemplate = `if src{{ .fieldName }}, ok := src.{{ .fieldName }}_.(*{{ .originStructType }}); ok {
+	dest{{ .fieldName }}, ok := dest.{{ .fieldName }}_.(*{{ .originStructType }})
+	if !ok {
+		dest{{ .fieldName }} = &{{ .originStructType }}{}
+		dest.{{ .fieldName }}_ = dest{{ .fieldName }}
+	}
+	dest{{ .fieldName }}.{{ .fieldName }} = src{{ .fieldName }}.{{ .fieldName }}
+} else {
+	dest.{{ .fieldName }}_ = nil
+}`
+
+const optionalPrimitiveMarshalJSONTemplate = `// Marshal orig.{{ .fieldName }} as JSON.
+	if ms.Has{{ .fieldName }}() {
+		dest.WriteObjectField("{{ lowerFirst .fieldName }}")
+		dest.Write{{ upperFirst .returnType }}(ms.{{ .fieldName }}())
+	}`
+
+type optionalPrimitiveField struct {
+	fieldName  string
+	defaultVal string
+	testVal    string
+	returnType string
+}
+
+func (opv *optionalPrimitiveField) GenerateAccessors(ms *messageStruct) string {
+	t := template.Must(templateNew("optionalPrimitiveAccessorsTemplate").Parse(optionalPrimitiveAccessorsTemplate))
+	return executeTemplate(t, opv.templateFields(ms))
+}
+
+func (opv *optionalPrimitiveField) GenerateAccessorsTest(ms *messageStruct) string {
+	t := template.Must(templateNew("optionalPrimitiveAccessorsTestTemplate").Parse(optionalPrimitiveAccessorsTestTemplate))
+	return executeTemplate(t, opv.templateFields(ms))
+}
+
+func (opv *optionalPrimitiveField) GenerateSetWithTestValue(ms *messageStruct) string {
+	t := template.Must(templateNew("optionalPrimitiveSetTestTemplate").Parse(optionalPrimitiveSetTestTemplate))
+	return executeTemplate(t, opv.templateFields(ms))
+}
+
+func (opv *optionalPrimitiveField) GenerateCopyOrig(ms *messageStruct) string {
+	t := template.Must(templateNew("optionalPrimitiveCopyOrigTemplate").Parse(optionalPrimitiveCopyOrigTemplate))
+	return executeTemplate(t, opv.templateFields(ms))
+}
+
+func (opv *optionalPrimitiveField) GenerateMarshalJSON(ms *messageStruct) string {
+	t := template.Must(templateNew("optionalPrimitiveMarshalJSONTemplate").Parse(optionalPrimitiveMarshalJSONTemplate))
+	return executeTemplate(t, opv.templateFields(ms))
+}
+
+func (opv *optionalPrimitiveField) templateFields(ms *messageStruct) map[string]any {
+	return map[string]any{
+		"structName":       ms.getName(),
+		"packageName":      "",
+		"defaultVal":       opv.defaultVal,
+		"fieldName":        opv.fieldName,
+		"lowerFieldName":   strings.ToLower(opv.fieldName),
+		"testValue":        opv.testVal,
+		"returnType":       opv.returnType,
+		"originStructName": ms.originFullName,
+		"originStructType": ms.originFullName + "_" + opv.fieldName,
+	}
+}
+
+var _ baseField = (*optionalPrimitiveField)(nil)

internal/cmd/pdatagen/internal/optional_primitive_field.go

@@ -8,13 +8,16 @@ var pcommon = &Package{
 		name: "pcommon",
 		path: "pcommon",
 		imports: []string{
+			`jsoniter "github.com/json-iterator/go"`,
+			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
 			`otlpcommon "go.opentelemetry.io/collector/pdata/internal/data/protogen/common/v1"`,
 			`otlpresource "go.opentelemetry.io/collector/pdata/internal/data/protogen/resource/v1"`,
 		},
 		testImports: []string{
 			`"testing"`,
 			``,
+			`jsoniter "github.com/json-iterator/go"`,
 			`"github.com/stretchr/testify/assert"`,
 			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
@@ -75,19 +78,19 @@ var timestampType = &primitiveType{
 	testVal:     "1234567890",
 }
 
-var startTimeField = &primitiveTypedField{
+var startTimeField = &typedField{
 	fieldName:       "StartTimestamp",
 	originFieldName: "StartTimeUnixNano",
 	returnType:      timestampType,
 }
 
-var timeField = &primitiveTypedField{
+var timeField = &typedField{
 	fieldName:       "Timestamp",
 	originFieldName: "TimeUnixNano",
 	returnType:      timestampType,
 }
 
-var endTimeField = &primitiveTypedField{
+var endTimeField = &typedField{
 	fieldName:       "EndTimestamp",
 	originFieldName: "EndTimeUnixNano",
 	returnType:      timestampType,
@@ -111,27 +114,26 @@ var anyValue = &messageStruct{
 	originFullName: "otlpcommon.AnyValue",
 }
 
-var traceIDField = &primitiveTypedField{
+var traceIDField = &typedField{
 	fieldName:       "TraceID",
 	originFieldName: "TraceId",
-	returnType:      traceIDType,
-}
-
-var traceIDType = &primitiveType{
-	structName:  "TraceID",
-	packageName: "pcommon",
-	rawType:     "data.TraceID",
-	defaultVal:  "data.TraceID([16]byte{})",
-	testVal:     "data.TraceID([16]byte{1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1})",
+	returnType: &primitiveType{
+		structName:  "TraceID",
+		packageName: "pcommon",
+		rawType:     "data.TraceID",
+		isType:      true,
+		defaultVal:  "data.TraceID([16]byte{})",
+		testVal:     "data.TraceID([16]byte{1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1})",
+	},
 }
 
-var spanIDField = &primitiveTypedField{
+var spanIDField = &typedField{
 	fieldName:       "SpanID",
 	originFieldName: "SpanId",
 	returnType:      spanIDType,
 }
 
-var parentSpanIDField = &primitiveTypedField{
+var parentSpanIDField = &typedField{
 	fieldName:       "ParentSpanID",
 	originFieldName: "ParentSpanId",
 	returnType:      spanIDType,
@@ -141,6 +143,7 @@ var spanIDType = &primitiveType{
 	structName:  "SpanID",
 	packageName: "pcommon",
 	rawType:     "data.SpanID",
+	isType:      true,
 	defaultVal:  "data.SpanID([8]byte{})",
 	testVal:     "data.SpanID([8]byte{8, 7, 6, 5, 4, 3, 2, 1})",
 }

internal/cmd/pdatagen/internal/pcommon_package.go

@@ -10,6 +10,8 @@ var plog = &Package{
 		imports: []string{
 			`"sort"`,
 			``,
+			`jsoniter "github.com/json-iterator/go"`,
+			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
 			`"go.opentelemetry.io/collector/pdata/internal/data"`,
 			`otlplogs "go.opentelemetry.io/collector/pdata/internal/data/protogen/logs/v1"`,
@@ -19,6 +21,7 @@ var plog = &Package{
 			`"testing"`,
 			`"unsafe"`,
 			``,
+			`jsoniter "github.com/json-iterator/go"`,
 			`"github.com/stretchr/testify/assert"`,
 			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
@@ -85,19 +88,19 @@ var logRecord = &messageStruct{
 	description:    "// LogRecord are experimental implementation of OpenTelemetry Log Data Model.\n",
 	originFullName: "otlplogs.LogRecord",
 	fields: []baseField{
-		&primitiveTypedField{
+		&typedField{
 			fieldName:       "ObservedTimestamp",
 			originFieldName: "ObservedTimeUnixNano",
 			returnType:      timestampType,
 		},
-		&primitiveTypedField{
+		&typedField{
 			fieldName:       "Timestamp",
 			originFieldName: "TimeUnixNano",
 			returnType:      timestampType,
 		},
 		traceIDField,
 		spanIDField,
-		&primitiveTypedField{
+		&typedField{
 			fieldName: "Flags",
 			returnType: &primitiveType{
 				structName: "LogRecordFlags",
@@ -118,11 +121,12 @@ var logRecord = &messageStruct{
 			defaultVal: `""`,
 			testVal:    `"INFO"`,
 		},
-		&primitiveTypedField{
+		&typedField{
 			fieldName: "SeverityNumber",
 			returnType: &primitiveType{
 				structName: "SeverityNumber",
 				rawType:    "otlplogs.SeverityNumber",
+				isType:     true,
 				defaultVal: `otlplogs.SeverityNumber(0)`,
 				testVal:    `otlplogs.SeverityNumber(5)`,
 			},

internal/cmd/pdatagen/internal/plog_package.go

@@ -10,6 +10,8 @@ var pmetric = &Package{
 		imports: []string{
 			`"sort"`,
 			``,
+			`jsoniter "github.com/json-iterator/go"`,
+			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
 			`"go.opentelemetry.io/collector/pdata/internal/data"`,
 			`otlpmetrics "go.opentelemetry.io/collector/pdata/internal/data/protogen/metrics/v1"`,
@@ -19,6 +21,7 @@ var pmetric = &Package{
 			`"testing"`,
 			`"unsafe"`,
 			``,
+			`jsoniter "github.com/json-iterator/go"`,
 			`"github.com/stretchr/testify/assert"`,
 			``,
 			`"go.opentelemetry.io/collector/pdata/internal"`,
@@ -433,7 +436,7 @@ var exemplar = &messageStruct{
 	},
 }
 
-var dataPointFlagsField = &primitiveTypedField{
+var dataPointFlagsField = &typedField{
 	fieldName: "Flags",
 	returnType: &primitiveType{
 		structName: "DataPointFlags",
@@ -501,31 +504,32 @@ var isMonotonicField = &primitiveField{
 	testVal:    "true",
 }
 
-var aggregationTemporalityField = &primitiveTypedField{
+var aggregationTemporalityField = &typedField{
 	fieldName: "AggregationTemporality",
 	returnType: &primitiveType{
 		structName: "AggregationTemporality",
 		rawType:    "otlpmetrics.AggregationTemporality",
+		isType:     true,
 		defaultVal: "otlpmetrics.AggregationTemporality(0)",
 		testVal:    "otlpmetrics.AggregationTemporality(1)",
 	},
 }
 
-var sumField = &optionalPrimitiveValue{
+var sumField = &optionalPrimitiveField{
 	fieldName:  "Sum",
 	returnType: "float64",
 	defaultVal: "float64(0.0)",
 	testVal:    "float64(17.13)",
 }
 
-var minField = &optionalPrimitiveValue{
+var minField = &optionalPrimitiveField{
 	fieldName:  "Min",
 	returnType: "float64",
 	defaultVal: "float64(0.0)",
 	testVal:    "float64(9.23)",
 }
 
-var maxField = &optionalPrimitiveValue{
+var maxField = &optionalPrimitiveField{
 	fieldName:  "Max",
 	returnType: "float64",
 	defaultVal: "float64(0.0)",