feat(pkg/streamingpromql): use utf8 naming scheme in count_values unit test

juliusmh · juliusmh · commit 37d2a4953bcb · 2025-07-02T08:41:30.000+02:00
diff --git a/pkg/streamingpromql/compat/name_validating_engine.go b/pkg/streamingpromql/compat/name_validating_engine.go
@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"github.com/grafana/dskit/tenant"
-	prom_validation "github.com/prometheus/prometheus/model/validation"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/storage"
 
@@ -25,64 +25,64 @@ func NameValidatingEngine(engine promql.QueryEngine, limits *validation.Override
 	return &nameValidatingEngine{engine: engine, limits: limits}
 }
 
-type optsWithNamingScheme struct {
+type optsWithValidationScheme struct {
 	promql.QueryOpts
-	namingScheme prom_validation.NamingScheme
+	validationScheme model.ValidationScheme
 }
 
-func (o optsWithNamingScheme) EnablePerStepStats() bool {
+func (o optsWithValidationScheme) EnablePerStepStats() bool {
 	return o.QueryOpts.EnablePerStepStats()
 }
 
-func (o optsWithNamingScheme) LookbackDelta() time.Duration {
+func (o optsWithValidationScheme) LookbackDelta() time.Duration {
 	return o.QueryOpts.LookbackDelta()
 }
 
-func (o optsWithNamingScheme) NameValidationScheme() prom_validation.NamingScheme {
-	return o.namingScheme
+func (o optsWithValidationScheme) ValidationScheme() model.ValidationScheme {
+	return o.validationScheme
 }
 
 func (e nameValidatingEngine) NewInstantQuery(ctx context.Context, q storage.Queryable, opts promql.QueryOpts, qs string, ts time.Time) (promql.Query, error) {
-	namingScheme, err := e.getNamingScheme(ctx)
+	validationScheme, err := e.getValidationScheme(ctx)
 	if err != nil {
 		return nil, err
 	}
 	if opts == nil {
-		opts = promql.NewPrometheusQueryOpts(false, 0, prom_validation.UTF8NamingScheme)
+		opts = promql.NewPrometheusQueryOpts(false, 0, model.UTF8Validation)
 	}
-	opts = &optsWithNamingScheme{
-		QueryOpts:    opts,
-		namingScheme: namingScheme,
+	opts = &optsWithValidationScheme{
+		QueryOpts:        opts,
+		validationScheme: validationScheme,
 	}
 	return e.engine.NewInstantQuery(ctx, q, opts, qs, ts)
 }
 
 func (e nameValidatingEngine) NewRangeQuery(ctx context.Context, q storage.Queryable, opts promql.QueryOpts, qs string, start, end time.Time, interval time.Duration) (promql.Query, error) {
-	namingScheme, err := e.getNamingScheme(ctx)
+	validationScheme, err := e.getValidationScheme(ctx)
 	if err != nil {
 		return nil, err
 	}
 	if opts == nil {
-		opts = promql.NewPrometheusQueryOpts(false, 0, prom_validation.UTF8NamingScheme)
+		opts = promql.NewPrometheusQueryOpts(false, 0, model.UTF8Validation)
 	}
-	opts = &optsWithNamingScheme{
-		QueryOpts:    opts,
-		namingScheme: namingScheme,
+	opts = &optsWithValidationScheme{
+		QueryOpts:        opts,
+		validationScheme: validationScheme,
 	}
 	return e.engine.NewRangeQuery(ctx, q, opts, qs, start, end, interval)
 }
 
-// getNamingScheme retrieves the name validation scheme to use from a context containing tenant IDs.
+// getValidationScheme retrieves the name validation scheme to use from a context containing tenant IDs.
 // Returns legacy validation scheme if at least one tenant uses legacy validation.
-func (e nameValidatingEngine) getNamingScheme(ctx context.Context) (prom_validation.NamingScheme, error) {
+func (e nameValidatingEngine) getValidationScheme(ctx context.Context) (model.ValidationScheme, error) {
 	tenantIDs, err := tenant.TenantIDs(ctx)
 	if err != nil {
-		return "", err
+		return model.UnsetValidation, err
 	}
 	for _, tenantID := range tenantIDs {
-		if e.limits.NameValidationScheme(tenantID) == prom_validation.LegacyNamingScheme {
-			return prom_validation.LegacyNamingScheme, nil
+		if e.limits.ValidationScheme(tenantID) == model.LegacyValidation {
+			return model.LegacyValidation, nil
 		}
 	}
-	return prom_validation.UTF8NamingScheme, nil
+	return model.UTF8Validation, nil
 }
diff --git a/pkg/streamingpromql/engine_test.go b/pkg/streamingpromql/engine_test.go
@@ -21,10 +21,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/testutil"
 	dto "github.com/prometheus/client_model/go"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/histogram"
 	"github.com/prometheus/prometheus/model/labels"
 	"github.com/prometheus/prometheus/model/timestamp"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/promql/parser/posrange"
@@ -3208,7 +3208,7 @@ func TestQueryStats(t *testing.T) {
 	runQueryAndGetSamplesStats := func(t *testing.T, engine promql.QueryEngine, expr string, isInstantQuery bool) *promstats.QuerySamples {
 		var q promql.Query
 		var err error
-		opts := promql.NewPrometheusQueryOpts(true, 0, validation.LegacyNamingScheme)
+		opts := promql.NewPrometheusQueryOpts(true, 0, model.LegacyValidation)
 		if isInstantQuery {
 			q, err = engine.NewInstantQuery(context.Background(), storage, opts, expr, end)
 		} else {
@@ -3502,7 +3502,7 @@ func TestQueryStatsUpstreamTestCases(t *testing.T) {
 	runQueryAndGetSamplesStats := func(t *testing.T, engine promql.QueryEngine, expr string, start, end time.Time, interval time.Duration) *promstats.QuerySamples {
 		var q promql.Query
 		var err error
-		opts := promql.NewPrometheusQueryOpts(true, 0, validation.LegacyNamingScheme)
+		opts := promql.NewPrometheusQueryOpts(true, 0, model.LegacyValidation)
 
 		if interval == 0 {
 			// Instant query
@@ -3883,7 +3883,7 @@ func TestQueryStatementLookbackDelta(t *testing.T) {
 		require.NoError(t, err)
 
 		t.Run("lookback delta not set in query options", func(t *testing.T) {
-			queryOpts := promql.NewPrometheusQueryOpts(false, 0, validation.LegacyNamingScheme)
+			queryOpts := promql.NewPrometheusQueryOpts(false, 0, model.LegacyValidation)
 			runTest(t, engine, queryOpts, defaultLookbackDelta)
 		})
 
@@ -3892,7 +3892,7 @@ func TestQueryStatementLookbackDelta(t *testing.T) {
 		})
 
 		t.Run("lookback delta set in query options", func(t *testing.T) {
-			queryOpts := promql.NewPrometheusQueryOpts(false, 14*time.Minute, validation.LegacyNamingScheme)
+			queryOpts := promql.NewPrometheusQueryOpts(false, 14*time.Minute, model.LegacyValidation)
 			runTest(t, engine, queryOpts, 14*time.Minute)
 		})
 	})
@@ -3904,7 +3904,7 @@ func TestQueryStatementLookbackDelta(t *testing.T) {
 		require.NoError(t, err)
 
 		t.Run("lookback delta not set in query options", func(t *testing.T) {
-			queryOpts := promql.NewPrometheusQueryOpts(false, 0, validation.LegacyNamingScheme)
+			queryOpts := promql.NewPrometheusQueryOpts(false, 0, model.LegacyValidation)
 			runTest(t, engine, queryOpts, 12*time.Minute)
 		})
 
@@ -3913,7 +3913,7 @@ func TestQueryStatementLookbackDelta(t *testing.T) {
 		})
 
 		t.Run("lookback delta set in query options", func(t *testing.T) {
-			queryOpts := promql.NewPrometheusQueryOpts(false, 14*time.Minute, validation.LegacyNamingScheme)
+			queryOpts := promql.NewPrometheusQueryOpts(false, 14*time.Minute, model.LegacyValidation)
 			runTest(t, engine, queryOpts, 14*time.Minute)
 		})
 	})
diff --git a/pkg/streamingpromql/operators/aggregations/aggregation_test.go b/pkg/streamingpromql/operators/aggregations/aggregation_test.go
@@ -7,10 +7,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/histogram"
 	"github.com/prometheus/prometheus/model/labels"
 	"github.com/prometheus/prometheus/model/timestamp"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/promql/parser/posrange"
@@ -346,7 +346,7 @@ func TestAggregations_ReturnIncompleteGroupsOnEarlyClose(t *testing.T) {
 					false,
 					memoryConsumptionTracker,
 					posrange.PositionRange{},
-					validation.LegacyNamingScheme,
+					model.LegacyValidation,
 				), nil
 			},
 			instant:                       true,
diff --git a/pkg/streamingpromql/operators/aggregations/count_values.go b/pkg/streamingpromql/operators/aggregations/count_values.go
@@ -12,8 +12,8 @@ import (
 	"strconv"
 	"sync"
 
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser/posrange"
 
@@ -40,7 +40,7 @@ type CountValues struct {
 	labelsBytesBuffer []byte
 	valueBuffer       []byte
 
-	nameValidationScheme validation.NamingScheme
+	nameValidationScheme model.ValidationScheme
 }
 
 var _ types.InstantVectorOperator = &CountValues{}
@@ -53,7 +53,7 @@ func NewCountValues(
 	without bool,
 	memoryConsumptionTracker *limiter.MemoryConsumptionTracker,
 	expressionPosition posrange.PositionRange,
-	nameValidationScheme validation.NamingScheme,
+	nameValidationScheme model.ValidationScheme,
 ) *CountValues {
 	if without {
 		grouping = append(grouping, labels.MetricName)
@@ -155,7 +155,7 @@ func (c *CountValues) SeriesMetadata(ctx context.Context) ([]types.SeriesMetadat
 
 func (c *CountValues) loadLabelName() error {
 	c.resolvedLabelName = c.LabelName.GetValue()
-	if !c.nameValidationScheme.IsValidLabelName(c.resolvedLabelName) {
+	if !model.LabelName(c.resolvedLabelName).IsValid(c.nameValidationScheme) {
 		return fmt.Errorf("invalid label name %q", c.resolvedLabelName)
 	}
 
diff --git a/pkg/streamingpromql/operators/aggregations/count_values_test.go b/pkg/streamingpromql/operators/aggregations/count_values_test.go
@@ -6,9 +6,9 @@ import (
 	"context"
 	"testing"
 
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/labels"
 	"github.com/prometheus/prometheus/model/timestamp"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser/posrange"
 	"github.com/stretchr/testify/require"
@@ -50,6 +50,11 @@ func TestCountValues_GroupLabelling(t *testing.T) {
 			inputSeries:          labels.FromStrings(labels.MetricName, "my_metric", "env", "prod", "foo", "bar"),
 			expectedOutputSeries: labels.FromStrings("env", "prod", "value", "123"),
 		},
+		"grouping with 'by', single utf8 grouping label, input does have grouping label": {
+			grouping:             []string{"env😀"},
+			inputSeries:          labels.FromStrings(labels.MetricName, "my_metric", "env😀", "prod", "foo", "bar"),
+			expectedOutputSeries: labels.FromStrings("env😀", "prod", "value", "123"),
+		},
 		"grouping with 'by', multiple grouping labels, input has only metric name": {
 			grouping:             []string{"cluster", "env"},
 			inputSeries:          labels.FromStrings(labels.MetricName, "my_metric"),
@@ -110,6 +115,12 @@ func TestCountValues_GroupLabelling(t *testing.T) {
 			inputSeries:          labels.FromStrings(labels.MetricName, "my_metric", "env", "prod", "a-label", "a-value", "f-label", "f-value"),
 			expectedOutputSeries: labels.FromStrings("a-label", "a-value", "f-label", "f-value", "value", "123"),
 		},
+		"grouping with 'without', single utf8 grouping label, input does have grouping label": {
+			grouping:             []string{"env😀"},
+			without:              true,
+			inputSeries:          labels.FromStrings(labels.MetricName, "my_metric", "env😀", "prod", "a-label", "a-value", "f-label", "f-value"),
+			expectedOutputSeries: labels.FromStrings("a-label", "a-value", "f-label", "f-value", "value", "123"),
+		},
 		"grouping with 'without', multiple grouping labels, input has only metric name": {
 			grouping:             []string{"cluster", "env"},
 			without:              true,
@@ -231,7 +242,7 @@ func TestCountValues_GroupLabelling(t *testing.T) {
 				testCase.without,
 				memoryConsumptionTracker,
 				posrange.PositionRange{},
-				validation.LegacyNamingScheme,
+				model.UTF8Validation,
 			)
 
 			metadata, err := aggregator.SeriesMetadata(context.Background())
diff --git a/pkg/streamingpromql/operators/functions/factories.go b/pkg/streamingpromql/operators/functions/factories.go
@@ -6,7 +6,7 @@ import (
 	"fmt"
 	"math"
 
-	"github.com/prometheus/prometheus/model/validation"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/promql/parser/posrange"
 	"github.com/prometheus/prometheus/util/annotations"
 
@@ -25,7 +25,7 @@ type InstantVectorFunctionOperatorFactory func(
 type InstantVectorFunctionOperatorParams struct {
 	MemoryConsumptionTracker *limiter.MemoryConsumptionTracker
 	Annotations              *annotations.Annotations
-	NameValidationScheme     validation.NamingScheme
+	NameValidationScheme     model.ValidationScheme
 	ExpressionPosition       posrange.PositionRange
 	TimeRange                types.QueryTimeRange
 }
diff --git a/pkg/streamingpromql/operators/functions/label.go b/pkg/streamingpromql/operators/functions/label.go
@@ -11,24 +11,24 @@ import (
 	"strings"
 
 	"github.com/grafana/regexp"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/labels"
-	"github.com/prometheus/prometheus/model/validation"
 
 	"github.com/grafana/mimir/pkg/streamingpromql/types"
 	"github.com/grafana/mimir/pkg/util/limiter"
 )
 
-func LabelJoinFactory(dstLabelOp, separatorOp types.StringOperator, srcLabelOps []types.StringOperator, namingScheme validation.NamingScheme) SeriesMetadataFunction {
+func LabelJoinFactory(dstLabelOp, separatorOp types.StringOperator, srcLabelOps []types.StringOperator, validationScheme model.ValidationScheme) SeriesMetadataFunction {
 	return func(seriesMetadata []types.SeriesMetadata, _ *limiter.MemoryConsumptionTracker) ([]types.SeriesMetadata, error) {
 		dst := dstLabelOp.GetValue()
-		if !namingScheme.IsValidLabelName(dst) {
+		if !model.LabelName(dst).IsValid(validationScheme) {
 			return nil, fmt.Errorf("invalid destination label name in label_join(): %s", dst)
 		}
 		separator := separatorOp.GetValue()
 		srcLabels := make([]string, len(srcLabelOps))
 		for i, op := range srcLabelOps {
 			src := op.GetValue()
-			if !namingScheme.IsValidLabelName(src) {
+			if !model.LabelName(src).IsValid(validationScheme) {
 				return nil, fmt.Errorf("invalid source label name in label_join(): %s", dst)
 			}
 			srcLabels[i] = src
@@ -58,15 +58,15 @@ func LabelJoinFactory(dstLabelOp, separatorOp types.StringOperator, srcLabelOps
 	}
 }
 
-func LabelReplaceFactory(dstLabelOp, replacementOp, srcLabelOp, regexOp types.StringOperator, namingScheme validation.NamingScheme) SeriesMetadataFunction {
+func LabelReplaceFactory(dstLabelOp, replacementOp, srcLabelOp, regexOp types.StringOperator, validationScheme model.ValidationScheme) SeriesMetadataFunction {
 	return func(seriesMetadata []types.SeriesMetadata, _ *limiter.MemoryConsumptionTracker) ([]types.SeriesMetadata, error) {
 		regexStr := regexOp.GetValue()
 		regex, err := regexp.Compile("^(?s:" + regexStr + ")$")
 		if err != nil {
 			return nil, fmt.Errorf("invalid regular expression in label_replace(): %s", regexStr)
 		}
 		dst := dstLabelOp.GetValue()
-		if !namingScheme.IsValidLabelName(dst) {
+		if !model.LabelName(dst).IsValid(validationScheme) {
 			return nil, fmt.Errorf("invalid destination label name in label_replace(): %s", dst)
 		}
 		repl := replacementOp.GetValue()
diff --git a/pkg/streamingpromql/planning.go b/pkg/streamingpromql/planning.go
@@ -16,7 +16,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/timestamp"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
@@ -421,7 +420,7 @@ func isKnownFunction(name string) bool {
 // Materialize converts a query plan into an executable query.
 func (e *Engine) Materialize(ctx context.Context, plan *planning.QueryPlan, queryable storage.Queryable, opts promql.QueryOpts) (promql.Query, error) {
 	if opts == nil {
-		opts = promql.NewPrometheusQueryOpts(false, 0, validation.UTF8NamingScheme)
+		opts = promql.NewPrometheusQueryOpts(false, 0, model.UTF8Validation)
 	}
 
 	queryID, err := e.activeQueryTracker.Insert(ctx, plan.OriginalExpression+" # (materialization)")
diff --git a/pkg/streamingpromql/planning/plan.go b/pkg/streamingpromql/planning/plan.go
@@ -10,8 +10,8 @@ import (
 
 	"github.com/gogo/protobuf/proto"
 	prototypes "github.com/gogo/protobuf/types"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/timestamp"
-	"github.com/prometheus/prometheus/model/validation"
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
 	"github.com/prometheus/prometheus/util/annotations"
@@ -91,7 +91,7 @@ type OperatorParameters struct {
 	Annotations              *annotations.Annotations
 	LookbackDelta            time.Duration
 	EagerLoadSelectors       bool
-	NameValidationScheme     validation.NamingScheme
+	NameValidationScheme     model.ValidationScheme
 }
 
 func (p *QueryPlan) ToEncodedPlan(includeDescriptions bool, includeDetails bool) (*EncodedQueryPlan, error) {
diff --git a/pkg/streamingpromql/query.go b/pkg/streamingpromql/query.go

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ import (`
`7`	`7`	`"time"`
`8`	`8`
`9`	`9`	`"github.com/grafana/dskit/tenant"`
`10`		`- prom_validation "github.com/prometheus/prometheus/model/validation"`
	`10`	`+ "github.com/prometheus/common/model"`
`11`	`11`	`"github.com/prometheus/prometheus/promql"`
`12`	`12`	`"github.com/prometheus/prometheus/storage"`
`13`	`13`
`@@ -25,64 +25,64 @@ func NameValidatingEngine(engine promql.QueryEngine, limits *validation.Override`
`25`	`25`	`return &nameValidatingEngine{engine: engine, limits: limits}`
`26`	`26`	`}`
`27`	`27`
`28`		`-type optsWithNamingScheme struct {`
	`28`	`+type optsWithValidationScheme struct {`
`29`	`29`	`promql.QueryOpts`
`30`		`- namingScheme prom_validation.NamingScheme`
	`30`	`+ validationScheme model.ValidationScheme`
`31`	`31`	`}`
`32`	`32`
`33`		`-func (o optsWithNamingScheme) EnablePerStepStats() bool {`
	`33`	`+func (o optsWithValidationScheme) EnablePerStepStats() bool {`
`34`	`34`	`return o.QueryOpts.EnablePerStepStats()`
`35`	`35`	`}`
`36`	`36`
`37`		`-func (o optsWithNamingScheme) LookbackDelta() time.Duration {`
	`37`	`+func (o optsWithValidationScheme) LookbackDelta() time.Duration {`
`38`	`38`	`return o.QueryOpts.LookbackDelta()`
`39`	`39`	`}`
`40`	`40`
`41`		`-func (o optsWithNamingScheme) NameValidationScheme() prom_validation.NamingScheme {`
`42`		`- return o.namingScheme`
	`41`	`+func (o optsWithValidationScheme) ValidationScheme() model.ValidationScheme {`
	`42`	`+ return o.validationScheme`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`func (e nameValidatingEngine) NewInstantQuery(ctx context.Context, q storage.Queryable, opts promql.QueryOpts, qs string, ts time.Time) (promql.Query, error) {`
`46`		`- namingScheme, err := e.getNamingScheme(ctx)`
	`46`	`+ validationScheme, err := e.getValidationScheme(ctx)`
`47`	`47`	`if err != nil {`
`48`	`48`	`return nil, err`
`49`	`49`	`}`
`50`	`50`	`if opts == nil {`
`51`		`- opts = promql.NewPrometheusQueryOpts(false, 0, prom_validation.UTF8NamingScheme)`
	`51`	`+ opts = promql.NewPrometheusQueryOpts(false, 0, model.UTF8Validation)`
`52`	`52`	`}`
`53`		`- opts = &optsWithNamingScheme{`
`54`		`- QueryOpts: opts,`
`55`		`- namingScheme: namingScheme,`
	`53`	`+ opts = &optsWithValidationScheme{`
	`54`	`+ QueryOpts: opts,`
	`55`	`+ validationScheme: validationScheme,`
`56`	`56`	`}`
`57`	`57`	`return e.engine.NewInstantQuery(ctx, q, opts, qs, ts)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`func (e nameValidatingEngine) NewRangeQuery(ctx context.Context, q storage.Queryable, opts promql.QueryOpts, qs string, start, end time.Time, interval time.Duration) (promql.Query, error) {`
`61`		`- namingScheme, err := e.getNamingScheme(ctx)`
	`61`	`+ validationScheme, err := e.getValidationScheme(ctx)`
`62`	`62`	`if err != nil {`
`63`	`63`	`return nil, err`
`64`	`64`	`}`
`65`	`65`	`if opts == nil {`
`66`		`- opts = promql.NewPrometheusQueryOpts(false, 0, prom_validation.UTF8NamingScheme)`
	`66`	`+ opts = promql.NewPrometheusQueryOpts(false, 0, model.UTF8Validation)`
`67`	`67`	`}`
`68`		`- opts = &optsWithNamingScheme{`
`69`		`- QueryOpts: opts,`
`70`		`- namingScheme: namingScheme,`
	`68`	`+ opts = &optsWithValidationScheme{`
	`69`	`+ QueryOpts: opts,`
	`70`	`+ validationScheme: validationScheme,`
`71`	`71`	`}`
`72`	`72`	`return e.engine.NewRangeQuery(ctx, q, opts, qs, start, end, interval)`
`73`	`73`	`}`
`74`	`74`
`75`		`-// getNamingScheme retrieves the name validation scheme to use from a context containing tenant IDs.`
	`75`	`+// getValidationScheme retrieves the name validation scheme to use from a context containing tenant IDs.`
`76`	`76`	`// Returns legacy validation scheme if at least one tenant uses legacy validation.`
`77`		`-func (e nameValidatingEngine) getNamingScheme(ctx context.Context) (prom_validation.NamingScheme, error) {`
	`77`	`+func (e nameValidatingEngine) getValidationScheme(ctx context.Context) (model.ValidationScheme, error) {`
`78`	`78`	`tenantIDs, err := tenant.TenantIDs(ctx)`
`79`	`79`	`if err != nil {`
`80`		`- return "", err`
	`80`	`+ return model.UnsetValidation, err`
`81`	`81`	`}`
`82`	`82`	`for _, tenantID := range tenantIDs {`
`83`		`- if e.limits.NameValidationScheme(tenantID) == prom_validation.LegacyNamingScheme {`
`84`		`- return prom_validation.LegacyNamingScheme, nil`
	`83`	`+ if e.limits.ValidationScheme(tenantID) == model.LegacyValidation {`
	`84`	`+ return model.LegacyValidation, nil`
`85`	`85`	`}`
`86`	`86`	`}`
`87`		`- return prom_validation.UTF8NamingScheme, nil`
	`87`	`+ return model.UTF8Validation, nil`
`88`	`88`	`}`