Support UTF-8 label matchers: Add compat package with feature flag and use in amtool

cli/alert_add.go

@@ -15,14 +15,18 @@ package cli
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"strconv"
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/go-openapi/strfmt"
 
 	"github.com/prometheus/alertmanager/api/v2/client/alert"
 	"github.com/prometheus/alertmanager/api/v2/models"
+	"github.com/prometheus/alertmanager/matchers/compat"
+	"github.com/prometheus/alertmanager/pkg/labels"
 )
 
 type alertAddCmd struct {
@@ -73,29 +77,45 @@ func (a *alertAddCmd) addAlert(ctx context.Context, _ *kingpin.ParseContext) err
 	if len(a.labels) > 0 {
 		// Allow the alertname label to be defined implicitly as the first argument rather
 		// than explicitly as a key=value pair.
-		if _, err := parseLabels([]string{a.labels[0]}); err != nil {
-			a.labels[0] = fmt.Sprintf("alertname=%s", a.labels[0])
+		if _, err := compat.Matcher(a.labels[0]); err != nil {
+			a.labels[0] = fmt.Sprintf("alertname=%s", strconv.Quote(a.labels[0]))
 		}
 	}
 
-	labels, err := parseLabels(a.labels)
-	if err != nil {
-		return err
+	ls := make(models.LabelSet, len(a.labels))
+	for _, l := range a.labels {
+		matcher, err := compat.Matcher(l)
+		if err != nil {
+			return err
+		}
+		if matcher.Type != labels.MatchEqual {
+			return errors.New("labels must be specified as key=value pairs")
+		}
+		ls[matcher.Name] = matcher.Value
 	}
 
-	annotations, err := parseLabels(a.annotations)
-	if err != nil {
-		return err
+	annotations := make(models.LabelSet, len(a.annotations))
+	for _, a := range a.annotations {
+		matcher, err := compat.Matcher(a)
+		if err != nil {
+			return err
+		}
+		if matcher.Type != labels.MatchEqual {
+			return errors.New("annotations must be specified as key=value pairs")
+		}
+		annotations[matcher.Name] = matcher.Value
 	}
 
 	var startsAt, endsAt time.Time
 	if a.start != "" {
+		var err error
 		startsAt, err = time.Parse(time.RFC3339, a.start)
 		if err != nil {
 			return err
 		}
 	}
 	if a.end != "" {
+		var err error
 		endsAt, err = time.Parse(time.RFC3339, a.end)
 		if err != nil {
 			return err
@@ -105,7 +125,7 @@ func (a *alertAddCmd) addAlert(ctx context.Context, _ *kingpin.ParseContext) err
 	pa := &models.PostableAlert{
 		Alert: models.Alert{
 			GeneratorURL: strfmt.URI(a.generatorURL),
-			Labels:       labels,
+			Labels:       ls,
 		},
 		Annotations: annotations,
 		StartsAt:    strfmt.DateTime(startsAt),
@@ -116,6 +136,6 @@ func (a *alertAddCmd) addAlert(ctx context.Context, _ *kingpin.ParseContext) err
 
 	amclient := NewAlertmanagerClient(alertmanagerURL)
 
-	_, err = amclient.Alert.PostAlerts(alertParams)
+	_, err := amclient.Alert.PostAlerts(alertParams)
 	return err
 }

cli/alert_query.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/prometheus/alertmanager/api/v2/client/alert"
 	"github.com/prometheus/alertmanager/cli/format"
-	"github.com/prometheus/alertmanager/pkg/labels"
+	"github.com/prometheus/alertmanager/matchers/compat"
 )
 
 type alertQueryCmd struct {
@@ -80,7 +80,7 @@ func (a *alertQueryCmd) queryAlerts(ctx context.Context, _ *kingpin.ParseContext
 		// the user wants alertname=<arg> and prepend `alertname=` to
 		// the front.
 		m := a.matcherGroups[0]
-		_, err := labels.ParseMatcher(m)
+		_, err := compat.Matcher(m)
 		if err != nil {
 			a.matcherGroups[0] = fmt.Sprintf("alertname=%s", m)
 		}

cli/root.go

@@ -18,9 +18,13 @@ import (
 	"net/url"
 	"os"
 	"path"
+	"strings"
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/go-kit/log"
+	"github.com/go-kit/log/level"
+	clientruntime "github.com/go-openapi/runtime/client"
 	"github.com/go-openapi/strfmt"
 	promconfig "github.com/prometheus/common/config"
 	"github.com/prometheus/common/version"
@@ -29,8 +33,8 @@ import (
 	"github.com/prometheus/alertmanager/api/v2/client"
 	"github.com/prometheus/alertmanager/cli/config"
 	"github.com/prometheus/alertmanager/cli/format"
-
-	clientruntime "github.com/go-openapi/runtime/client"
+	"github.com/prometheus/alertmanager/featurecontrol"
+	"github.com/prometheus/alertmanager/matchers/compat"
 )
 
 var (
@@ -40,11 +44,27 @@ var (
 	timeout         time.Duration
 	httpConfigFile  string
 	versionCheck    bool
+	featureFlags    string
 
 	configFiles = []string{os.ExpandEnv("$HOME/.config/amtool/config.yml"), "/etc/amtool/config.yml"}
 	legacyFlags = map[string]string{"comment_required": "require-comment"}
 )
 
+func initMatchersCompat(_ *kingpin.ParseContext) error {
+	logger := log.NewLogfmtLogger(os.Stdout)
+	if verbose {
+		logger = level.NewFilter(logger, level.AllowDebug())
+	} else {
+		logger = level.NewFilter(logger, level.AllowInfo())
+	}
+	featureConfig, err := featurecontrol.NewFlags(logger, featureFlags)
+	if err != nil {
+		kingpin.Fatalf("error parsing the feature flag list: %v\n", err)
+	}
+	compat.InitFromFlags(logger, featureConfig)
+	return nil
+}
+
 func requireAlertManagerURL(pc *kingpin.ParseContext) error {
 	// Return without error if any help flag is set.
 	for _, elem := range pc.Elements {
@@ -137,6 +157,7 @@ func Execute() {
 	app.Flag("timeout", "Timeout for the executed command").Default("30s").DurationVar(&timeout)
 	app.Flag("http.config.file", "HTTP client configuration file for amtool to connect to Alertmanager.").PlaceHolder("<filename>").ExistingFileVar(&httpConfigFile)
 	app.Flag("version-check", "Check alertmanager version. Use --no-version-check to disable.").Default("true").BoolVar(&versionCheck)
+	app.Flag("enable-feature", fmt.Sprintf("Experimental features to enable. The flag can be repeated to enable multiple features. Valid options: %s", strings.Join(featurecontrol.AllowedFlags, ", "))).Default("").StringVar(&featureFlags)
 
 	app.Version(version.Print("amtool"))
 	app.GetFlag("help").Short('h')
@@ -154,6 +175,8 @@ func Execute() {
 	configureConfigCmd(app)
 	configureTemplateCmd(app)
 
+	app.Action(initMatchersCompat)
+
 	err = resolver.Bind(app, os.Args[1:])
 	if err != nil {
 		kingpin.Fatalf("%v\n", err)

cli/silence_add.go

@@ -18,6 +18,7 @@ import (
 	"errors"
 	"fmt"
 	"os/user"
+	"strconv"
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
@@ -26,6 +27,8 @@ import (
 
 	"github.com/prometheus/alertmanager/api/v2/client/silence"
 	"github.com/prometheus/alertmanager/api/v2/models"
+	"github.com/prometheus/alertmanager/matchers/compat"
+	"github.com/prometheus/alertmanager/pkg/labels"
 )
 
 func username() string {
@@ -92,17 +95,20 @@ func (c *silenceAddCmd) add(ctx context.Context, _ *kingpin.ParseContext) error
 		// If the parser fails then we likely don't have a (=|=~|!=|!~) so lets
 		// assume that the user wants alertname=<arg> and prepend `alertname=`
 		// to the front.
-		_, err := parseMatchers([]string{c.matchers[0]})
+		_, err := compat.Matcher(c.matchers[0])
 		if err != nil {
-			c.matchers[0] = fmt.Sprintf("alertname=%s", c.matchers[0])
+			c.matchers[0] = fmt.Sprintf("alertname=%s", strconv.Quote(c.matchers[0]))
 		}
 	}
 
-	matchers, err := parseMatchers(c.matchers)
-	if err != nil {
-		return err
+	matchers := make([]labels.Matcher, 0, len(c.matchers))
+	for _, s := range c.matchers {
+		m, err := compat.Matcher(s)
+		if err != nil {
+			return err
+		}
+		matchers = append(matchers, *m)
 	}
-
 	if len(matchers) < 1 {
 		return fmt.Errorf("no matchers specified")
 	}

cli/silence_query.go

@@ -17,14 +17,15 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 	"time"
 
 	kingpin "github.com/alecthomas/kingpin/v2"
 
 	"github.com/prometheus/alertmanager/api/v2/client/silence"
 	"github.com/prometheus/alertmanager/api/v2/models"
 	"github.com/prometheus/alertmanager/cli/format"
-	"github.com/prometheus/alertmanager/pkg/labels"
+	"github.com/prometheus/alertmanager/matchers/compat"
 )
 
 type silenceQueryCmd struct {
@@ -98,9 +99,9 @@ func (c *silenceQueryCmd) query(ctx context.Context, _ *kingpin.ParseContext) er
 		// If the parser fails then we likely don't have a (=|=~|!=|!~) so lets
 		// assume that the user wants alertname=<arg> and prepend `alertname=`
 		// to the front.
-		_, err := labels.ParseMatcher(c.matchers[0])
+		_, err := compat.Matcher(c.matchers[0])
 		if err != nil {
-			c.matchers[0] = fmt.Sprintf("alertname=%s", c.matchers[0])
+			c.matchers[0] = fmt.Sprintf("alertname=%s", strconv.Quote(c.matchers[0]))
 		}
 	}
 

cli/test_routing.go

@@ -24,6 +24,8 @@ import (
 
 	"github.com/prometheus/alertmanager/api/v2/models"
 	"github.com/prometheus/alertmanager/dispatch"
+	"github.com/prometheus/alertmanager/matchers/compat"
+	"github.com/prometheus/alertmanager/pkg/labels"
 )
 
 const routingTestHelp = `Test alert routing
@@ -80,9 +82,16 @@ func (c *routingShow) routingTestAction(ctx context.Context, _ *kingpin.ParseCon
 	mainRoute := dispatch.NewRoute(cfg.Route, nil)
 
 	// Parse labels to LabelSet.
-	ls, err := parseLabels(c.labels)
-	if err != nil {
-		kingpin.Fatalf("Failed to parse labels: %v\n", err)
+	ls := make(models.LabelSet, len(c.labels))
+	for _, l := range c.labels {
+		matcher, err := compat.Matcher(l)
+		if err != nil {
+			kingpin.Fatalf("Failed to parse labels: %v\n", err)
+		}
+		if matcher.Type != labels.MatchEqual {
+			kingpin.Fatalf("%s\n", "Labels must be specified as key=value pairs")
+		}
+		ls[matcher.Name] = matcher.Value
 	}
 
 	if c.debugTree {

cli/utils.go

@@ -20,7 +20,7 @@ import (
 	"net/url"
 	"os"
 
-	kingpin "github.com/alecthomas/kingpin/v2"
+	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus/common/model"
 
 	"github.com/prometheus/alertmanager/api/v2/client/general"
@@ -29,22 +29,6 @@ import (
 	"github.com/prometheus/alertmanager/pkg/labels"
 )
 
-// parseMatchers parses a list of matchers (cli arguments).
-func parseMatchers(inputMatchers []string) ([]labels.Matcher, error) {
-	matchers := make([]labels.Matcher, 0, len(inputMatchers))
-
-	for _, v := range inputMatchers {
-		matcher, err := labels.ParseMatcher(v)
-		if err != nil {
-			return []labels.Matcher{}, err
-		}
-
-		matchers = append(matchers, *matcher)
-	}
-
-	return matchers, nil
-}
-
 // getRemoteAlertmanagerConfigStatus returns status responsecontaining configuration from remote Alertmanager
 func getRemoteAlertmanagerConfigStatus(ctx context.Context, alertmanagerURL *url.URL) (*models.AlertmanagerStatus, error) {
 	amclient := NewAlertmanagerClient(alertmanagerURL)
@@ -94,25 +78,6 @@ func convertClientToCommonLabelSet(cls models.LabelSet) model.LabelSet {
 	return mls
 }
 
-// parseLabels parses a list of labels (cli arguments).
-func parseLabels(inputLabels []string) (models.LabelSet, error) {
-	labelSet := make(models.LabelSet, len(inputLabels))
-
-	for _, l := range inputLabels {
-		matcher, err := labels.ParseMatcher(l)
-		if err != nil {
-			return models.LabelSet{}, err
-		}
-		if matcher.Type != labels.MatchEqual {
-			return models.LabelSet{}, errors.New("labels must be specified as key=value pairs")
-		}
-
-		labelSet[matcher.Name] = matcher.Value
-	}
-
-	return labelSet, nil
-}
-
 // TypeMatchers only valid for when you are going to add a silence
 func TypeMatchers(matchers []labels.Matcher) models.Matchers {
 	typeMatchers := make(models.Matchers, len(matchers))