Rename stable to classic

Signed-off-by: George Robinson <[email protected]>

featurecontrol/featurecontrol.go

@@ -23,36 +23,36 @@ import (
 )
 
 const (
-	fcReceiverNameInMetrics = "receiver-name-in-metrics"
-	fcStableMatchersParsing = "stable-matchers-parsing"
-	fcUTF8MatchersParsing   = "utf8-matchers-parsing"
+	fcReceiverNameInMetrics  = "receiver-name-in-metrics"
+	fcClassicMatchersParsing = "classic-matchers-parsing"
+	fcUTF8MatchersParsing    = "utf8-matchers-parsing"
 )
 
 var AllowedFlags = []string{
 	fcReceiverNameInMetrics,
-	fcStableMatchersParsing,
+	fcClassicMatchersParsing,
 	fcUTF8MatchersParsing,
 }
 
 type Flagger interface {
 	EnableReceiverNamesInMetrics() bool
-	StableMatchersParsing() bool
+	ClassicMatchersParsing() bool
 	UTF8MatchersParsing() bool
 }
 
 type Flags struct {
 	logger                       log.Logger
 	enableReceiverNamesInMetrics bool
+	classicMatchersParsing       bool
 	utf8MatchersParsing          bool
-	stableMatchersParsing        bool
 }
 
 func (f *Flags) EnableReceiverNamesInMetrics() bool {
 	return f.enableReceiverNamesInMetrics
 }
 
-func (f *Flags) StableMatchersParsing() bool {
-	return f.stableMatchersParsing
+func (f *Flags) ClassicMatchersParsing() bool {
+	return f.classicMatchersParsing
 }
 
 func (f *Flags) UTF8MatchersParsing() bool {
@@ -67,9 +67,9 @@ func enableReceiverNameInMetrics() flagOption {
 	}
 }
 
-func enableStableMatchersParsing() flagOption {
+func enableClassicMatchersParsing() flagOption {
 	return func(configs *Flags) {
-		configs.stableMatchersParsing = true
+		configs.classicMatchersParsing = true
 	}
 }
 
@@ -92,9 +92,9 @@ func NewFlags(logger log.Logger, features string) (Flagger, error) {
 		case fcReceiverNameInMetrics:
 			opts = append(opts, enableReceiverNameInMetrics())
 			level.Warn(logger).Log("msg", "Experimental receiver name in metrics enabled")
-		case fcStableMatchersParsing:
-			opts = append(opts, enableStableMatchersParsing())
-			level.Warn(logger).Log("msg", "Stable matchers parsing enabled")
+		case fcClassicMatchersParsing:
+			opts = append(opts, enableClassicMatchersParsing())
+			level.Warn(logger).Log("msg", "Classic matchers parsing enabled")
 		case fcUTF8MatchersParsing:
 			opts = append(opts, enableUTF8MatchersParsing())
 			level.Warn(logger).Log("msg", "UTF-8 matchers parsing enabled")
@@ -107,8 +107,8 @@ func NewFlags(logger log.Logger, features string) (Flagger, error) {
 		opt(fc)
 	}
 
-	if fc.stableMatchersParsing && fc.utf8MatchersParsing {
-		return nil, errors.New("Both stable and UTF-8 matchers parsing is enabled, please choose one or remove the flag for both")
+	if fc.classicMatchersParsing && fc.utf8MatchersParsing {
+		return nil, errors.New("Both classic and UTF-8 matchers parsing is enabled, please choose one or remove the flag for both")
 	}
 
 	return fc, nil
@@ -118,6 +118,6 @@ type NoopFlags struct{}
 
 func (n NoopFlags) EnableReceiverNamesInMetrics() bool { return false }
 
-func (n NoopFlags) StableMatchersParsing() bool { return false }
+func (n NoopFlags) ClassicMatchersParsing() bool { return false }
 
 func (n NoopFlags) UTF8MatchersParsing() bool { return false }

matchers/compat/parse.go

@@ -26,8 +26,8 @@ import (
 )
 
 var (
-	parseMatcher  = stableMatcherParser(log.NewNopLogger())
-	parseMatchers = stableMatchersParser(log.NewNopLogger())
+	parseMatcher  = classicMatcherParser(log.NewNopLogger())
+	parseMatchers = classicMatchersParser(log.NewNopLogger())
 )
 
 type matcherParser func(s string) (*labels.Matcher, error)
@@ -48,9 +48,9 @@ func Matchers(s string) (labels.Matchers, error) {
 
 // InitFromFlags initializes the compat package from the flagger.
 func InitFromFlags(l log.Logger, f featurecontrol.Flagger) {
-	if f.StableMatchersParsing() {
-		parseMatcher = stableMatcherParser(l)
-		parseMatchers = stableMatchersParser(l)
+	if f.ClassicMatchersParsing() {
+		parseMatcher = classicMatcherParser(l)
+		parseMatchers = classicMatchersParser(l)
 	} else if f.UTF8MatchersParsing() {
 		parseMatcher = utf8MatcherParser(l)
 		parseMatchers = utf8MatchersParser(l)
@@ -60,20 +60,20 @@ func InitFromFlags(l log.Logger, f featurecontrol.Flagger) {
 	}
 }
 
-// stableMatcherParser uses the old pkg/labels parser to parse the matcher in
+// classicMatcherParser uses the old pkg/labels parser to parse the matcher in
 // the input string.
-func stableMatcherParser(l log.Logger) matcherParser {
+func classicMatcherParser(l log.Logger) matcherParser {
 	return func(s string) (*labels.Matcher, error) {
-		level.Debug(l).Log("msg", "Parsing with stable matchers parser", "input", s)
+		level.Debug(l).Log("msg", "Parsing with classic matchers parser", "input", s)
 		return labels.ParseMatcher(s)
 	}
 }
 
-// stableMatchersParser uses the old pkg/labels parser to parse zero or more
+// classicMatchersParser uses the old pkg/labels parser to parse zero or more
 // matchers in the input string. It returns an error if the input is invalid.
-func stableMatchersParser(l log.Logger) matchersParser {
+func classicMatchersParser(l log.Logger) matchersParser {
 	return func(s string) (labels.Matchers, error) {
-		level.Debug(l).Log("msg", "Parsing with stable matchers parser", "input", s)
+		level.Debug(l).Log("msg", "Parsing with classic matchers parser", "input", s)
 		return labels.ParseMatchers(s)
 	}
 }
@@ -111,7 +111,7 @@ func fallbackMatcherParser(l log.Logger) matcherParser {
 			err        error
 			invalidErr error
 		)
-		level.Debug(l).Log("msg", "Parsing with UTF-8 matchers parser, with fallback to stable matchers parser", "input", s)
+		level.Debug(l).Log("msg", "Parsing with UTF-8 matchers parser, with fallback to classic matchers parser", "input", s)
 		if strings.HasPrefix(s, "{") || strings.HasSuffix(s, "}") {
 			return nil, fmt.Errorf("unexpected open or close brace: %s", s)
 		}
@@ -142,7 +142,7 @@ func fallbackMatchersParser(l log.Logger) matchersParser {
 			err        error
 			invalidErr error
 		)
-		level.Debug(l).Log("msg", "Parsing with UTF-8 matchers parser, with fallback to stable matchers parser", "input", s)
+		level.Debug(l).Log("msg", "Parsing with UTF-8 matchers parser, with fallback to classic matchers parser", "input", s)
 		m, err = parse.Matchers(s)
 		if err != nil {
 			m, invalidErr = labels.ParseMatchers(s)