Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 alert.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "github.com/alecthomas/kingpin/v2" ) func configureAlertCmd(app *kingpin.Application) { alertCmd := app.Command("alert", "Add or query alerts.").PreAction(requireAlertManagerURL) configureQueryAlertsCmd(alertCmd) configureAddAlertCmd(alertCmd) }	859 B	2025-05-25 12:27
📄 alert_add.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. 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/matcher/compat" "github.com/prometheus/alertmanager/pkg/labels" ) type alertAddCmd struct { annotations []string generatorURL string labels []string start string end string } const alertAddHelp = `Add a new alert. This command is used to add a new alert to Alertmanager. To add a new alert with labels: amtool alert add alertname=foo node=bar If alertname is omitted and the first argument does not contain a '=' then it will be assumed to be the value of the alertname pair. amtool alert add foo node=bar One or more annotations can be added using the --annotation flag: amtool alert add foo node=bar \ --annotation=runbook='http://runbook.biz' \ --annotation=summary='summary of the alert' \ --annotation=description='description of the alert' Additional flags such as --generator-url, --start, and --end are also supported. ` func configureAddAlertCmd(cc kingpin.CmdClause) { var ( a = &alertAddCmd{} addCmd = cc.Command("add", alertAddHelp) ) addCmd.Arg("labels", "List of labels to be included with the alert").StringsVar(&a.labels) addCmd.Flag("generator-url", "Set the URL of the source that generated the alert").StringVar(&a.generatorURL) addCmd.Flag("start", "Set when the alert should start. RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&a.start) addCmd.Flag("end", "Set when the alert should end. RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&a.end) addCmd.Flag("annotation", "Set an annotation to be included with the alert").StringsVar(&a.annotations) addCmd.Action(execWithTimeout(a.addAlert)) } func (a alertAddCmd) addAlert(ctx context.Context, _ *kingpin.ParseContext) error { 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 := compat.Matcher(a.labels[0], "cli"); err != nil { a.labels[0] = fmt.Sprintf("alertname=%s", strconv.Quote(a.labels[0])) } } ls := make(models.LabelSet, len(a.labels)) for _, l := range a.labels { matcher, err := compat.Matcher(l, "cli") 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 := make(models.LabelSet, len(a.annotations)) for _, a := range a.annotations { matcher, err := compat.Matcher(a, "cli") 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 } } pa := &models.PostableAlert{ Alert: models.Alert{ GeneratorURL: strfmt.URI(a.generatorURL), Labels: ls, }, Annotations: annotations, StartsAt: strfmt.DateTime(startsAt), EndsAt: strfmt.DateTime(endsAt), } alertParams := alert.NewPostAlertsParams().WithContext(ctx). WithAlerts(models.PostableAlerts{pa}) amclient := NewAlertmanagerClient(alertmanagerURL) _, err := amclient.Alert.PostAlerts(alertParams) return err }	4.13 KB	2025-05-25 12:27
📄 alert_query.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "fmt" "strconv" "github.com/alecthomas/kingpin/v2" "github.com/prometheus/alertmanager/api/v2/client/alert" "github.com/prometheus/alertmanager/cli/format" "github.com/prometheus/alertmanager/matcher/compat" ) type alertQueryCmd struct { inhibited, silenced, active, unprocessed bool receiver string matcherGroups []string } const alertQueryHelp = `View and search through current alerts. Amtool has a simplified prometheus query syntax, but contains robust support for bash variable expansions. The non-option section of arguments constructs a list of "Matcher Groups" that will be used to filter your query. The following examples will attempt to show this behaviour in action: amtool alert query alertname=foo node=bar This query will match all alerts with the alertname=foo and node=bar label value pairs set. amtool alert query foo node=bar If alertname is omitted and the first argument does not contain a '=' or a '=~' then it will be assumed to be the value of the alertname pair. amtool alert query 'alertname=~foo.' As well as direct equality, regex matching is also supported. The '=~' syntax (similar to prometheus) is used to represent a regex match. Regex matching can be used in combination with a direct match. Amtool supports several flags for filtering the returned alerts by state (inhibited, silenced, active, unprocessed). If none of these flags is given, only active alerts are returned. ` func configureQueryAlertsCmd(cc kingpin.CmdClause) { var ( a = &alertQueryCmd{} queryCmd = cc.Command("query", alertQueryHelp).Default() ) queryCmd.Flag("inhibited", "Show inhibited alerts").Short('i').BoolVar(&a.inhibited) queryCmd.Flag("silenced", "Show silenced alerts").Short('s').BoolVar(&a.silenced) queryCmd.Flag("active", "Show active alerts").Short('a').BoolVar(&a.active) queryCmd.Flag("unprocessed", "Show unprocessed alerts").Short('u').BoolVar(&a.unprocessed) queryCmd.Flag("receiver", "Show alerts matching receiver (Supports regex syntax)").Short('r').StringVar(&a.receiver) queryCmd.Arg("matcher-groups", "Query filter").StringsVar(&a.matcherGroups) queryCmd.Action(execWithTimeout(a.queryAlerts)) } func (a alertQueryCmd) queryAlerts(ctx context.Context, _ kingpin.ParseContext) error { if len(a.matcherGroups) > 0 { // Attempt to parse the first argument. 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. m := a.matcherGroups[0] _, err := compat.Matcher(m, "cli") if err != nil { a.matcherGroups[0] = fmt.Sprintf("alertname=%s", strconv.Quote(m)) } } // If no selector was passed, default to showing active alerts. if !a.silenced && !a.inhibited && !a.active && !a.unprocessed { a.active = true } alertParams := alert.NewGetAlertsParams().WithContext(ctx). WithActive(&a.active). WithInhibited(&a.inhibited). WithSilenced(&a.silenced). WithUnprocessed(&a.unprocessed). WithReceiver(&a.receiver). WithFilter(a.matcherGroups) amclient := NewAlertmanagerClient(alertmanagerURL) getOk, err := amclient.Alert.GetAlerts(alertParams) if err != nil { return err } formatter, found := format.Formatters[output] if !found { return errors.New("unknown output formatter") } return formatter.FormatAlerts(getOk.Payload) }	3.95 KB	2025-05-25 12:27
📄 check_config.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "fmt" "os" "github.com/alecthomas/kingpin/v2" "github.com/prometheus/alertmanager/config" "github.com/prometheus/alertmanager/template" ) // TODO: This can just be a type that is []string, doesn't have to be a struct. type checkConfigCmd struct { files []string } const checkConfigHelp = `Validate alertmanager config files Will validate the syntax and schema for alertmanager config file and associated templates. Non existing templates will not trigger errors. ` func configureCheckConfigCmd(app kingpin.Application) { var ( c = &checkConfigCmd{} checkCmd = app.Command("check-config", checkConfigHelp) ) checkCmd.Arg("check-files", "Files to be validated").ExistingFilesVar(&c.files) checkCmd.Action(c.checkConfig) } func (c checkConfigCmd) checkConfig(ctx *kingpin.ParseContext) error { return CheckConfig(c.files) } func CheckConfig(args []string) error { if len(args) == 0 { stat, err := os.Stdin.Stat() if err != nil { kingpin.Fatalf("Failed to stat standard input: %v", err) } if (stat.Mode() & os.ModeCharDevice) != 0 { kingpin.Fatalf("Failed to read from standard input") } args = []string{os.Stdin.Name()} } failed := 0 for _, arg := range args { fmt.Printf("Checking '%s'", arg) cfg, err := config.LoadFile(arg) if err != nil { fmt.Printf(" FAILED: %s\n", err) failed++ } else { fmt.Printf(" SUCCESS\n") } if cfg != nil { fmt.Println("Found:") if cfg.Global != nil { fmt.Println(" - global config") } if cfg.Route != nil { fmt.Println(" - route") } fmt.Printf(" - %d inhibit rules\n", len(cfg.InhibitRules)) fmt.Printf(" - %d receivers\n", len(cfg.Receivers)) fmt.Printf(" - %d templates\n", len(cfg.Templates)) if len(cfg.Templates) > 0 { _, err = template.FromGlobs(cfg.Templates) if err != nil { fmt.Printf(" FAILED: %s\n", err) failed++ } else { fmt.Printf(" SUCCESS\n") } } } fmt.Printf("\n") } if failed > 0 { return fmt.Errorf("failed to validate %d file(s)", failed) } return nil }	2.61 KB	2025-05-25 12:27
📄 check_config_test.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "testing" ) func TestCheckConfig(t *testing.T) { err := CheckConfig([]string{"testdata/conf.good.yml"}) if err != nil { t.Fatalf("checking valid config file failed with: %v", err) } err = CheckConfig([]string{"testdata/conf.bad.yml"}) if err == nil { t.Fatalf("failed to detect invalid file.") } }	919 B	2025-05-25 12:27
📄 cluster.go // Copyright 2020 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "github.com/alecthomas/kingpin/v2" "github.com/prometheus/alertmanager/cli/format" ) const clusterHelp = `View cluster status and peers.` // configureClusterCmd represents the cluster command. func configureClusterCmd(app kingpin.Application) { clusterCmd := app.Command("cluster", clusterHelp) clusterCmd.Command("show", clusterHelp).Default().Action(execWithTimeout(showStatus)).PreAction(requireAlertManagerURL) } func showStatus(ctx context.Context, _ kingpin.ParseContext) error { alertManagerStatus, err := getRemoteAlertmanagerConfigStatus(ctx, alertmanagerURL) if err != nil { return err } formatter, found := format.Formatters[output] if !found { return errors.New("unknown output formatter") } return formatter.FormatClusterStatus(alertManagerStatus.Cluster) }	1.39 KB	2025-05-25 12:27
📁 config	-	2025-05-25 12:27
📄 config.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" kingpin "github.com/alecthomas/kingpin/v2" "github.com/prometheus/alertmanager/cli/format" ) const configHelp = `View current config. The amount of output is controlled by the output selection flag: - Simple: Print just the running config - Extended: Print the running config as well as uptime and all version info - Json: Print entire config object as json ` // configureConfigCmd represents the config command. func configureConfigCmd(app kingpin.Application) { configCmd := app.Command("config", configHelp) configCmd.Command("show", configHelp).Default().Action(execWithTimeout(queryConfig)).PreAction(requireAlertManagerURL) configureRoutingCmd(configCmd) } func queryConfig(ctx context.Context, _ kingpin.ParseContext) error { status, err := getRemoteAlertmanagerConfigStatus(ctx, alertmanagerURL) if err != nil { return err } formatter, found := format.Formatters[output] if !found { return errors.New("unknown output formatter") } return formatter.FormatConfig(status) }	1.6 KB	2025-05-25 12:27
📁 format	-	2025-05-25 12:27
📄 root.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "fmt" "net/url" "os" "path" "strings" "time" "github.com/alecthomas/kingpin/v2" clientruntime "github.com/go-openapi/runtime/client" "github.com/go-openapi/strfmt" promconfig "github.com/prometheus/common/config" "github.com/prometheus/common/promslog" "github.com/prometheus/common/version" "golang.org/x/mod/semver" "github.com/prometheus/alertmanager/api/v2/client" "github.com/prometheus/alertmanager/cli/config" "github.com/prometheus/alertmanager/cli/format" "github.com/prometheus/alertmanager/featurecontrol" "github.com/prometheus/alertmanager/matcher/compat" ) var ( verbose bool alertmanagerURL url.URL output string 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 { promslogConfig := &promslog.Config{Writer: os.Stdout} if verbose { promslogConfig.Level = &promslog.AllowedLevel{} _ = promslogConfig.Level.Set("debug") } logger := promslog.New(promslogConfig) 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 { f, ok := elem.Clause.(kingpin.FlagClause) if !ok { continue } name := f.Model().Name if name == "help" \|\| name == "help-long" \|\| name == "help-man" { return nil } } if alertmanagerURL == nil { kingpin.Fatalf("required flag --alertmanager.url not provided") } return nil } const ( defaultAmHost = "localhost" defaultAmPort = "9093" defaultAmApiv2path = "/api/v2" ) // NewAlertmanagerClient initializes an alertmanager client with the given URL. func NewAlertmanagerClient(amURL url.URL) client.AlertmanagerAPI { address := defaultAmHost + ":" + defaultAmPort schemes := []string{"http"} if amURL.Host != "" { address = amURL.Host // URL documents host as host or host:port } if amURL.Scheme != "" { schemes = []string{amURL.Scheme} } cr := clientruntime.New(address, path.Join(amURL.Path, defaultAmApiv2path), schemes) if amURL.User != nil && httpConfigFile != "" { kingpin.Fatalf("basic authentication and http.config.file are mutually exclusive") } if amURL.User != nil { password, _ := amURL.User.Password() cr.DefaultAuthentication = clientruntime.BasicAuth(amURL.User.Username(), password) } if httpConfigFile != "" { var err error httpConfig, _, err := promconfig.LoadHTTPConfigFile(httpConfigFile) if err != nil { kingpin.Fatalf("failed to load HTTP config file: %v", err) } httpclient, err := promconfig.NewClientFromConfig(httpConfig, "amtool") if err != nil { kingpin.Fatalf("failed to create a new HTTP client: %v", err) } cr = clientruntime.NewWithClient(address, path.Join(amURL.Path, defaultAmApiv2path), schemes, httpclient) } c := client.New(cr, strfmt.Default) if !versionCheck { return c } status, err := c.General.GetStatus(nil) if err != nil \|\| status.Payload.VersionInfo == nil \|\| version.Version == "" { // We can not get version info, or we do not know our own version. Let amtool continue. return c } if semver.MajorMinor("v"+status.Payload.VersionInfo.Version) != semver.MajorMinor("v"+version.Version) { fmt.Fprintf(os.Stderr, "Warning: amtool version (%s) and alertmanager version (%s) are different.\n", version.Version, *status.Payload.VersionInfo.Version) } return c } // Execute is the main function for the amtool command. func Execute() { app := kingpin.New("amtool", helpRoot).UsageWriter(os.Stdout) format.InitFormatFlags(app) app.Flag("verbose", "Verbose running information").Short('v').BoolVar(&verbose) app.Flag("alertmanager.url", "Alertmanager to talk to").URLVar(&alertmanagerURL) app.Flag("output", "Output formatter (simple, extended, json)").Short('o').Default("simple").EnumVar(&output, "simple", "extended", "json") 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, comma separated. Valid options: %s", strings.Join(featurecontrol.AllowedFlags, ", "))).Default("").StringVar(&featureFlags) app.Version(version.Print("amtool")) app.GetFlag("help").Short('h') app.UsageTemplate(kingpin.CompactUsageTemplate) resolver, err := config.NewResolver(configFiles, legacyFlags) if err != nil { kingpin.Fatalf("could not load config file: %v\n", err) } configureAlertCmd(app) configureSilenceCmd(app) configureCheckConfigCmd(app) configureClusterCmd(app) configureConfigCmd(app) configureTemplateCmd(app) app.Action(initMatchersCompat) err = resolver.Bind(app, os.Args[1:]) if err != nil { kingpin.Fatalf("%v\n", err) } _, err = app.Parse(os.Args[1:]) if err != nil { kingpin.Fatalf("%v\n", err) } } const ( helpRoot = `View and modify the current Alertmanager state. Config File: The alertmanager tool will read a config file in YAML format from one of two default config locations: $HOME/.config/amtool/config.yml or /etc/amtool/config.yml All flags can be given in the config file, but the following are the suited for static configuration: alertmanager.url Set a default alertmanager url for each request author Set a default author value for new silences. If this argument is not specified then the username will be used require-comment Bool, whether to require a comment on silence creation. Defaults to true output Set a default output type. Options are (simple, extended, json) date.format Sets the output format for dates. Defaults to "2006-01-02 15:04:05 MST" http.config.file HTTP client configuration file for amtool to connect to Alertmanager. The format is https://prometheus.io/docs/alerting/latest/configuration/#http_config. ` )	6.89 KB	2025-05-25 12:27
📄 routing.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "bytes" "context" "fmt" "github.com/alecthomas/kingpin/v2" "github.com/xlab/treeprint" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/dispatch" ) type routingShow struct { configFile string labels []string expectedReceivers string debugTree bool } const ( routingHelp = `Prints alert routing tree Will print whole routing tree in form of ASCII tree view. Routing is loaded from a local configuration file or a running Alertmanager configuration. Specifying --config.file takes precedence over --alertmanager.url. Example: ./amtool config routes [show] --config.file=doc/examples/simple.yml ` branchSlugSeparator = " " ) func configureRoutingCmd(app kingpin.CmdClause) { var ( c = &routingShow{} routingCmd = app.Command("routes", routingHelp) routingShowCmd = routingCmd.Command("show", routingHelp).Default() configFlag = routingCmd.Flag("config.file", "Config file to be tested.") ) configFlag.ExistingFileVar(&c.configFile) routingShowCmd.Action(execWithTimeout(c.routingShowAction)) configureRoutingTestCmd(routingCmd, c) } func (c routingShow) routingShowAction(ctx context.Context, _ kingpin.ParseContext) error { // Load configuration from file or URL. cfg, err := loadAlertmanagerConfig(ctx, alertmanagerURL, c.configFile) if err != nil { kingpin.Fatalf("%s", err) return err } route := dispatch.NewRoute(cfg.Route, nil) tree := treeprint.New() convertRouteToTree(route, tree) fmt.Println("Routing tree:") fmt.Println(tree.String()) return nil } func getRouteTreeSlug(route dispatch.Route, showContinue, showReceiver bool) string { var branchSlug bytes.Buffer if route.Matchers.Len() == 0 { branchSlug.WriteString("default-route") } else { branchSlug.WriteString(route.Matchers.String()) } if route.Continue && showContinue { branchSlug.WriteString(branchSlugSeparator) branchSlug.WriteString("continue: true") } if showReceiver { branchSlug.WriteString(branchSlugSeparator) branchSlug.WriteString("receiver: ") branchSlug.WriteString(route.RouteOpts.Receiver) } return branchSlug.String() } func convertRouteToTree(route dispatch.Route, tree treeprint.Tree) { branch := tree.AddBranch(getRouteTreeSlug(route, true, true)) for _, r := range route.Routes { convertRouteToTree(r, branch) } } func getMatchingTree(route dispatch.Route, tree treeprint.Tree, lset models.LabelSet) { final := true branch := tree.AddBranch(getRouteTreeSlug(route, false, false)) for _, r := range route.Routes { if r.Matchers.Matches(convertClientToCommonLabelSet(lset)) { getMatchingTree(r, branch, lset) final = false if !r.Continue { break } } } if final { branch.SetValue(getRouteTreeSlug(route, false, true)) } }	3.33 KB	2025-05-25 12:27
📄 silence.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "github.com/alecthomas/kingpin/v2" ) // configureSilenceCmd represents the silence command. func configureSilenceCmd(app *kingpin.Application) { silenceCmd := app.Command("silence", "Add, expire or view silences. For more information and additional flags see query help").PreAction(requireAlertManagerURL) configureSilenceAddCmd(silenceCmd) configureSilenceExpireCmd(silenceCmd) configureSilenceImportCmd(silenceCmd) configureSilenceQueryCmd(silenceCmd) configureSilenceUpdateCmd(silenceCmd) }	1.08 KB	2025-05-25 12:27
📄 silence_add.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "fmt" "os/user" "strconv" "time" "github.com/alecthomas/kingpin/v2" "github.com/go-openapi/strfmt" "github.com/prometheus/common/model" "github.com/prometheus/alertmanager/api/v2/client/silence" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/matcher/compat" "github.com/prometheus/alertmanager/pkg/labels" ) func username() string { user, err := user.Current() if err != nil { return "" } return user.Username } type silenceAddCmd struct { author string requireComment bool duration string start string end string comment string matchers []string } const silenceAddHelp = `Add a new alertmanager silence Amtool uses a simplified Prometheus syntax to represent silences. The non-option section of arguments constructs a list of "Matcher Groups" that will be used to create a number of silences. The following examples will attempt to show this behaviour in action: amtool silence add alertname=foo node=bar This statement will add a silence that matches alerts with the alertname=foo and node=bar label value pairs set. amtool silence add foo node=bar If alertname is omitted and the first argument does not contain a '=' or a '=~' then it will be assumed to be the value of the alertname pair. amtool silence add 'alertname=~foo.' As well as direct equality, regex matching is also supported. The '=~' syntax (similar to Prometheus) is used to represent a regex match. Regex matching can be used in combination with a direct match. ` func configureSilenceAddCmd(cc kingpin.CmdClause) { var ( c = &silenceAddCmd{} addCmd = cc.Command("add", silenceAddHelp) ) addCmd.Flag("author", "Username for CreatedBy field").Short('a').Default(username()).StringVar(&c.author) addCmd.Flag("require-comment", "Require comment to be set").Hidden().Default("true").BoolVar(&c.requireComment) addCmd.Flag("duration", "Duration of silence").Short('d').Default("1h").StringVar(&c.duration) addCmd.Flag("start", "Set when the silence should start. RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&c.start) addCmd.Flag("end", "Set when the silence should end (overwrites duration). RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&c.end) addCmd.Flag("comment", "A comment to help describe the silence").Short('c').StringVar(&c.comment) addCmd.Arg("matcher-groups", "Query filter").StringsVar(&c.matchers) addCmd.Action(execWithTimeout(c.add)) } func (c silenceAddCmd) add(ctx context.Context, _ kingpin.ParseContext) error { var err error if len(c.matchers) > 0 { // 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 := compat.Matcher(c.matchers[0], "cli") if err != nil { c.matchers[0] = fmt.Sprintf("alertname=%s", strconv.Quote(c.matchers[0])) } } matchers := make([]labels.Matcher, 0, len(c.matchers)) for _, s := range c.matchers { m, err := compat.Matcher(s, "cli") if err != nil { return err } matchers = append(matchers, *m) } if len(matchers) < 1 { return fmt.Errorf("no matchers specified") } var startsAt time.Time if c.start != "" { startsAt, err = time.Parse(time.RFC3339, c.start) if err != nil { return err } } else { startsAt = time.Now().UTC() } var endsAt time.Time if c.end != "" { endsAt, err = time.Parse(time.RFC3339, c.end) if err != nil { return err } } else { d, err := model.ParseDuration(c.duration) if err != nil { return err } if d == 0 { return fmt.Errorf("silence duration must be greater than 0") } endsAt = startsAt.UTC().Add(time.Duration(d)) } if startsAt.After(endsAt) { return errors.New("silence cannot start after it ends") } if c.requireComment && c.comment == "" { return errors.New("comment required by config") } start := strfmt.DateTime(startsAt) end := strfmt.DateTime(endsAt) ps := &models.PostableSilence{ Silence: models.Silence{ Matchers: TypeMatchers(matchers), StartsAt: &start, EndsAt: &end, CreatedBy: &c.author, Comment: &c.comment, }, } silenceParams := silence.NewPostSilencesParams().WithContext(ctx). WithSilence(ps) amclient := NewAlertmanagerClient(alertmanagerURL) postOk, err := amclient.Silence.PostSilences(silenceParams) if err != nil { return err } _, err = fmt.Println(postOk.Payload.SilenceID) return err }	5 KB	2025-05-25 12:27
📄 silence_expire.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "github.com/alecthomas/kingpin/v2" "github.com/go-openapi/strfmt" "github.com/prometheus/alertmanager/api/v2/client/silence" ) type silenceExpireCmd struct { ids []string } func configureSilenceExpireCmd(cc kingpin.CmdClause) { var ( c = &silenceExpireCmd{} expireCmd = cc.Command("expire", "expire an alertmanager silence") ) expireCmd.Arg("silence-ids", "Ids of silences to expire").StringsVar(&c.ids) expireCmd.Action(execWithTimeout(c.expire)) } func (c silenceExpireCmd) expire(ctx context.Context, _ *kingpin.ParseContext) error { if len(c.ids) < 1 { return errors.New("no silence IDs specified") } amclient := NewAlertmanagerClient(alertmanagerURL) for _, id := range c.ids { params := silence.NewDeleteSilenceParams().WithContext(ctx) params.SilenceID = strfmt.UUID(id) _, err := amclient.Silence.DeleteSilence(params) if err != nil { return err } } return nil }	1.51 KB	2025-05-25 12:27
📄 silence_import.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "encoding/json" "errors" "fmt" "os" "sync" kingpin "github.com/alecthomas/kingpin/v2" "github.com/prometheus/alertmanager/api/v2/client/silence" "github.com/prometheus/alertmanager/api/v2/models" ) type silenceImportCmd struct { force bool workers int file string } const silenceImportHelp = `Import alertmanager silences from JSON file or stdin This command can be used to bulk import silences from a JSON file created by query command. For example: amtool silence query -o json foo > foo.json amtool silence import foo.json JSON data can also come from stdin if no param is specified. ` func configureSilenceImportCmd(cc kingpin.CmdClause) { var ( c = &silenceImportCmd{} importCmd = cc.Command("import", silenceImportHelp) ) importCmd.Flag("force", "Force adding new silences even if it already exists").Short('f').BoolVar(&c.force) importCmd.Flag("worker", "Number of concurrent workers to use for import").Short('w').Default("8").IntVar(&c.workers) importCmd.Arg("input-file", "JSON file with silences").ExistingFileVar(&c.file) importCmd.Action(execWithTimeout(c.bulkImport)) } func addSilenceWorker(ctx context.Context, sclient silence.ClientService, silencec <-chan models.PostableSilence, errc chan<- error) { for s := range silencec { sid := s.ID params := silence.NewPostSilencesParams().WithContext(ctx).WithSilence(s) postOk, err := sclient.PostSilences(params) var e silence.PostSilencesNotFound if errors.As(err, &e) { // silence doesn't exists yet, retry to create as a new one params.Silence.ID = "" postOk, err = sclient.PostSilences(params) } if err != nil { fmt.Fprintf(os.Stderr, "Error adding silence id='%v': %v\n", sid, err) } else { fmt.Println(postOk.Payload.SilenceID) } errc <- err } } func (c silenceImportCmd) bulkImport(ctx context.Context, _ kingpin.ParseContext) error { input := os.Stdin var err error if c.file != "" { input, err = os.Open(c.file) if err != nil { return err } defer input.Close() } dec := json.NewDecoder(input) // read open square bracket _, err = dec.Token() if err != nil { return fmt.Errorf("couldn't unmarshal input data, is it JSON?: %w", err) } amclient := NewAlertmanagerClient(alertmanagerURL) silencec := make(chan models.PostableSilence, 100) errc := make(chan error, 100) var wg sync.WaitGroup for w := 0; w < c.workers; w++ { wg.Add(1) go func() { addSilenceWorker(ctx, amclient.Silence, silencec, errc) wg.Done() }() } errCount := 0 go func() { for err := range errc { if err != nil { errCount++ } } }() count := 0 for dec.More() { var s models.PostableSilence err := dec.Decode(&s) if err != nil { return fmt.Errorf("couldn't unmarshal input data, is it JSON?: %w", err) } if c.force { // reset the silence ID so Alertmanager will always create new silence s.ID = "" } silencec <- &s count++ } close(silencec) wg.Wait() close(errc) if errCount > 0 { return fmt.Errorf("couldn't import %v out of %v silences", errCount, count) } return nil }	3.63 KB	2025-05-25 12:27
📄 silence_query.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli 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/matcher/compat" ) type silenceQueryCmd struct { expired bool quiet bool createdBy string ID string matchers []string within time.Duration } const querySilenceHelp = `Query Alertmanager silences. Amtool has a simplified prometheus query syntax, but contains robust support for bash variable expansions. The non-option section of arguments constructs a list of "Matcher Groups" that will be used to filter your query. The following examples will attempt to show this behaviour in action: amtool silence query alertname=foo node=bar This query will match all silences with the alertname=foo and node=bar label value pairs set. amtool silence query foo node=bar If alertname is omitted and the first argument does not contain a '=' or a '=~' then it will be assumed to be the value of the alertname pair. amtool silence query 'alertname=~foo.' As well as direct equality, regex matching is also supported. The '=~' syntax (similar to prometheus) is used to represent a regex match. Regex matching can be used in combination with a direct match. In addition to filtering by silence labels, one can also query for silences that are due to expire soon with the "--within" parameter. In the event that you want to preemptively act upon expiring silences by either fixing them or extending them. For example: amtool silence query --within 8h returns all the silences due to expire within the next 8 hours. This syntax can also be combined with the label based filtering above for more flexibility. The "--expired" parameter returns only expired silences. Used in combination with "--within=TIME", amtool returns the silences that expired within the preceding duration. amtool silence query --within 2h --expired returns all silences that expired within the preceding 2 hours. ` func configureSilenceQueryCmd(cc kingpin.CmdClause) { var ( c = &silenceQueryCmd{} queryCmd = cc.Command("query", querySilenceHelp).Default() ) queryCmd.Flag("expired", "Show expired silences instead of active").BoolVar(&c.expired) queryCmd.Flag("quiet", "Only show silence ids").Short('q').BoolVar(&c.quiet) queryCmd.Flag("created-by", "Show silences that belong to this creator").StringVar(&c.createdBy) queryCmd.Flag("id", "Get a single silence by its ID").StringVar(&c.ID) queryCmd.Arg("matcher-groups", "Query filter").StringsVar(&c.matchers) queryCmd.Flag("within", "Show silences that will expire or have expired within a duration").DurationVar(&c.within) queryCmd.Action(execWithTimeout(c.query)) } func (c silenceQueryCmd) query(ctx context.Context, _ kingpin.ParseContext) error { if len(c.matchers) > 0 { // 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 := compat.Matcher(c.matchers[0], "cli") if err != nil { c.matchers[0] = fmt.Sprintf("alertname=%s", strconv.Quote(c.matchers[0])) } } silenceParams := silence.NewGetSilencesParams().WithContext(ctx).WithFilter(c.matchers) amclient := NewAlertmanagerClient(alertmanagerURL) getOk, err := amclient.Silence.GetSilences(silenceParams) if err != nil { return err } displaySilences := []models.GettableSilence{} for _, silence := range getOk.Payload { // skip expired silences if --expired is not set if !c.expired && time.Time(silence.EndsAt).Before(time.Now()) { continue } // skip active silences if --expired is set if c.expired && time.Time(silence.EndsAt).After(time.Now()) { continue } // skip active silences expiring after "--within" if !c.expired && int64(c.within) > 0 && time.Time(silence.EndsAt).After(time.Now().UTC().Add(c.within)) { continue } // skip silences that expired before "--within" if c.expired && int64(c.within) > 0 && time.Time(silence.EndsAt).Before(time.Now().UTC().Add(-c.within)) { continue } // Skip silences if the author doesn't match. if c.createdBy != "" && silence.CreatedBy != c.createdBy { continue } // Skip silences if the ID doesn't match. if c.ID != "" && c.ID != silence.ID { continue } displaySilences = append(displaySilences, silence) } if c.quiet { for _, silence := range displaySilences { fmt.Println(silence.ID) } } else { formatter, found := format.Formatters[output] if !found { return errors.New("unknown output formatter") } if err := formatter.FormatSilences(displaySilences); err != nil { return fmt.Errorf("error formatting silences: %w", err) } } return nil }	5.33 KB	2025-05-25 12:27
📄 silence_update.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "fmt" "time" "github.com/alecthomas/kingpin/v2" "github.com/go-openapi/strfmt" "github.com/prometheus/common/model" "github.com/prometheus/alertmanager/api/v2/client/silence" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/cli/format" ) type silenceUpdateCmd struct { quiet bool duration string start string end string comment string ids []string } func configureSilenceUpdateCmd(cc kingpin.CmdClause) { var ( c = &silenceUpdateCmd{} updateCmd = cc.Command("update", "Update silences") ) updateCmd.Flag("quiet", "Only show silence ids").Short('q').BoolVar(&c.quiet) updateCmd.Flag("duration", "Duration of silence").Short('d').StringVar(&c.duration) updateCmd.Flag("start", "Set when the silence should start. RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&c.start) updateCmd.Flag("end", "Set when the silence should end (overwrites duration). RFC3339 format 2006-01-02T15:04:05-07:00").StringVar(&c.end) updateCmd.Flag("comment", "A comment to help describe the silence").Short('c').StringVar(&c.comment) updateCmd.Arg("update-ids", "Silence IDs to update").StringsVar(&c.ids) updateCmd.Action(execWithTimeout(c.update)) } func (c silenceUpdateCmd) update(ctx context.Context, _ kingpin.ParseContext) error { if len(c.ids) < 1 { return fmt.Errorf("no silence IDs specified") } amclient := NewAlertmanagerClient(alertmanagerURL) var updatedSilences []models.GettableSilence for _, silenceID := range c.ids { params := silence.NewGetSilenceParams() params.SilenceID = strfmt.UUID(silenceID) response, err := amclient.Silence.GetSilence(params) if err != nil { return err } sil := response.Payload if c.start != "" { startsAtTime, err := time.Parse(time.RFC3339, c.start) if err != nil { return err } startsAt := strfmt.DateTime(startsAtTime) sil.StartsAt = &startsAt } if c.end != "" { endsAtTime, err := time.Parse(time.RFC3339, c.end) if err != nil { return err } endsAt := strfmt.DateTime(endsAtTime) sil.EndsAt = &endsAt } else if c.duration != "" { d, err := model.ParseDuration(c.duration) if err != nil { return err } if d == 0 { return fmt.Errorf("silence duration must be greater than 0") } endsAt := strfmt.DateTime(time.Time(sil.StartsAt).UTC().Add(time.Duration(d))) sil.EndsAt = &endsAt } if time.Time(sil.StartsAt).After(time.Time(sil.EndsAt)) { return errors.New("silence cannot start after it ends") } if c.comment != "" { sil.Comment = &c.comment } ps := &models.PostableSilence{ ID: sil.ID, Silence: sil.Silence, } amclient := NewAlertmanagerClient(alertmanagerURL) silenceParams := silence.NewPostSilencesParams().WithContext(ctx).WithSilence(ps) postOk, err := amclient.Silence.PostSilences(silenceParams) if err != nil { return err } sil.ID = &postOk.Payload.SilenceID updatedSilences = append(updatedSilences, sil) } if c.quiet { for _, silence := range updatedSilences { fmt.Println(silence.ID) } } else { formatter, found := format.Formatters[output] if !found { return fmt.Errorf("unknown output formatter") } if err := formatter.FormatSilences(updatedSilences); err != nil { return fmt.Errorf("error formatting silences: %w", err) } } return nil }	3.9 KB	2025-05-25 12:27
📄 template.go // Copyright 2021 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "github.com/alecthomas/kingpin/v2" ) // configureTemplateCmd represents the template command. func configureTemplateCmd(app *kingpin.Application) { templateCmd := app.Command("template", "Render template files.") configureTemplateRenderCmd(templateCmd) }	867 B	2025-05-25 12:27
📄 template_render.go // Copyright 2021 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "encoding/json" "fmt" "io" "os" "time" "github.com/alecthomas/kingpin/v2" "github.com/prometheus/common/model" "github.com/prometheus/alertmanager/template" ) var defaultData = template.Data{ Receiver: "receiver", Status: "alertstatus", Alerts: template.Alerts{ template.Alert{ Status: string(model.AlertFiring), Labels: template.KV{ "label1": "value1", "label2": "value2", "instance": "foo.bar:1234", "commonlabelkey1": "commonlabelvalue1", "commonlabelkey2": "commonlabelvalue2", }, Annotations: template.KV{ "annotation1": "value1", "annotation2": "value2", "commonannotationkey1": "commonannotationvalue1", "commonannotationkey2": "commonannotationvalue2", }, StartsAt: time.Now().Add(-5 * time.Minute), EndsAt: time.Now(), GeneratorURL: "https://generatorurl.com", Fingerprint: "fingerprint1", }, template.Alert{ Status: string(model.AlertResolved), Labels: template.KV{ "foo": "bar", "baz": "qux", "commonlabelkey1": "commonlabelvalue1", "commonlabelkey2": "commonlabelvalue2", }, Annotations: template.KV{ "aaa": "bbb", "ccc": "ddd", "commonannotationkey1": "commonannotationvalue1", "commonannotationkey2": "commonannotationvalue2", }, StartsAt: time.Now().Add(-10 * time.Minute), EndsAt: time.Now(), GeneratorURL: "https://generatorurl.com", Fingerprint: "fingerprint2", }, }, GroupLabels: template.KV{ "grouplabelkey1": "grouplabelvalue1", "grouplabelkey2": "grouplabelvalue2", }, CommonLabels: template.KV{ "commonlabelkey1": "commonlabelvalue1", "commonlabelkey2": "commonlabelvalue2", }, CommonAnnotations: template.KV{ "commonannotationkey1": "commonannotationvalue1", "commonannotationkey2": "commonannotationvalue2", }, ExternalURL: "https://example.com", } type templateRenderCmd struct { templateFilesGlobs []string templateType string templateText string templateData os.File } func configureTemplateRenderCmd(cc kingpin.CmdClause) { var ( c = &templateRenderCmd{} renderCmd = cc.Command("render", "Render a given definition in a template file to standard output.") ) renderCmd.Flag("template.glob", "Glob of paths that will be expanded and used for rendering.").Required().StringsVar(&c.templateFilesGlobs) renderCmd.Flag("template.text", "The template that will be rendered.").Required().StringVar(&c.templateText) renderCmd.Flag("template.type", "The type of the template. Can be either text (default) or html.").EnumVar(&c.templateType, "html", "text") renderCmd.Flag("template.data", "Full path to a file which contains the data of the alert(-s) with which the --template.text will be rendered. Must be in JSON. File must be formatted according to the following layout: https://pkg.go.dev/github.com/prometheus/alertmanager/template#Data. If none has been specified then a predefined, simple alert will be used for rendering.").FileVar(&c.templateData) renderCmd.Action(execWithTimeout(c.render)) } func (c templateRenderCmd) render(ctx context.Context, _ kingpin.ParseContext) error { tmpl, err := template.FromGlobs(c.templateFilesGlobs) if err != nil { return err } f := tmpl.ExecuteTextString if c.templateType == "html" { f = tmpl.ExecuteHTMLString } var data template.Data if c.templateData == nil { data = defaultData } else { content, err := io.ReadAll(c.templateData) if err != nil { return err } if err := json.Unmarshal(content, &data); err != nil { return err } } rendered, err := f(c.templateText, data) if err != nil { return err } fmt.Print(rendered) return nil }	4.3 KB	2025-05-25 12:27
📄 test_routing.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "fmt" "os" "strings" "github.com/alecthomas/kingpin/v2" "github.com/xlab/treeprint" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/dispatch" "github.com/prometheus/alertmanager/matcher/compat" "github.com/prometheus/alertmanager/pkg/labels" ) const routingTestHelp = `Test alert routing Will return receiver names which the alert with given labels resolves to. If the labelset resolves to multiple receivers, they are printed out in order as defined in the routing tree. Routing is loaded from a local configuration file or a running Alertmanager configuration. Specifying --config.file takes precedence over --alertmanager.url. Example: ./amtool config routes test --config.file=doc/examples/simple.yml --verify.receivers=team-DB-pager service=database ` func configureRoutingTestCmd(cc kingpin.CmdClause, c routingShow) { routingTestCmd := cc.Command("test", routingTestHelp) routingTestCmd.Flag("verify.receivers", "Checks if specified receivers matches resolved receivers. The command fails if the labelset does not route to the specified receivers.").StringVar(&c.expectedReceivers) routingTestCmd.Flag("tree", "Prints out matching routes tree.").BoolVar(&c.debugTree) routingTestCmd.Arg("labels", "List of labels to be tested against the configured routes.").StringsVar(&c.labels) routingTestCmd.Action(execWithTimeout(c.routingTestAction)) } // resolveAlertReceivers returns list of receiver names which given LabelSet resolves to. func resolveAlertReceivers(mainRoute dispatch.Route, labels models.LabelSet) ([]string, error) { var ( finalRoutes []dispatch.Route receivers []string ) finalRoutes = mainRoute.Match(convertClientToCommonLabelSet(labels)) for _, r := range finalRoutes { receivers = append(receivers, r.RouteOpts.Receiver) } return receivers, nil } func printMatchingTree(mainRoute dispatch.Route, ls models.LabelSet) { tree := treeprint.New() getMatchingTree(mainRoute, tree, ls) fmt.Println("Matching routes:") fmt.Println(tree.String()) fmt.Print("\n") } func (c routingShow) routingTestAction(ctx context.Context, _ *kingpin.ParseContext) error { cfg, err := loadAlertmanagerConfig(ctx, alertmanagerURL, c.configFile) if err != nil { kingpin.Fatalf("%v\n", err) return err } mainRoute := dispatch.NewRoute(cfg.Route, nil) // Parse labels to LabelSet. ls := make(models.LabelSet, len(c.labels)) for _, l := range c.labels { matcher, err := compat.Matcher(l, "cli") 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 { printMatchingTree(mainRoute, ls) } receivers, err := resolveAlertReceivers(mainRoute, &ls) receiversSlug := strings.Join(receivers, ",") fmt.Printf("%s\n", receiversSlug) if c.expectedReceivers != "" && c.expectedReceivers != receiversSlug { fmt.Printf("WARNING: Expected receivers did not match resolved receivers.\n") os.Exit(1) } return err }	3.64 KB	2025-05-25 12:27
📄 test_routing_test.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "fmt" "reflect" "strings" "testing" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/config" "github.com/prometheus/alertmanager/dispatch" ) type routingTestDefinition struct { alert models.LabelSet expectedReceivers []string configFile string } func checkResolvedReceivers(mainRoute dispatch.Route, ls models.LabelSet, expectedReceivers []string) error { resolvedReceivers, err := resolveAlertReceivers(mainRoute, &ls) if err != nil { return err } if !reflect.DeepEqual(expectedReceivers, resolvedReceivers) { return fmt.Errorf("unexpected routing result want: `%s`, got: `%s`", strings.Join(expectedReceivers, ","), strings.Join(resolvedReceivers, ",")) } return nil } func TestRoutingTest(t testing.T) { tests := []*routingTestDefinition{ {configFile: "testdata/conf.routing.yml", alert: models.LabelSet{"test": "1"}, expectedReceivers: []string{"test1"}}, {configFile: "testdata/conf.routing.yml", alert: models.LabelSet{"test": "2"}, expectedReceivers: []string{"test1", "test2"}}, {configFile: "testdata/conf.routing-reverted.yml", alert: models.LabelSet{"test": "2"}, expectedReceivers: []string{"test2", "test1"}}, {configFile: "testdata/conf.routing.yml", alert: models.LabelSet{"test": "volovina"}, expectedReceivers: []string{"default"}}, } for _, test := range tests { cfg, err := config.LoadFile(test.configFile) if err != nil { t.Fatalf("failed to load test configuration: %v", err) } mainRoute := dispatch.NewRoute(cfg.Route, nil) err = checkResolvedReceivers(mainRoute, test.alert, test.expectedReceivers) if err != nil { t.Fatalf("%v", err) } fmt.Println(" OK") } }	2.26 KB	2025-05-25 12:27
📁 testdata	-	2025-05-25 12:27
📄 utils.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package cli import ( "context" "errors" "fmt" "net/url" "os" "github.com/alecthomas/kingpin/v2" "github.com/prometheus/common/model" "github.com/prometheus/alertmanager/api/v2/client/general" "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/config" "github.com/prometheus/alertmanager/pkg/labels" ) // getRemoteAlertmanagerConfigStatus returns status responsecontaining configuration from remote Alertmanager. func getRemoteAlertmanagerConfigStatus(ctx context.Context, alertmanagerURL url.URL) (models.AlertmanagerStatus, error) { amclient := NewAlertmanagerClient(alertmanagerURL) params := general.NewGetStatusParams().WithContext(ctx) getOk, err := amclient.General.GetStatus(params) if err != nil { return nil, err } return getOk.Payload, nil } func checkRoutingConfigInputFlags(alertmanagerURL url.URL, configFile string) { if alertmanagerURL != nil && configFile != "" { fmt.Fprintln(os.Stderr, "Warning: --config.file flag overrides the --alertmanager.url.") } if alertmanagerURL == nil && configFile == "" { kingpin.Fatalf("You have to specify one of --config.file or --alertmanager.url flags.") } } func loadAlertmanagerConfig(ctx context.Context, alertmanagerURL url.URL, configFile string) (config.Config, error) { checkRoutingConfigInputFlags(alertmanagerURL, configFile) if configFile != "" { cfg, err := config.LoadFile(configFile) if err != nil { return nil, err } return cfg, nil } if alertmanagerURL == nil { return nil, errors.New("failed to get Alertmanager configuration") } configStatus, err := getRemoteAlertmanagerConfigStatus(ctx, alertmanagerURL) if err != nil { return nil, err } return config.Load(configStatus.Config.Original) } // convertClientToCommonLabelSet converts client.LabelSet to model.Labelset. func convertClientToCommonLabelSet(cls models.LabelSet) model.LabelSet { mls := make(model.LabelSet, len(cls)) for ln, lv := range cls { mls[model.LabelName(ln)] = model.LabelValue(lv) } return mls } // 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)) for i, matcher := range matchers { typeMatchers[i] = TypeMatcher(matcher) } return typeMatchers } // TypeMatcher only valid for when you are going to add a silence. func TypeMatcher(matcher labels.Matcher) models.Matcher { name := matcher.Name value := matcher.Value typeMatcher := models.Matcher{ Name: &name, Value: &value, } isEqual := (matcher.Type == labels.MatchEqual) \|\| (matcher.Type == labels.MatchRegexp) isRegex := (matcher.Type == labels.MatchRegexp) \|\| (matcher.Type == labels.MatchNotRegexp) typeMatcher.IsEqual = &isEqual typeMatcher.IsRegex = &isRegex return &typeMatcher } // Helper function for adding the ctx with timeout into an action. func execWithTimeout(fn func(context.Context, kingpin.ParseContext) error) func(kingpin.ParseContext) error { return func(x kingpin.ParseContext) error { ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() return fn(ctx, x) } }	3.68 KB	2025-05-25 12:27

Edit File:

Terminal