feat(model): remove deprecated global NameValidationScheme

juliusmh · juliusmh · commit 4525d212e9e3 · 2025-07-03T16:00:57.000+02:00
diff --git a/expfmt/decode.go b/expfmt/decode.go
@@ -29,7 +29,7 @@ import (
 
 // Decoder types decode an input stream into metric families.
 type Decoder interface {
-	Decode(*dto.MetricFamily) error
+	Decode(*dto.MetricFamily, model.ValidationScheme) error
 }
 
 // DecodeOptions contains options used by the Decoder and in sample extraction.
@@ -86,14 +86,14 @@ type protoDecoder struct {
 }
 
 // Decode implements the Decoder interface.
-func (d *protoDecoder) Decode(v *dto.MetricFamily) error {
+func (d *protoDecoder) Decode(v *dto.MetricFamily, nameValidationScheme model.ValidationScheme) error {
 	opts := protodelim.UnmarshalOptions{
 		MaxSize: -1,
 	}
 	if err := opts.UnmarshalFrom(d.r, v); err != nil {
 		return err
 	}
-	if !model.IsValidMetricName(model.LabelValue(v.GetName())) {
+	if !model.IsValidMetricName(model.LabelValue(v.GetName()), nameValidationScheme) {
 		return fmt.Errorf("invalid metric name %q", v.GetName())
 	}
 	for _, m := range v.GetMetric() {
@@ -107,7 +107,7 @@ func (d *protoDecoder) Decode(v *dto.MetricFamily) error {
 			if !model.LabelValue(l.GetValue()).IsValid() {
 				return fmt.Errorf("invalid label value %q", l.GetValue())
 			}
-			if !model.LabelName(l.GetName()).IsValid() {
+			if !model.LabelName(l.GetName()).IsValid(nameValidationScheme) {
 				return fmt.Errorf("invalid label name %q", l.GetName())
 			}
 		}
@@ -123,7 +123,7 @@ type textDecoder struct {
 }
 
 // Decode implements the Decoder interface.
-func (d *textDecoder) Decode(v *dto.MetricFamily) error {
+func (d *textDecoder) Decode(v *dto.MetricFamily, _ model.ValidationScheme) error {
 	if d.err == nil {
 		// Read all metrics in one shot.
 		var p TextParser
@@ -156,8 +156,8 @@ type SampleDecoder struct {
 
 // Decode calls the Decode method of the wrapped Decoder and then extracts the
 // samples from the decoded MetricFamily into the provided model.Vector.
-func (sd *SampleDecoder) Decode(s *model.Vector) error {
-	err := sd.Dec.Decode(&sd.f)
+func (sd *SampleDecoder) Decode(s *model.Vector, nameValidationScheme model.ValidationScheme) error {
+	err := sd.Dec.Decode(&sd.f, nameValidationScheme)
 	if err != nil {
 		return err
 	}
diff --git a/expfmt/decode_test.go b/expfmt/decode_test.go
@@ -88,7 +88,7 @@ mf2 4
 	var all model.Vector
 	for {
 		var smpls model.Vector
-		err := dec.Decode(&smpls)
+		err := dec.Decode(&smpls, model.UTF8Validation)
 		if err != nil && errors.Is(err, io.EOF) {
 			break
 		}
@@ -369,22 +369,20 @@ func TestProtoDecoder(t *testing.T) {
 
 		var all model.Vector
 		for {
-			model.NameValidationScheme = model.LegacyValidation //nolint:staticcheck
 			var smpls model.Vector
-			err := dec.Decode(&smpls)
+			err := dec.Decode(&smpls, model.LegacyValidation)
 			if err != nil && errors.Is(err, io.EOF) {
 				break
 			}
 			if scenario.legacyNameFail {
 				require.Errorf(t, err, "Expected error when decoding without UTF-8 support enabled but got none")
-				model.NameValidationScheme = model.UTF8Validation //nolint:staticcheck
 				dec = &SampleDecoder{
 					Dec: &protoDecoder{r: strings.NewReader(scenario.in)},
 					Opts: &DecodeOptions{
 						Timestamp: testTime,
 					},
 				}
-				err = dec.Decode(&smpls)
+				err = dec.Decode(&smpls, model.UTF8Validation)
 				if errors.Is(err, io.EOF) {
 					break
 				}
@@ -412,7 +410,7 @@ func TestProtoMultiMessageDecoder(t *testing.T) {
 	var metrics []*dto.MetricFamily
 	for {
 		var mf dto.MetricFamily
-		if err := decoder.Decode(&mf); err != nil {
+		if err := decoder.Decode(&mf, model.UTF8Validation); err != nil {
 			if errors.Is(err, io.EOF) {
 				break
 			}
@@ -560,7 +558,7 @@ func TestTextDecoderWithBufioReader(t *testing.T) {
 	dec := NewDecoder(r, FmtText)
 	for {
 		var mf dto.MetricFamily
-		if err := dec.Decode(&mf); err != nil {
+		if err := dec.Decode(&mf, model.UTF8Validation); err != nil {
 			if errors.Is(err, io.EOF) {
 				break
 			}
diff --git a/model/alert.go b/model/alert.go
@@ -88,20 +88,20 @@ func (a *Alert) StatusAt(ts time.Time) AlertStatus {
 }
 
 // Validate checks whether the alert data is inconsistent.
-func (a *Alert) Validate() error {
+func (a *Alert) Validate(nameValidationScheme ValidationScheme) error {
 	if a.StartsAt.IsZero() {
 		return errors.New("start time missing")
 	}
 	if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {
 		return errors.New("start time must be before end time")
 	}
-	if err := a.Labels.Validate(); err != nil {
+	if err := a.Labels.Validate(nameValidationScheme); err != nil {
 		return fmt.Errorf("invalid label set: %w", err)
 	}
 	if len(a.Labels) == 0 {
 		return errors.New("at least one label pair required")
 	}
-	if err := a.Annotations.Validate(); err != nil {
+	if err := a.Annotations.Validate(nameValidationScheme); err != nil {
 		return fmt.Errorf("invalid annotations: %w", err)
 	}
 	return nil
diff --git a/model/alert_test.go b/model/alert_test.go
@@ -22,91 +22,97 @@ import (
 )
 
 func TestAlertValidate(t *testing.T) {
-	oldScheme := NameValidationScheme
-	NameValidationScheme = LegacyValidation
-	defer func() {
-		NameValidationScheme = oldScheme
-	}()
 	ts := time.Now()
 
 	cases := []struct {
-		alert *Alert
-		err   string
+		alert  *Alert
+		err    string
+		scheme NameValidationScheme
 	}{
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b"},
 				StartsAt: ts,
 			},
+			scheme: LegacyValidation,
 		},
 		{
 			alert: &Alert{
 				Labels: LabelSet{"a": "b"},
 			},
-			err: "start time missing",
+			scheme: LegacyValidation,
+			err:    "start time missing",
 		},
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b"},
 				StartsAt: ts,
 				EndsAt:   ts,
 			},
+			scheme: LegacyValidation,
 		},
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b"},
 				StartsAt: ts,
 				EndsAt:   ts.Add(1 * time.Minute),
 			},
+			scheme: LegacyValidation,
 		},
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b"},
 				StartsAt: ts,
 				EndsAt:   ts.Add(-1 * time.Minute),
 			},
-			err: "start time must be before end time",
+			scheme: LegacyValidation,
+			err:    "start time must be before end time",
 		},
 		{
 			alert: &Alert{
 				StartsAt: ts,
 			},
-			err: "at least one label pair required",
+			scheme: LegacyValidation,
+			err:    "at least one label pair required",
 		},
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b", "!bad": "label"},
 				StartsAt: ts,
 			},
-			err: "invalid label set: invalid name",
+			scheme: LegacyValidation,
+			err:    "invalid label set: invalid name",
 		},
 		{
 			alert: &Alert{
 				Labels:   LabelSet{"a": "b", "bad": "\xfflabel"},
 				StartsAt: ts,
 			},
-			err: "invalid label set: invalid value",
+			scheme: LegacyValidation,
+			err:    "invalid label set: invalid value",
 		},
 		{
 			alert: &Alert{
 				Labels:      LabelSet{"a": "b"},
 				Annotations: LabelSet{"!bad": "label"},
 				StartsAt:    ts,
 			},
-			err: "invalid annotations: invalid name",
+			scheme: LegacyValidation,
+			err:    "invalid annotations: invalid name",
 		},
 		{
 			alert: &Alert{
 				Labels:      LabelSet{"a": "b"},
 				Annotations: LabelSet{"bad": "\xfflabel"},
 				StartsAt:    ts,
 			},
-			err: "invalid annotations: invalid value",
+			scheme: LegacyValidation,
+			err:    "invalid annotations: invalid value",
 		},
 	}
 
 	for i, c := range cases {
-		err := c.alert.Validate()
+		err := c.alert.Validate(c.scheme)
 		if err == nil {
 			if c.err == "" {
 				continue
diff --git a/model/labels.go b/model/labels.go
@@ -106,17 +106,17 @@ type LabelName string
 // IsValid returns true iff the name matches the pattern of LabelNameRE when
 // NameValidationScheme is set to LegacyValidation, or valid UTF-8 if
 // NameValidationScheme is set to UTF8Validation.
-func (ln LabelName) IsValid() bool {
+func (ln LabelName) IsValid(scheme ValidationScheme) bool {
 	if len(ln) == 0 {
 		return false
 	}
-	switch NameValidationScheme {
+	switch scheme {
 	case LegacyValidation:
 		return ln.IsValidLegacy()
 	case UTF8Validation:
 		return utf8.ValidString(string(ln))
 	default:
-		panic(fmt.Sprintf("Invalid name validation scheme requested: %d", NameValidationScheme))
+		panic(fmt.Sprintf("Invalid name validation scheme requested: %d", scheme))
 	}
 }
 
@@ -137,25 +137,27 @@ func (ln LabelName) IsValidLegacy() bool {
 }
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface.
+// Validation is done using UTF8Validation.
 func (ln *LabelName) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	var s string
 	if err := unmarshal(&s); err != nil {
 		return err
 	}
-	if !LabelName(s).IsValid() {
+	if !LabelName(s).IsValid(UTF8Validation) {
 		return fmt.Errorf("%q is not a valid label name", s)
 	}
 	*ln = LabelName(s)
 	return nil
 }
 
 // UnmarshalJSON implements the json.Unmarshaler interface.
+// Validation is done using UTF8Validation.
 func (ln *LabelName) UnmarshalJSON(b []byte) error {
 	var s string
 	if err := json.Unmarshal(b, &s); err != nil {
 		return err
 	}
-	if !LabelName(s).IsValid() {
+	if !LabelName(s).IsValid(UTF8Validation) {
 		return fmt.Errorf("%q is not a valid label name", s)
 	}
 	*ln = LabelName(s)
diff --git a/model/labels_test.go b/model/labels_test.go
@@ -144,15 +144,13 @@ func TestLabelNameIsValid(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		NameValidationScheme = LegacyValidation
-		if s.ln.IsValid() != s.legacyValid {
+		if s.ln.IsValid(LegacyValidation) != s.legacyValid {
 			t.Errorf("Expected %v for %q using legacy IsValid method", s.legacyValid, s.ln)
 		}
 		if LabelNameRE.MatchString(string(s.ln)) != s.legacyValid {
 			t.Errorf("Expected %v for %q using legacy regexp match", s.legacyValid, s.ln)
 		}
-		NameValidationScheme = UTF8Validation
-		if s.ln.IsValid() != s.utf8Valid {
+		if s.ln.IsValid(UTF8Validation) != s.utf8Valid {
 			t.Errorf("Expected %v for %q using UTF-8 IsValid method", s.legacyValid, s.ln)
 		}
 	}
diff --git a/model/labelset.go b/model/labelset.go
@@ -28,9 +28,9 @@ type LabelSet map[LabelName]LabelValue
 
 // Validate checks whether all names and values in the label set
 // are valid.
-func (ls LabelSet) Validate() error {
+func (ls LabelSet) Validate(nameValidationScheme ValidationScheme) error {
 	for ln, lv := range ls {
-		if !ln.IsValid() {
+		if !ln.IsValid(nameValidationScheme) {
 			return fmt.Errorf("invalid name %q", ln)
 		}
 		if !lv.IsValid() {
@@ -140,6 +140,7 @@ func (ls LabelSet) FastFingerprint() Fingerprint {
 }
 
 // UnmarshalJSON implements the json.Unmarshaler interface.
+// Validates label names using UTF8Validation.
 func (l *LabelSet) UnmarshalJSON(b []byte) error {
 	var m map[LabelName]LabelValue
 	if err := json.Unmarshal(b, &m); err != nil {
@@ -149,7 +150,7 @@ func (l *LabelSet) UnmarshalJSON(b []byte) error {
 	// LabelName as a string and does not call its UnmarshalJSON method.
 	// Thus, we have to replicate the behavior here.
 	for ln := range m {
-		if !ln.IsValid() {
+		if !ln.IsValid(UTF8Validation) {
 			return fmt.Errorf("%q is not a valid label name", ln)
 		}
 	}
diff --git a/model/labelset_test.go b/model/labelset_test.go
@@ -16,6 +16,8 @@ package model
 import (
 	"encoding/json"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestUnmarshalJSONLabelSet(t *testing.T) {
@@ -55,12 +57,11 @@ func TestUnmarshalJSONLabelSet(t *testing.T) {
 	}
 }`
 
-	NameValidationScheme = LegacyValidation
 	err = json.Unmarshal([]byte(invalidlabelSetJSON), &c)
-	expectedErr := `"1nvalid_23name" is not a valid label name`
-	if err == nil || err.Error() != expectedErr {
-		t.Errorf("expected an error with message '%s' to be thrown", expectedErr)
-	}
+	require.NoError(t, err)
+	err = c.LabelSet.Validate(LegacyValidation)
+	expectedErr := `invalid name "1nvalid_23name"`
+	require.EqualError(t, err, expectedErr)
 }
 
 func TestLabelSetClone(t *testing.T) {
diff --git a/model/metric.go b/model/metric.go
diff --git a/model/metric_test.go b/model/metric_test.go
diff --git a/model/silence.go b/model/silence.go
diff --git a/model/silence_test.go b/model/silence_test.go

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ import (`
`29`	`29`
`30`	`30`	`// Decoder types decode an input stream into metric families.`
`31`	`31`	`type Decoder interface {`
`32`		`- Decode(*dto.MetricFamily) error`
	`32`	`+ Decode(*dto.MetricFamily, model.ValidationScheme) error`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`// DecodeOptions contains options used by the Decoder and in sample extraction.`
`@@ -86,14 +86,14 @@ type protoDecoder struct {`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`// Decode implements the Decoder interface.`
`89`		`-func (d protoDecoder) Decode(v dto.MetricFamily) error {`
	`89`	`+func (d protoDecoder) Decode(v dto.MetricFamily, nameValidationScheme model.ValidationScheme) error {`
`90`	`90`	`opts := protodelim.UnmarshalOptions{`
`91`	`91`	`MaxSize: -1,`
`92`	`92`	`}`
`93`	`93`	`if err := opts.UnmarshalFrom(d.r, v); err != nil {`
`94`	`94`	`return err`
`95`	`95`	`}`
`96`		`- if !model.IsValidMetricName(model.LabelValue(v.GetName())) {`
	`96`	`+ if !model.IsValidMetricName(model.LabelValue(v.GetName()), nameValidationScheme) {`
`97`	`97`	`return fmt.Errorf("invalid metric name %q", v.GetName())`
`98`	`98`	`}`
`99`	`99`	`for _, m := range v.GetMetric() {`
`@@ -107,7 +107,7 @@ func (d protoDecoder) Decode(v dto.MetricFamily) error {`
`107`	`107`	`if !model.LabelValue(l.GetValue()).IsValid() {`
`108`	`108`	`return fmt.Errorf("invalid label value %q", l.GetValue())`
`109`	`109`	`}`
`110`		`- if !model.LabelName(l.GetName()).IsValid() {`
	`110`	`+ if !model.LabelName(l.GetName()).IsValid(nameValidationScheme) {`
`111`	`111`	`return fmt.Errorf("invalid label name %q", l.GetName())`
`112`	`112`	`}`
`113`	`113`	`}`
`@@ -123,7 +123,7 @@ type textDecoder struct {`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`// Decode implements the Decoder interface.`
`126`		`-func (d textDecoder) Decode(v dto.MetricFamily) error {`
	`126`	`+func (d textDecoder) Decode(v dto.MetricFamily, _ model.ValidationScheme) error {`
`127`	`127`	`if d.err == nil {`
`128`	`128`	`// Read all metrics in one shot.`
`129`	`129`	`var p TextParser`
`@@ -156,8 +156,8 @@ type SampleDecoder struct {`
`156`	`156`
`157`	`157`	`// Decode calls the Decode method of the wrapped Decoder and then extracts the`
`158`	`158`	`// samples from the decoded MetricFamily into the provided model.Vector.`
`159`		`-func (sd SampleDecoder) Decode(s model.Vector) error {`
`160`		`- err := sd.Dec.Decode(&sd.f)`
	`159`	`+func (sd SampleDecoder) Decode(s model.Vector, nameValidationScheme model.ValidationScheme) error {`
	`160`	`+ err := sd.Dec.Decode(&sd.f, nameValidationScheme)`
`161`	`161`	`if err != nil {`
`162`	`162`	`return err`
`163`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,20 +88,20 @@ func (a *Alert) StatusAt(ts time.Time) AlertStatus {`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`// Validate checks whether the alert data is inconsistent.`
`91`		`-func (a *Alert) Validate() error {`
	`91`	`+func (a *Alert) Validate(nameValidationScheme ValidationScheme) error {`
`92`	`92`	`if a.StartsAt.IsZero() {`
`93`	`93`	`return errors.New("start time missing")`
`94`	`94`	`}`
`95`	`95`	`if !a.EndsAt.IsZero() && a.EndsAt.Before(a.StartsAt) {`
`96`	`96`	`return errors.New("start time must be before end time")`
`97`	`97`	`}`
`98`		`- if err := a.Labels.Validate(); err != nil {`
	`98`	`+ if err := a.Labels.Validate(nameValidationScheme); err != nil {`
`99`	`99`	`return fmt.Errorf("invalid label set: %w", err)`
`100`	`100`	`}`
`101`	`101`	`if len(a.Labels) == 0 {`
`102`	`102`	`return errors.New("at least one label pair required")`
`103`	`103`	`}`
`104`		`- if err := a.Annotations.Validate(); err != nil {`
	`104`	`+ if err := a.Annotations.Validate(nameValidationScheme); err != nil {`
`105`	`105`	`return fmt.Errorf("invalid annotations: %w", err)`
`106`	`106`	`}`
`107`	`107`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -106,17 +106,17 @@ type LabelName string`
`106`	`106`	`// IsValid returns true iff the name matches the pattern of LabelNameRE when`
`107`	`107`	`// NameValidationScheme is set to LegacyValidation, or valid UTF-8 if`
`108`	`108`	`// NameValidationScheme is set to UTF8Validation.`
`109`		`-func (ln LabelName) IsValid() bool {`
	`109`	`+func (ln LabelName) IsValid(scheme ValidationScheme) bool {`
`110`	`110`	`if len(ln) == 0 {`
`111`	`111`	`return false`
`112`	`112`	`}`
`113`		`- switch NameValidationScheme {`
	`113`	`+ switch scheme {`
`114`	`114`	`case LegacyValidation:`
`115`	`115`	`return ln.IsValidLegacy()`
`116`	`116`	`case UTF8Validation:`
`117`	`117`	`return utf8.ValidString(string(ln))`
`118`	`118`	`default:`
`119`		`- panic(fmt.Sprintf("Invalid name validation scheme requested: %d", NameValidationScheme))`
	`119`	`+ panic(fmt.Sprintf("Invalid name validation scheme requested: %d", scheme))`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
`@@ -137,25 +137,27 @@ func (ln LabelName) IsValidLegacy() bool {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`// UnmarshalYAML implements the yaml.Unmarshaler interface.`
	`140`	`+// Validation is done using UTF8Validation.`
`140`	`141`	`func (ln *LabelName) UnmarshalYAML(unmarshal func(interface{}) error) error {`
`141`	`142`	`var s string`
`142`	`143`	`if err := unmarshal(&s); err != nil {`
`143`	`144`	`return err`
`144`	`145`	`}`
`145`		`- if !LabelName(s).IsValid() {`
	`146`	`+ if !LabelName(s).IsValid(UTF8Validation) {`
`146`	`147`	`return fmt.Errorf("%q is not a valid label name", s)`
`147`	`148`	`}`
`148`	`149`	`*ln = LabelName(s)`
`149`	`150`	`return nil`
`150`	`151`	`}`
`151`	`152`
`152`	`153`	`// UnmarshalJSON implements the json.Unmarshaler interface.`
	`154`	`+// Validation is done using UTF8Validation.`
`153`	`155`	`func (ln *LabelName) UnmarshalJSON(b []byte) error {`
`154`	`156`	`var s string`
`155`	`157`	`if err := json.Unmarshal(b, &s); err != nil {`
`156`	`158`	`return err`
`157`	`159`	`}`
`158`		`- if !LabelName(s).IsValid() {`
	`160`	`+ if !LabelName(s).IsValid(UTF8Validation) {`
`159`	`161`	`return fmt.Errorf("%q is not a valid label name", s)`
`160`	`162`	`}`
`161`	`163`	`*ln = LabelName(s)`
Original file line number	Diff line number	Diff line change
`@@ -144,15 +144,13 @@ func TestLabelNameIsValid(t *testing.T) {`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`for _, s := range scenarios {`
`147`		`- NameValidationScheme = LegacyValidation`
`148`		`- if s.ln.IsValid() != s.legacyValid {`
	`147`	`+ if s.ln.IsValid(LegacyValidation) != s.legacyValid {`
`149`	`148`	`t.Errorf("Expected %v for %q using legacy IsValid method", s.legacyValid, s.ln)`
`150`	`149`	`}`
`151`	`150`	`if LabelNameRE.MatchString(string(s.ln)) != s.legacyValid {`
`152`	`151`	`t.Errorf("Expected %v for %q using legacy regexp match", s.legacyValid, s.ln)`
`153`	`152`	`}`
`154`		`- NameValidationScheme = UTF8Validation`
`155`		`- if s.ln.IsValid() != s.utf8Valid {`
	`153`	`+ if s.ln.IsValid(UTF8Validation) != s.utf8Valid {`
`156`	`154`	`t.Errorf("Expected %v for %q using UTF-8 IsValid method", s.legacyValid, s.ln)`
`157`	`155`	`}`
`158`	`156`	`}`