add validation/tests for SpanLimits

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

Author: codeboten

otelconf/config_json.go

@@ -623,6 +623,7 @@ func (j *TextMapPropagator) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+// UnmarshalJSON implements json.Unmarshaler.
 func (j *CardinalityLimits) UnmarshalJSON(value []byte) error {
 	type Plain CardinalityLimits
 	var plain Plain
@@ -635,3 +636,17 @@ func (j *CardinalityLimits) UnmarshalJSON(value []byte) error {
 	*j = CardinalityLimits(plain)
 	return nil
 }
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (j *SpanLimits) UnmarshalJSON(value []byte) error {
+	type Plain SpanLimits
+	var plain Plain
+	if err := json.Unmarshal(value, &plain); err != nil {
+		return err
+	}
+	if err := validateSpanLimits((*SpanLimits)(&plain)); err != nil {
+		return err
+	}
+	*j = SpanLimits(plain)
+	return nil
+}

otelconf/config_test.go

@@ -1299,3 +1299,83 @@ func TestUnmarshalCardinalityLimits(t *testing.T) {
 		})
 	}
 }
+
+func TestUnmarshalSpanLimits(t *testing.T) {
+	for _, tt := range []struct {
+		name       string
+		yamlConfig []byte
+		jsonConfig []byte
+		wantErr    string
+	}{
+		{
+			name:       "valid with all fields positive",
+			jsonConfig: []byte(`{"attribute_count_limit":100,"attribute_value_length_limit":200,"event_attribute_count_limit":300,"event_count_limit":400,"link_attribute_count_limit":500,"link_count_limit":600}`),
+			yamlConfig: []byte("attribute_count_limit: 100\nattribute_value_length_limit: 200\nevent_attribute_count_limit: 300\nevent_count_limit: 400\nlink_attribute_count_limit: 500\nlink_count_limit: 600"),
+		},
+		{
+			name:       "valid with single field",
+			jsonConfig: []byte(`{"attribute_value_length_limit":2000}`),
+			yamlConfig: []byte("attribute_value_length_limit: 2000"),
+		},
+		{
+			name:       "valid empty",
+			jsonConfig: []byte(`{}`),
+			yamlConfig: []byte("{}"),
+		},
+		{
+			name:       "invalid attribute_count_limit negative",
+			jsonConfig: []byte(`{"attribute_count_limit":-1}`),
+			yamlConfig: []byte("attribute_count_limit: -1"),
+			wantErr:    "field attribute_count_limit: must be >= 0",
+		},
+		{
+			name:       "invalid attribute_value_length_limit negative",
+			jsonConfig: []byte(`{"attribute_value_length_limit":-1}`),
+			yamlConfig: []byte("attribute_value_length_limit: -1"),
+			wantErr:    "field attribute_value_length_limit: must be >= 0",
+		},
+		{
+			name:       "invalid event_attribute_count_limit negative",
+			jsonConfig: []byte(`{"event_attribute_count_limit":-1}`),
+			yamlConfig: []byte("event_attribute_count_limit: -1"),
+			wantErr:    "field event_attribute_count_limit: must be >= 0",
+		},
+		{
+			name:       "invalid event_count_limit negative",
+			jsonConfig: []byte(`{"event_count_limit":-1}`),
+			yamlConfig: []byte("event_count_limit: -1"),
+			wantErr:    "field event_count_limit: must be >= 0",
+		},
+		{
+			name:       "invalid link_attribute_count_limit negative",
+			jsonConfig: []byte(`{"link_attribute_count_limit":-1}`),
+			yamlConfig: []byte("link_attribute_count_limit: -1"),
+			wantErr:    "field link_attribute_count_limit: must be >= 0",
+		},
+		{
+			name:       "invalid link_count_limit negative",
+			jsonConfig: []byte(`{"link_count_limit":-1}`),
+			yamlConfig: []byte("link_count_limit: -1"),
+			wantErr:    "field link_count_limit: must be >= 0",
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			cl := SpanLimits{}
+			err := cl.UnmarshalJSON(tt.jsonConfig)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+			cl = SpanLimits{}
+			err = yaml.Unmarshal(tt.yamlConfig, &cl)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				require.Contains(t, err.Error(), tt.wantErr)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

otelconf/config_yaml.go

@@ -326,6 +326,7 @@ func (j *BatchSpanProcessor) UnmarshalYAML(node *yaml.Node) error {
 	return nil
 }
 
+// UnmarshalYAML implements yaml.Unmarshaler.
 func (j *CardinalityLimits) UnmarshalYAML(node *yaml.Node) error {
 	type Plain CardinalityLimits
 	var plain Plain
@@ -338,3 +339,17 @@ func (j *CardinalityLimits) UnmarshalYAML(node *yaml.Node) error {
 	*j = CardinalityLimits(plain)
 	return nil
 }
+
+// UnmarshalYAML implements yaml.Unmarshaler.
+func (j *SpanLimits) UnmarshalYAML(node *yaml.Node) error {
+	type Plain SpanLimits
+	var plain Plain
+	if err := node.Decode(&plain); err != nil {
+		return err
+	}
+	if err := validateSpanLimits((*SpanLimits)(&plain)); err != nil {
+		return err
+	}
+	*j = SpanLimits(plain)
+	return nil
+}

otelconf/v1.0.0-rc.1/config_common.go

@@ -218,3 +218,26 @@ func validateCardinalityLimits(plain *CardinalityLimits) error {
 	}
 	return nil
 }
+
+// validateSpanLimits handles validation for SpanLimits.
+func validateSpanLimits(plain *SpanLimits) error {
+	if plain.AttributeCountLimit != nil && 0 > *plain.AttributeCountLimit {
+		return fmt.Errorf("field %s: must be >= %v", "attribute_count_limit", 0)
+	}
+	if plain.AttributeValueLengthLimit != nil && 0 > *plain.AttributeValueLengthLimit {
+		return fmt.Errorf("field %s: must be >= %v", "attribute_value_length_limit", 0)
+	}
+	if plain.EventAttributeCountLimit != nil && 0 > *plain.EventAttributeCountLimit {
+		return fmt.Errorf("field %s: must be >= %v", "event_attribute_count_limit", 0)
+	}
+	if plain.EventCountLimit != nil && 0 > *plain.EventCountLimit {
+		return fmt.Errorf("field %s: must be >= %v", "event_count_limit", 0)
+	}
+	if plain.LinkAttributeCountLimit != nil && 0 > *plain.LinkAttributeCountLimit {
+		return fmt.Errorf("field %s: must be >= %v", "link_attribute_count_limit", 0)
+	}
+	if plain.LinkCountLimit != nil && 0 > *plain.LinkCountLimit {
+		return fmt.Errorf("field %s: must be >= %v", "link_count_limit", 0)
+	}
+	return nil
+}