add unmarshal for experimental peer instrumentation

Signed-off-by: alex boten <[email protected]>

Author: codeboten

CHANGELOG.md

@@ -18,7 +18,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Add unmarshaling and validation for `TextMapPropagator` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8052)
 - Add unmarshaling and validation for `OTLPHttpExporter`, `OTLPGrpcExporter`, `OTLPGrpcMetricExporter` and `OTLPHttpMetricExporter` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8112)
 - Add a `WithSpanNameFormatter` option to `go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/v2/mongo/otelmongo`. (#7986)
-- Add unmarshaling and validation for `AttributeType`, `AttributeNameValue`, `SimpleSpanProcessor`, `SimpleLogRecordProcessor`, `ZipkinSpanExporter`, `NameStringValuePair`, `InstrumentType` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8127)
+- Add unmarshaling and validation for `AttributeType`, `AttributeNameValue`, `SimpleSpanProcessor`, `SimpleLogRecordProcessor`, `ZipkinSpanExporter`, `NameStringValuePair`, `InstrumentType`, `ExperimentalPeerInstrumentationServiceMappingElem` to v1.0.0 model in `go.opentelemetry.io/contrib/otelconf`. (#8127)
 
 ### Changed
 

otelconf/config_json.go

@@ -650,3 +650,32 @@ func (j *InstrumentType) UnmarshalJSON(b []byte) error {
 	*j = InstrumentType(v)
 	return nil
 }
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (j *ExperimentalPeerInstrumentationServiceMappingElem) UnmarshalJSON(b []byte) error {
+	type Plain ExperimentalPeerInstrumentationServiceMappingElem
+	type shadow struct {
+		Plain
+		Peer    json.RawMessage `json:"peer"`
+		Service json.RawMessage `json:"service"`
+	}
+	var sh shadow
+	if err := json.Unmarshal(b, &sh); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
+	}
+	if sh.Peer == nil {
+		return newErrRequired(j, "peer")
+	}
+	if err := json.Unmarshal(sh.Peer, &sh.Plain.Peer); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
+	}
+	if sh.Service == nil {
+		return newErrRequired(j, "service")
+	}
+	if err := json.Unmarshal(sh.Service, &sh.Plain.Service); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
+	}
+
+	*j = ExperimentalPeerInstrumentationServiceMappingElem(sh.Plain)
+	return nil
+}

otelconf/config_test.go

@@ -1237,6 +1237,12 @@ func TestUnmarshalNameStringValuePairType(t *testing.T) {
 			yamlConfig: []byte("name: test"),
 			wantErrT:   newErrRequired(&NameStringValuePair{}, "value"),
 		},
+		{
+			name:       "invalid array name",
+			jsonConfig: []byte(`{"name":[], "value": ["test-val", "test-val-2"], "type": "string_array"}`),
+			yamlConfig: []byte("name: []\nvalue: [test-val, test-val-2]\ntype: string_array\n"),
+			wantErrT:   newErrUnmarshal(&NameStringValuePair{}),
+		},
 		{
 			name:       "valid string value",
 			jsonConfig: []byte(`{"name":"test", "value": "test-val", "type": "string"}`),
@@ -1308,3 +1314,65 @@ func TestUnmarshalInstrumentType(t *testing.T) {
 		})
 	}
 }
+
+func TestUnmarshalExperimentalPeerInstrumentationServiceMappingElemType(t *testing.T) {
+	for _, tt := range []struct {
+		name                                                  string
+		yamlConfig                                            []byte
+		jsonConfig                                            []byte
+		wantErrT                                              error
+		wantExperimentalPeerInstrumentationServiceMappingElem ExperimentalPeerInstrumentationServiceMappingElem
+	}{
+		{
+			name:       "invalid data",
+			jsonConfig: []byte(`{:2000}`),
+			yamlConfig: []byte("peer: []\nservice: true"),
+			wantErrT:   newErrUnmarshal(&ExperimentalPeerInstrumentationServiceMappingElem{}),
+		},
+		{
+			name:       "missing required peer field",
+			jsonConfig: []byte(`{}`),
+			yamlConfig: []byte("{}"),
+			wantErrT:   newErrRequired(&ExperimentalPeerInstrumentationServiceMappingElem{}, "peer"),
+		},
+		{
+			name:       "missing required service field",
+			jsonConfig: []byte(`{"peer":"test"}`),
+			yamlConfig: []byte("peer: test"),
+			wantErrT:   newErrRequired(&ExperimentalPeerInstrumentationServiceMappingElem{}, "service"),
+		},
+		{
+			name:       "invalid string_array peer",
+			jsonConfig: []byte(`{"peer":[], "service": ["test-val", "test-val-2"], "type": "string_array"}`),
+			yamlConfig: []byte("peer: []\nservice: [test-val, test-val-2]\ntype: string_array\n"),
+			wantErrT:   newErrUnmarshal(&ExperimentalPeerInstrumentationServiceMappingElem{}),
+		},
+		{
+			name:       "valid string service",
+			jsonConfig: []byte(`{"peer":"test", "service": "test-val"}`),
+			yamlConfig: []byte("peer: test\nservice: test-val"),
+			wantExperimentalPeerInstrumentationServiceMappingElem: ExperimentalPeerInstrumentationServiceMappingElem{
+				Peer:    "test",
+				Service: "test-val",
+			},
+		},
+		{
+			name:       "invalid string_array service",
+			jsonConfig: []byte(`{"peer":"test", "service": ["test-val", "test-val-2"], "type": "string_array"}`),
+			yamlConfig: []byte("peer: test\nservice: [test-val, test-val-2]\ntype: string_array\n"),
+			wantErrT:   newErrUnmarshal(&ExperimentalPeerInstrumentationServiceMappingElem{}),
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			val := ExperimentalPeerInstrumentationServiceMappingElem{}
+			err := val.UnmarshalJSON(tt.jsonConfig)
+			assert.ErrorIs(t, err, tt.wantErrT)
+			assert.Equal(t, tt.wantExperimentalPeerInstrumentationServiceMappingElem, val)
+
+			val = ExperimentalPeerInstrumentationServiceMappingElem{}
+			err = yaml.Unmarshal(tt.yamlConfig, &val)
+			assert.ErrorIs(t, err, tt.wantErrT)
+			assert.Equal(t, tt.wantExperimentalPeerInstrumentationServiceMappingElem, val)
+		})
+	}
+}

otelconf/config_yaml.go

@@ -395,3 +395,22 @@ func (j *InstrumentType) UnmarshalYAML(node *yaml.Node) error {
 	*j = InstrumentType(plain)
 	return nil
 }
+
+// UnmarshalYAML implements yaml.Unmarshaler.
+func (j *ExperimentalPeerInstrumentationServiceMappingElem) UnmarshalYAML(node *yaml.Node) error {
+	if !hasYAMLMapKey(node, "peer") {
+		return newErrRequired(j, "peer")
+	}
+	if !hasYAMLMapKey(node, "service") {
+		return newErrRequired(j, "service")
+	}
+
+	type Plain ExperimentalPeerInstrumentationServiceMappingElem
+	var plain Plain
+	if err := node.Decode(&plain); err != nil {
+		return errors.Join(newErrUnmarshal(j), err)
+	}
+
+	*j = ExperimentalPeerInstrumentationServiceMappingElem(plain)
+	return nil
+}