Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 config.go // Copyright 2015 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 config import ( "encoding/json" "errors" "fmt" "net" "net/url" "os" "path/filepath" "regexp" "sort" "strings" "time" commoncfg "github.com/prometheus/common/config" "github.com/prometheus/common/model" "gopkg.in/yaml.v2" "github.com/prometheus/alertmanager/matcher/compat" "github.com/prometheus/alertmanager/pkg/labels" "github.com/prometheus/alertmanager/timeinterval" ) const secretToken = "<secret>" var secretTokenJSON string // MarshalSecretValue if set to true will expose Secret type // through the marshal interfaces. Useful for outside projects // that load and marshal the Alertmanager config. var MarshalSecretValue bool = commoncfg.MarshalSecretValue func init() { b, err := json.Marshal(secretToken) if err != nil { panic(err) } secretTokenJSON = string(b) } // Secret is a string that must not be revealed on marshaling. type Secret string // MarshalYAML implements the yaml.Marshaler interface for Secret. func (s Secret) MarshalYAML() (interface{}, error) { if MarshalSecretValue { return string(s), nil } if s != "" { return secretToken, nil } return nil, nil } // UnmarshalYAML implements the yaml.Unmarshaler interface for Secret. func (s Secret) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain Secret return unmarshal((plain)(s)) } // MarshalJSON implements the json.Marshaler interface for Secret. func (s Secret) MarshalJSON() ([]byte, error) { if MarshalSecretValue { return json.Marshal(string(s)) } if len(s) == 0 { return json.Marshal("") } return json.Marshal(secretToken) } // URL is a custom type that represents an HTTP or HTTPS URL and allows validation at configuration load time. type URL struct { url.URL } // Copy makes a deep-copy of the struct. func (u URL) Copy() URL { v := u.URL return &URL{&v} } // MarshalYAML implements the yaml.Marshaler interface for URL. func (u URL) MarshalYAML() (interface{}, error) { if u.URL != nil { return u.URL.String(), nil } return nil, nil } // UnmarshalYAML implements the yaml.Unmarshaler interface for URL. func (u URL) UnmarshalYAML(unmarshal func(interface{}) error) error { var s string if err := unmarshal(&s); err != nil { return err } urlp, err := parseURL(s) if err != nil { return err } u.URL = urlp.URL return nil } // MarshalJSON implements the json.Marshaler interface for URL. func (u URL) MarshalJSON() ([]byte, error) { if u.URL != nil { return json.Marshal(u.URL.String()) } return []byte("null"), nil } // UnmarshalJSON implements the json.Marshaler interface for URL. func (u URL) UnmarshalJSON(data []byte) error { var s string if err := json.Unmarshal(data, &s); err != nil { return err } urlp, err := parseURL(s) if err != nil { return err } u.URL = urlp.URL return nil } // SecretURL is a URL that must not be revealed on marshaling. type SecretURL URL // MarshalYAML implements the yaml.Marshaler interface for SecretURL. func (s SecretURL) MarshalYAML() (interface{}, error) { if s.URL != nil { if MarshalSecretValue { return s.URL.String(), nil } return secretToken, nil } return nil, nil } // UnmarshalYAML implements the yaml.Unmarshaler interface for SecretURL. func (s SecretURL) UnmarshalYAML(unmarshal func(interface{}) error) error { var str string if err := unmarshal(&str); err != nil { return err } // In order to deserialize a previously serialized configuration (eg from // the Alertmanager API with amtool), `<secret>` needs to be treated // specially, as it isn't a valid URL. if str == secretToken { s.URL = &url.URL{} return nil } return unmarshal((URL)(s)) } // MarshalJSON implements the json.Marshaler interface for SecretURL. func (s SecretURL) MarshalJSON() ([]byte, error) { if s.URL == nil { return json.Marshal("") } if MarshalSecretValue { return json.Marshal(s.URL.String()) } return json.Marshal(secretToken) } // UnmarshalJSON implements the json.Marshaler interface for SecretURL. func (s SecretURL) UnmarshalJSON(data []byte) error { // In order to deserialize a previously serialized configuration (eg from // the Alertmanager API with amtool), `<secret>` needs to be treated // specially, as it isn't a valid URL. if string(data) == secretToken \|\| string(data) == secretTokenJSON { s.URL = &url.URL{} return nil } // Redact the secret URL in case of errors if err := json.Unmarshal(data, (URL)(s)); err != nil { if MarshalSecretValue { return err } return errors.New(strings.ReplaceAll(err.Error(), string(data), "[REDACTED]")) } return nil } // Load parses the YAML input s into a Config. func Load(s string) (Config, error) { cfg := &Config{} err := yaml.UnmarshalStrict([]byte(s), cfg) if err != nil { return nil, err } // Check if we have a root route. We cannot check for it in the // UnmarshalYAML method because it won't be called if the input is empty // (e.g. the config file is empty or only contains whitespace). if cfg.Route == nil { return nil, errors.New("no route provided in config") } // Check if continue in root route. if cfg.Route.Continue { return nil, errors.New("cannot have continue in root route") } cfg.original = s return cfg, nil } // LoadFile parses the given YAML file into a Config. func LoadFile(filename string) (Config, error) { content, err := os.ReadFile(filename) if err != nil { return nil, err } cfg, err := Load(string(content)) if err != nil { return nil, err } resolveFilepaths(filepath.Dir(filename), cfg) return cfg, nil } // resolveFilepaths joins all relative paths in a configuration // with a given base directory. func resolveFilepaths(baseDir string, cfg Config) { join := func(fp string) string { if len(fp) > 0 && !filepath.IsAbs(fp) { fp = filepath.Join(baseDir, fp) } return fp } for i, tf := range cfg.Templates { cfg.Templates[i] = join(tf) } cfg.Global.HTTPConfig.SetDirectory(baseDir) for _, receiver := range cfg.Receivers { for _, cfg := range receiver.OpsGenieConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.PagerdutyConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.PushoverConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.SlackConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.VictorOpsConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.WebhookConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.WechatConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.SNSConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.TelegramConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.DiscordConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.WebexConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.MSTeamsConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.MSTeamsV2Configs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.JiraConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } for _, cfg := range receiver.RocketchatConfigs { cfg.HTTPConfig.SetDirectory(baseDir) } } } // MuteTimeInterval represents a named set of time intervals for which a route should be muted. type MuteTimeInterval struct { Name string `yaml:"name" json:"name"` TimeIntervals []timeinterval.TimeInterval `yaml:"time_intervals" json:"time_intervals"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for MuteTimeInterval. func (mt MuteTimeInterval) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain MuteTimeInterval if err := unmarshal((plain)(mt)); err != nil { return err } if mt.Name == "" { return errors.New("missing name in mute time interval") } return nil } // TimeInterval represents a named set of time intervals for which a route should be muted. type TimeInterval struct { Name string `yaml:"name" json:"name"` TimeIntervals []timeinterval.TimeInterval `yaml:"time_intervals" json:"time_intervals"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for MuteTimeInterval. func (ti TimeInterval) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain TimeInterval if err := unmarshal((plain)(ti)); err != nil { return err } if ti.Name == "" { return errors.New("missing name in time interval") } return nil } // Config is the top-level configuration for Alertmanager's config files. type Config struct { Global GlobalConfig `yaml:"global,omitempty" json:"global,omitempty"` Route Route `yaml:"route,omitempty" json:"route,omitempty"` InhibitRules []InhibitRule `yaml:"inhibit_rules,omitempty" json:"inhibit_rules,omitempty"` Receivers []Receiver `yaml:"receivers,omitempty" json:"receivers,omitempty"` Templates []string `yaml:"templates" json:"templates"` // Deprecated. Remove before v1.0 release. MuteTimeIntervals []MuteTimeInterval `yaml:"mute_time_intervals,omitempty" json:"mute_time_intervals,omitempty"` TimeIntervals []TimeInterval `yaml:"time_intervals,omitempty" json:"time_intervals,omitempty"` // original is the input from which the config was parsed. original string } func (c Config) String() string { b, err := yaml.Marshal(c) if err != nil { return fmt.Sprintf("<error creating config string: %s>", err) } return string(b) } // UnmarshalYAML implements the yaml.Unmarshaler interface for Config. func (c Config) UnmarshalYAML(unmarshal func(interface{}) error) error { // We want to set c to the defaults and then overwrite it with the input. // To make unmarshal fill the plain data struct rather than calling UnmarshalYAML // again, we have to hide it using a type indirection. type plain Config if err := unmarshal((plain)(c)); err != nil { return err } // If a global block was open but empty the default global config is overwritten. // We have to restore it here. if c.Global == nil { c.Global = &GlobalConfig{} c.Global = DefaultGlobalConfig() } if c.Global.SlackAPIURL != nil && len(c.Global.SlackAPIURLFile) > 0 { return errors.New("at most one of slack_api_url & slack_api_url_file must be configured") } if c.Global.OpsGenieAPIKey != "" && len(c.Global.OpsGenieAPIKeyFile) > 0 { return errors.New("at most one of opsgenie_api_key & opsgenie_api_key_file must be configured") } if c.Global.VictorOpsAPIKey != "" && len(c.Global.VictorOpsAPIKeyFile) > 0 { return errors.New("at most one of victorops_api_key & victorops_api_key_file must be configured") } if len(c.Global.SMTPAuthPassword) > 0 && len(c.Global.SMTPAuthPasswordFile) > 0 { return errors.New("at most one of smtp_auth_password & smtp_auth_password_file must be configured") } if c.Global.RocketchatToken != nil && len(c.Global.RocketchatTokenFile) > 0 { return errors.New("at most one of rocketchat_token & rocketchat_token_file must be configured") } if c.Global.RocketchatTokenID != nil && len(c.Global.RocketchatTokenIDFile) > 0 { return errors.New("at most one of rocketchat_token_id & rocketchat_token_id_file must be configured") } names := map[string]struct{}{} for _, rcv := range c.Receivers { if _, ok := names[rcv.Name]; ok { return fmt.Errorf("notification config name %q is not unique", rcv.Name) } for _, wh := range rcv.WebhookConfigs { if wh.HTTPConfig == nil { wh.HTTPConfig = c.Global.HTTPConfig } } for _, ec := range rcv.EmailConfigs { if ec.TLSConfig == nil { ec.TLSConfig = c.Global.SMTPTLSConfig } if ec.Smarthost.String() == "" { if c.Global.SMTPSmarthost.String() == "" { return errors.New("no global SMTP smarthost set") } ec.Smarthost = c.Global.SMTPSmarthost } if ec.From == "" { if c.Global.SMTPFrom == "" { return errors.New("no global SMTP from set") } ec.From = c.Global.SMTPFrom } if ec.Hello == "" { ec.Hello = c.Global.SMTPHello } if ec.AuthUsername == "" { ec.AuthUsername = c.Global.SMTPAuthUsername } if ec.AuthPassword == "" && ec.AuthPasswordFile == "" { ec.AuthPassword = c.Global.SMTPAuthPassword ec.AuthPasswordFile = c.Global.SMTPAuthPasswordFile } if ec.AuthSecret == "" { ec.AuthSecret = c.Global.SMTPAuthSecret } if ec.AuthIdentity == "" { ec.AuthIdentity = c.Global.SMTPAuthIdentity } if ec.RequireTLS == nil { ec.RequireTLS = new(bool) ec.RequireTLS = c.Global.SMTPRequireTLS } } for _, sc := range rcv.SlackConfigs { if sc.HTTPConfig == nil { sc.HTTPConfig = c.Global.HTTPConfig } if sc.APIURL == nil && len(sc.APIURLFile) == 0 { if c.Global.SlackAPIURL == nil && len(c.Global.SlackAPIURLFile) == 0 { return errors.New("no global Slack API URL set either inline or in a file") } sc.APIURL = c.Global.SlackAPIURL sc.APIURLFile = c.Global.SlackAPIURLFile } } for _, poc := range rcv.PushoverConfigs { if poc.HTTPConfig == nil { poc.HTTPConfig = c.Global.HTTPConfig } } for _, pdc := range rcv.PagerdutyConfigs { if pdc.HTTPConfig == nil { pdc.HTTPConfig = c.Global.HTTPConfig } if pdc.URL == nil { if c.Global.PagerdutyURL == nil { return errors.New("no global PagerDuty URL set") } pdc.URL = c.Global.PagerdutyURL } } for _, ogc := range rcv.OpsGenieConfigs { if ogc.HTTPConfig == nil { ogc.HTTPConfig = c.Global.HTTPConfig } if ogc.APIURL == nil { if c.Global.OpsGenieAPIURL == nil { return errors.New("no global OpsGenie URL set") } ogc.APIURL = c.Global.OpsGenieAPIURL } if !strings.HasSuffix(ogc.APIURL.Path, "/") { ogc.APIURL.Path += "/" } if ogc.APIKey == "" && len(ogc.APIKeyFile) == 0 { if c.Global.OpsGenieAPIKey == "" && len(c.Global.OpsGenieAPIKeyFile) == 0 { return errors.New("no global OpsGenie API Key set either inline or in a file") } ogc.APIKey = c.Global.OpsGenieAPIKey ogc.APIKeyFile = c.Global.OpsGenieAPIKeyFile } } for _, wcc := range rcv.WechatConfigs { if wcc.HTTPConfig == nil { wcc.HTTPConfig = c.Global.HTTPConfig } if wcc.APIURL == nil { if c.Global.WeChatAPIURL == nil { return errors.New("no global Wechat URL set") } wcc.APIURL = c.Global.WeChatAPIURL } if wcc.APISecret == "" { if c.Global.WeChatAPISecret == "" { return errors.New("no global Wechat ApiSecret set") } wcc.APISecret = c.Global.WeChatAPISecret } if wcc.CorpID == "" { if c.Global.WeChatAPICorpID == "" { return errors.New("no global Wechat CorpID set") } wcc.CorpID = c.Global.WeChatAPICorpID } if !strings.HasSuffix(wcc.APIURL.Path, "/") { wcc.APIURL.Path += "/" } } for _, voc := range rcv.VictorOpsConfigs { if voc.HTTPConfig == nil { voc.HTTPConfig = c.Global.HTTPConfig } if voc.APIURL == nil { if c.Global.VictorOpsAPIURL == nil { return errors.New("no global VictorOps URL set") } voc.APIURL = c.Global.VictorOpsAPIURL } if !strings.HasSuffix(voc.APIURL.Path, "/") { voc.APIURL.Path += "/" } if voc.APIKey == "" && len(voc.APIKeyFile) == 0 { if c.Global.VictorOpsAPIKey == "" && len(c.Global.VictorOpsAPIKeyFile) == 0 { return errors.New("no global VictorOps API Key set") } voc.APIKey = c.Global.VictorOpsAPIKey voc.APIKeyFile = c.Global.VictorOpsAPIKeyFile } } for _, sns := range rcv.SNSConfigs { if sns.HTTPConfig == nil { sns.HTTPConfig = c.Global.HTTPConfig } } for _, telegram := range rcv.TelegramConfigs { if telegram.HTTPConfig == nil { telegram.HTTPConfig = c.Global.HTTPConfig } if telegram.APIUrl == nil { telegram.APIUrl = c.Global.TelegramAPIUrl } } for _, discord := range rcv.DiscordConfigs { if discord.HTTPConfig == nil { discord.HTTPConfig = c.Global.HTTPConfig } if discord.WebhookURL == nil && len(discord.WebhookURLFile) == 0 { return errors.New("no discord webhook URL or URLFile provided") } } for _, webex := range rcv.WebexConfigs { if webex.HTTPConfig == nil { webex.HTTPConfig = c.Global.HTTPConfig } if webex.APIURL == nil { if c.Global.WebexAPIURL == nil { return errors.New("no global Webex URL set") } webex.APIURL = c.Global.WebexAPIURL } } for _, msteams := range rcv.MSTeamsConfigs { if msteams.HTTPConfig == nil { msteams.HTTPConfig = c.Global.HTTPConfig } if msteams.WebhookURL == nil && len(msteams.WebhookURLFile) == 0 { return errors.New("no msteams webhook URL or URLFile provided") } } for _, msteamsv2 := range rcv.MSTeamsV2Configs { if msteamsv2.HTTPConfig == nil { msteamsv2.HTTPConfig = c.Global.HTTPConfig } if msteamsv2.WebhookURL == nil && len(msteamsv2.WebhookURLFile) == 0 { return errors.New("no msteamsv2 webhook URL or URLFile provided") } } for _, jira := range rcv.JiraConfigs { if jira.HTTPConfig == nil { jira.HTTPConfig = c.Global.HTTPConfig } if jira.APIURL == nil { if c.Global.JiraAPIURL == nil { return errors.New("no global Jira Cloud URL set") } jira.APIURL = c.Global.JiraAPIURL } } for _, rocketchat := range rcv.RocketchatConfigs { if rocketchat.HTTPConfig == nil { rocketchat.HTTPConfig = c.Global.HTTPConfig } if rocketchat.APIURL == nil { rocketchat.APIURL = c.Global.RocketchatAPIURL } if rocketchat.TokenID == nil && len(rocketchat.TokenIDFile) == 0 { if c.Global.RocketchatTokenID == nil && len(c.Global.RocketchatTokenIDFile) == 0 { return errors.New("no global Rocketchat TokenID set either inline or in a file") } rocketchat.TokenID = c.Global.RocketchatTokenID rocketchat.TokenIDFile = c.Global.RocketchatTokenIDFile } if rocketchat.Token == nil && len(rocketchat.TokenFile) == 0 { if c.Global.RocketchatToken == nil && len(c.Global.RocketchatTokenFile) == 0 { return errors.New("no global Rocketchat Token set either inline or in a file") } rocketchat.Token = c.Global.RocketchatToken rocketchat.TokenFile = c.Global.RocketchatTokenFile } } names[rcv.Name] = struct{}{} } // The root route must not have any matchers as it is the fallback node // for all alerts. if c.Route == nil { return errors.New("no routes provided") } if len(c.Route.Receiver) == 0 { return errors.New("root route must specify a default receiver") } if len(c.Route.Match) > 0 \|\| len(c.Route.MatchRE) > 0 \|\| len(c.Route.Matchers) > 0 { return errors.New("root route must not have any matchers") } if len(c.Route.MuteTimeIntervals) > 0 { return errors.New("root route must not have any mute time intervals") } if len(c.Route.ActiveTimeIntervals) > 0 { return errors.New("root route must not have any active time intervals") } // Validate that all receivers used in the routing tree are defined. if err := checkReceiver(c.Route, names); err != nil { return err } tiNames := make(map[string]struct{}) // read mute time intervals until deprecated for _, mt := range c.MuteTimeIntervals { if _, ok := tiNames[mt.Name]; ok { return fmt.Errorf("mute time interval %q is not unique", mt.Name) } tiNames[mt.Name] = struct{}{} } for _, mt := range c.TimeIntervals { if _, ok := tiNames[mt.Name]; ok { return fmt.Errorf("time interval %q is not unique", mt.Name) } tiNames[mt.Name] = struct{}{} } return checkTimeInterval(c.Route, tiNames) } // checkReceiver returns an error if a node in the routing tree // references a receiver not in the given map. func checkReceiver(r Route, receivers map[string]struct{}) error { for _, sr := range r.Routes { if err := checkReceiver(sr, receivers); err != nil { return err } } if r.Receiver == "" { return nil } if _, ok := receivers[r.Receiver]; !ok { return fmt.Errorf("undefined receiver %q used in route", r.Receiver) } return nil } func checkTimeInterval(r Route, timeIntervals map[string]struct{}) error { for _, sr := range r.Routes { if err := checkTimeInterval(sr, timeIntervals); err != nil { return err } } for _, ti := range r.ActiveTimeIntervals { if _, ok := timeIntervals[ti]; !ok { return fmt.Errorf("undefined time interval %q used in route", ti) } } for _, tm := range r.MuteTimeIntervals { if _, ok := timeIntervals[tm]; !ok { return fmt.Errorf("undefined time interval %q used in route", tm) } } return nil } // DefaultGlobalConfig returns GlobalConfig with default values. func DefaultGlobalConfig() GlobalConfig { defaultHTTPConfig := commoncfg.DefaultHTTPClientConfig defaultSMTPTLSConfig := commoncfg.TLSConfig{} return GlobalConfig{ ResolveTimeout: model.Duration(5 time.Minute), HTTPConfig: &defaultHTTPConfig, SMTPHello: "localhost", SMTPRequireTLS: true, SMTPTLSConfig: &defaultSMTPTLSConfig, PagerdutyURL: mustParseURL("https://events.pagerduty.com/v2/enqueue"), OpsGenieAPIURL: mustParseURL("https://api.opsgenie.com/"), WeChatAPIURL: mustParseURL("https://qyapi.weixin.qq.com/cgi-bin/"), VictorOpsAPIURL: mustParseURL("https://alert.victorops.com/integrations/generic/20131114/alert/"), TelegramAPIUrl: mustParseURL("https://api.telegram.org"), WebexAPIURL: mustParseURL("https://webexapis.com/v1/messages"), RocketchatAPIURL: mustParseURL("https://open.rocket.chat/"), } } func mustParseURL(s string) URL { u, err := parseURL(s) if err != nil { panic(err) } return u } func parseURL(s string) (URL, error) { u, err := url.Parse(s) if err != nil { return nil, err } if u.Scheme != "http" && u.Scheme != "https" { return nil, fmt.Errorf("unsupported scheme %q for URL", u.Scheme) } if u.Host == "" { return nil, errors.New("missing host for URL") } return &URL{u}, nil } // HostPort represents a "host:port" network address. type HostPort struct { Host string Port string } // UnmarshalYAML implements the yaml.Unmarshaler interface for HostPort. func (hp HostPort) UnmarshalYAML(unmarshal func(interface{}) error) error { var ( s string err error ) if err = unmarshal(&s); err != nil { return err } if s == "" { return nil } hp.Host, hp.Port, err = net.SplitHostPort(s) if err != nil { return err } if hp.Port == "" { return fmt.Errorf("address %q: port cannot be empty", s) } return nil } // UnmarshalJSON implements the json.Unmarshaler interface for HostPort. func (hp HostPort) UnmarshalJSON(data []byte) error { var ( s string err error ) if err = json.Unmarshal(data, &s); err != nil { return err } if s == "" { return nil } hp.Host, hp.Port, err = net.SplitHostPort(s) if err != nil { return err } if hp.Port == "" { return fmt.Errorf("address %q: port cannot be empty", s) } return nil } // MarshalYAML implements the yaml.Marshaler interface for HostPort. func (hp HostPort) MarshalYAML() (interface{}, error) { return hp.String(), nil } // MarshalJSON implements the json.Marshaler interface for HostPort. func (hp HostPort) MarshalJSON() ([]byte, error) { return json.Marshal(hp.String()) } func (hp HostPort) String() string { if hp.Host == "" && hp.Port == "" { return "" } return fmt.Sprintf("%s:%s", hp.Host, hp.Port) } // GlobalConfig defines configuration parameters that are valid globally // unless overwritten. type GlobalConfig struct { // ResolveTimeout is the time after which an alert is declared resolved // if it has not been updated. ResolveTimeout model.Duration `yaml:"resolve_timeout" json:"resolve_timeout"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` JiraAPIURL URL `yaml:"jira_api_url,omitempty" json:"jira_api_url,omitempty"` SMTPFrom string `yaml:"smtp_from,omitempty" json:"smtp_from,omitempty"` SMTPHello string `yaml:"smtp_hello,omitempty" json:"smtp_hello,omitempty"` SMTPSmarthost HostPort `yaml:"smtp_smarthost,omitempty" json:"smtp_smarthost,omitempty"` SMTPAuthUsername string `yaml:"smtp_auth_username,omitempty" json:"smtp_auth_username,omitempty"` SMTPAuthPassword Secret `yaml:"smtp_auth_password,omitempty" json:"smtp_auth_password,omitempty"` SMTPAuthPasswordFile string `yaml:"smtp_auth_password_file,omitempty" json:"smtp_auth_password_file,omitempty"` SMTPAuthSecret Secret `yaml:"smtp_auth_secret,omitempty" json:"smtp_auth_secret,omitempty"` SMTPAuthIdentity string `yaml:"smtp_auth_identity,omitempty" json:"smtp_auth_identity,omitempty"` SMTPRequireTLS bool `yaml:"smtp_require_tls" json:"smtp_require_tls,omitempty"` SMTPTLSConfig commoncfg.TLSConfig `yaml:"smtp_tls_config,omitempty" json:"smtp_tls_config,omitempty"` SlackAPIURL SecretURL `yaml:"slack_api_url,omitempty" json:"slack_api_url,omitempty"` SlackAPIURLFile string `yaml:"slack_api_url_file,omitempty" json:"slack_api_url_file,omitempty"` PagerdutyURL URL `yaml:"pagerduty_url,omitempty" json:"pagerduty_url,omitempty"` OpsGenieAPIURL URL `yaml:"opsgenie_api_url,omitempty" json:"opsgenie_api_url,omitempty"` OpsGenieAPIKey Secret `yaml:"opsgenie_api_key,omitempty" json:"opsgenie_api_key,omitempty"` OpsGenieAPIKeyFile string `yaml:"opsgenie_api_key_file,omitempty" json:"opsgenie_api_key_file,omitempty"` WeChatAPIURL URL `yaml:"wechat_api_url,omitempty" json:"wechat_api_url,omitempty"` WeChatAPISecret Secret `yaml:"wechat_api_secret,omitempty" json:"wechat_api_secret,omitempty"` WeChatAPICorpID string `yaml:"wechat_api_corp_id,omitempty" json:"wechat_api_corp_id,omitempty"` VictorOpsAPIURL URL `yaml:"victorops_api_url,omitempty" json:"victorops_api_url,omitempty"` VictorOpsAPIKey Secret `yaml:"victorops_api_key,omitempty" json:"victorops_api_key,omitempty"` VictorOpsAPIKeyFile string `yaml:"victorops_api_key_file,omitempty" json:"victorops_api_key_file,omitempty"` TelegramAPIUrl URL `yaml:"telegram_api_url,omitempty" json:"telegram_api_url,omitempty"` WebexAPIURL URL `yaml:"webex_api_url,omitempty" json:"webex_api_url,omitempty"` RocketchatAPIURL URL `yaml:"rocketchat_api_url,omitempty" json:"rocketchat_api_url,omitempty"` RocketchatToken Secret `yaml:"rocketchat_token,omitempty" json:"rocketchat_token,omitempty"` RocketchatTokenFile string `yaml:"rocketchat_token_file,omitempty" json:"rocketchat_token_file,omitempty"` RocketchatTokenID Secret `yaml:"rocketchat_token_id,omitempty" json:"rocketchat_token_id,omitempty"` RocketchatTokenIDFile string `yaml:"rocketchat_token_id_file,omitempty" json:"rocketchat_token_id_file,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for GlobalConfig. func (c GlobalConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultGlobalConfig() type plain GlobalConfig return unmarshal((plain)(c)) } // A Route is a node that contains definitions of how to handle alerts. type Route struct { Receiver string `yaml:"receiver,omitempty" json:"receiver,omitempty"` GroupByStr []string `yaml:"group_by,omitempty" json:"group_by,omitempty"` GroupBy []model.LabelName `yaml:"-" json:"-"` GroupByAll bool `yaml:"-" json:"-"` // Deprecated. Remove before v1.0 release. Match map[string]string `yaml:"match,omitempty" json:"match,omitempty"` // Deprecated. Remove before v1.0 release. MatchRE MatchRegexps `yaml:"match_re,omitempty" json:"match_re,omitempty"` Matchers Matchers `yaml:"matchers,omitempty" json:"matchers,omitempty"` MuteTimeIntervals []string `yaml:"mute_time_intervals,omitempty" json:"mute_time_intervals,omitempty"` ActiveTimeIntervals []string `yaml:"active_time_intervals,omitempty" json:"active_time_intervals,omitempty"` Continue bool `yaml:"continue" json:"continue,omitempty"` Routes []Route `yaml:"routes,omitempty" json:"routes,omitempty"` GroupWait model.Duration `yaml:"group_wait,omitempty" json:"group_wait,omitempty"` GroupInterval model.Duration `yaml:"group_interval,omitempty" json:"group_interval,omitempty"` RepeatInterval model.Duration `yaml:"repeat_interval,omitempty" json:"repeat_interval,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for Route. func (r Route) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain Route if err := unmarshal((plain)(r)); err != nil { return err } for k := range r.Match { if !model.LabelNameRE.MatchString(k) { return fmt.Errorf("invalid label name %q", k) } } for _, l := range r.GroupByStr { if l == "..." { r.GroupByAll = true } else { labelName := model.LabelName(l) if !compat.IsValidLabelName(labelName) { return fmt.Errorf("invalid label name %q in group_by list", l) } r.GroupBy = append(r.GroupBy, labelName) } } if len(r.GroupBy) > 0 && r.GroupByAll { return errors.New("cannot have wildcard group_by (`...`) and other other labels at the same time") } groupBy := map[model.LabelName]struct{}{} for _, ln := range r.GroupBy { if _, ok := groupBy[ln]; ok { return fmt.Errorf("duplicated label %q in group_by", ln) } groupBy[ln] = struct{}{} } if r.GroupInterval != nil && time.Duration(r.GroupInterval) == time.Duration(0) { return errors.New("group_interval cannot be zero") } if r.RepeatInterval != nil && time.Duration(r.RepeatInterval) == time.Duration(0) { return errors.New("repeat_interval cannot be zero") } return nil } // InhibitRule defines an inhibition rule that mutes alerts that match the // target labels if an alert matching the source labels exists. // Both alerts have to have a set of labels being equal. type InhibitRule struct { // SourceMatch defines a set of labels that have to equal the given // value for source alerts. Deprecated. Remove before v1.0 release. SourceMatch map[string]string `yaml:"source_match,omitempty" json:"source_match,omitempty"` // SourceMatchRE defines pairs like SourceMatch but does regular expression // matching. Deprecated. Remove before v1.0 release. SourceMatchRE MatchRegexps `yaml:"source_match_re,omitempty" json:"source_match_re,omitempty"` // SourceMatchers defines a set of label matchers that have to be fulfilled for source alerts. SourceMatchers Matchers `yaml:"source_matchers,omitempty" json:"source_matchers,omitempty"` // TargetMatch defines a set of labels that have to equal the given // value for target alerts. Deprecated. Remove before v1.0 release. TargetMatch map[string]string `yaml:"target_match,omitempty" json:"target_match,omitempty"` // TargetMatchRE defines pairs like TargetMatch but does regular expression // matching. Deprecated. Remove before v1.0 release. TargetMatchRE MatchRegexps `yaml:"target_match_re,omitempty" json:"target_match_re,omitempty"` // TargetMatchers defines a set of label matchers that have to be fulfilled for target alerts. TargetMatchers Matchers `yaml:"target_matchers,omitempty" json:"target_matchers,omitempty"` // A set of labels that must be equal between the source and target alert // for them to be a match. Equal []string `yaml:"equal,omitempty" json:"equal,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for InhibitRule. func (r InhibitRule) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain InhibitRule if err := unmarshal((plain)(r)); err != nil { return err } for k := range r.SourceMatch { if !model.LabelNameRE.MatchString(k) { return fmt.Errorf("invalid label name %q", k) } } for k := range r.TargetMatch { if !model.LabelNameRE.MatchString(k) { return fmt.Errorf("invalid label name %q", k) } } for _, l := range r.Equal { labelName := model.LabelName(l) if !compat.IsValidLabelName(labelName) { return fmt.Errorf("invalid label name %q in equal list", l) } } return nil } // Receiver configuration provides configuration on how to contact a receiver. type Receiver struct { // A unique identifier for this receiver. Name string `yaml:"name" json:"name"` DiscordConfigs []DiscordConfig `yaml:"discord_configs,omitempty" json:"discord_configs,omitempty"` EmailConfigs []EmailConfig `yaml:"email_configs,omitempty" json:"email_configs,omitempty"` PagerdutyConfigs []PagerdutyConfig `yaml:"pagerduty_configs,omitempty" json:"pagerduty_configs,omitempty"` SlackConfigs []SlackConfig `yaml:"slack_configs,omitempty" json:"slack_configs,omitempty"` WebhookConfigs []WebhookConfig `yaml:"webhook_configs,omitempty" json:"webhook_configs,omitempty"` OpsGenieConfigs []OpsGenieConfig `yaml:"opsgenie_configs,omitempty" json:"opsgenie_configs,omitempty"` WechatConfigs []WechatConfig `yaml:"wechat_configs,omitempty" json:"wechat_configs,omitempty"` PushoverConfigs []PushoverConfig `yaml:"pushover_configs,omitempty" json:"pushover_configs,omitempty"` VictorOpsConfigs []VictorOpsConfig `yaml:"victorops_configs,omitempty" json:"victorops_configs,omitempty"` SNSConfigs []SNSConfig `yaml:"sns_configs,omitempty" json:"sns_configs,omitempty"` TelegramConfigs []TelegramConfig `yaml:"telegram_configs,omitempty" json:"telegram_configs,omitempty"` WebexConfigs []WebexConfig `yaml:"webex_configs,omitempty" json:"webex_configs,omitempty"` MSTeamsConfigs []MSTeamsConfig `yaml:"msteams_configs,omitempty" json:"msteams_configs,omitempty"` MSTeamsV2Configs []MSTeamsV2Config `yaml:"msteamsv2_configs,omitempty" json:"msteamsv2_configs,omitempty"` JiraConfigs []JiraConfig `yaml:"jira_configs,omitempty" json:"jira_configs,omitempty"` RocketchatConfigs []RocketchatConfig `yaml:"rocketchat_configs,omitempty" json:"rocketchat_configs,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for Receiver. func (c Receiver) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain Receiver if err := unmarshal((plain)(c)); err != nil { return err } if c.Name == "" { return errors.New("missing name in receiver") } return nil } // MatchRegexps represents a map of Regexp. type MatchRegexps map[string]Regexp // UnmarshalYAML implements the yaml.Unmarshaler interface for MatchRegexps. func (m MatchRegexps) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain MatchRegexps if err := unmarshal((plain)(m)); err != nil { return err } for k, v := range m { if !model.LabelNameRE.MatchString(k) { return fmt.Errorf("invalid label name %q", k) } if v.Regexp == nil { return fmt.Errorf("invalid regexp value for %q", k) } } return nil } // Regexp encapsulates a regexp.Regexp and makes it YAML marshalable. type Regexp struct { regexp.Regexp original string } // UnmarshalYAML implements the yaml.Unmarshaler interface for Regexp. func (re Regexp) UnmarshalYAML(unmarshal func(interface{}) error) error { var s string if err := unmarshal(&s); err != nil { return err } regex, err := regexp.Compile("^(?:" + s + ")$") if err != nil { return err } re.Regexp = regex re.original = s return nil } // MarshalYAML implements the yaml.Marshaler interface for Regexp. func (re Regexp) MarshalYAML() (interface{}, error) { if re.original != "" { return re.original, nil } return nil, nil } // UnmarshalJSON implements the json.Unmarshaler interface for Regexp. func (re Regexp) UnmarshalJSON(data []byte) error { var s string if err := json.Unmarshal(data, &s); err != nil { return err } regex, err := regexp.Compile("^(?:" + s + ")$") if err != nil { return err } re.Regexp = regex re.original = s return nil } // MarshalJSON implements the json.Marshaler interface for Regexp. func (re Regexp) MarshalJSON() ([]byte, error) { if re.original != "" { return json.Marshal(re.original) } return []byte("null"), nil } // Matchers is label.Matchers with an added UnmarshalYAML method to implement the yaml.Unmarshaler interface // and MarshalYAML to implement the yaml.Marshaler interface. type Matchers labels.Matchers // UnmarshalYAML implements the yaml.Unmarshaler interface for Matchers. func (m Matchers) UnmarshalYAML(unmarshal func(interface{}) error) error { var lines []string if err := unmarshal(&lines); err != nil { return err } for _, line := range lines { pm, err := compat.Matchers(line, "config") if err != nil { return err } m = append(m, pm...) } sort.Sort(labels.Matchers(m)) return nil } // MarshalYAML implements the yaml.Marshaler interface for Matchers. func (m Matchers) MarshalYAML() (interface{}, error) { result := make([]string, len(m)) for i, matcher := range m { result[i] = matcher.String() } return result, nil } // UnmarshalJSON implements the json.Unmarshaler interface for Matchers. func (m Matchers) UnmarshalJSON(data []byte) error { var lines []string if err := json.Unmarshal(data, &lines); err != nil { return err } for _, line := range lines { pm, err := compat.Matchers(line, "config") if err != nil { return err } m = append(m, pm...) } sort.Sort(labels.Matchers(m)) return nil } // MarshalJSON implements the json.Marshaler interface for Matchers. func (m Matchers) MarshalJSON() ([]byte, error) { if len(m) == 0 { return []byte("[]"), nil } result := make([]string, len(m)) for i, matcher := range m { result[i] = matcher.String() } return json.Marshal(result) }	37.81 KB	2025-05-25 12:27
📄 config_test.go // Copyright 2016 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 config import ( "encoding/json" "net/url" "os" "reflect" "regexp" "strings" "testing" "time" commoncfg "github.com/prometheus/common/config" "github.com/prometheus/common/model" "github.com/prometheus/common/promslog" "github.com/stretchr/testify/require" "gopkg.in/yaml.v2" "github.com/prometheus/alertmanager/featurecontrol" "github.com/prometheus/alertmanager/matcher/compat" ) func TestLoadEmptyString(t testing.T) { var in string _, err := Load(in) expected := "no route provided in config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestDefaultReceiverExists(t testing.T) { in := ` route: group_wait: 30s ` _, err := Load(in) expected := "root route must specify a default receiver" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestReceiverNameIsUnique(t testing.T) { in := ` route: receiver: team-X receivers: - name: 'team-X' - name: 'team-X' ` _, err := Load(in) expected := "notification config name \"team-X\" is not unique" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestReceiverExists(t testing.T) { in := ` route: receiver: team-X receivers: - name: 'team-Y' ` _, err := Load(in) expected := "undefined receiver \"team-X\" used in route" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestReceiverExistsForDeepSubRoute(t testing.T) { in := ` route: receiver: team-X routes: - match: foo: bar routes: - match: foo: bar receiver: nonexistent receivers: - name: 'team-X' ` _, err := Load(in) expected := "undefined receiver \"nonexistent\" used in route" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestReceiverHasName(t testing.T) { in := ` route: receivers: - name: '' ` _, err := Load(in) expected := "missing name in receiver" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestMuteTimeExists(t testing.T) { in := ` route: receiver: team-Y routes: - match: severity: critical mute_time_intervals: - business_hours receivers: - name: 'team-Y' ` _, err := Load(in) expected := "undefined time interval \"business_hours\" used in route" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestActiveTimeExists(t testing.T) { in := ` route: receiver: team-Y routes: - match: severity: critical active_time_intervals: - business_hours receivers: - name: 'team-Y' ` _, err := Load(in) expected := "undefined time interval \"business_hours\" used in route" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestTimeIntervalHasName(t testing.T) { in := ` time_intervals: - name: time_intervals: - times: - start_time: '09:00' end_time: '17:00' receivers: - name: 'team-X-mails' route: receiver: 'team-X-mails' routes: - match: severity: critical mute_time_intervals: - business_hours ` _, err := Load(in) expected := "missing name in time interval" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestMuteTimeNoDuplicates(t testing.T) { in := ` mute_time_intervals: - name: duplicate time_intervals: - times: - start_time: '09:00' end_time: '17:00' - name: duplicate time_intervals: - times: - start_time: '10:00' end_time: '14:00' receivers: - name: 'team-X-mails' route: receiver: 'team-X-mails' routes: - match: severity: critical mute_time_intervals: - business_hours ` _, err := Load(in) expected := "mute time interval \"duplicate\" is not unique" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestGroupByHasNoDuplicatedLabels(t testing.T) { in := ` route: group_by: ['alertname', 'cluster', 'service', 'cluster'] receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "duplicated label \"cluster\" in group_by" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestWildcardGroupByWithOtherGroupByLabels(t testing.T) { in := ` route: group_by: ['alertname', 'cluster', '...'] receiver: team-X-mails receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "cannot have wildcard group_by (`...`) and other other labels at the same time" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestGroupByInvalidLabel(t testing.T) { in := ` route: group_by: ['-invalid-'] receiver: team-X-mails receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "invalid label name \"-invalid-\" in group_by list" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestRootRouteExists(t testing.T) { in := ` receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "no routes provided" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestRootRouteNoMuteTimes(t testing.T) { in := ` mute_time_intervals: - name: my_mute_time time_intervals: - times: - start_time: '09:00' end_time: '17:00' receivers: - name: 'team-X-mails' route: receiver: 'team-X-mails' mute_time_intervals: - my_mute_time ` _, err := Load(in) expected := "root route must not have any mute time intervals" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestRootRouteNoActiveTimes(t testing.T) { in := ` time_intervals: - name: my_active_time time_intervals: - times: - start_time: '09:00' end_time: '17:00' receivers: - name: 'team-X-mails' route: receiver: 'team-X-mails' active_time_intervals: - my_active_time ` _, err := Load(in) expected := "root route must not have any active time intervals" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestRootRouteHasNoMatcher(t testing.T) { testCases := []struct { name string in string }{ { name: "Test deprecated matchers on root route not allowed", in: ` route: receiver: 'team-X' match: severity: critical receivers: - name: 'team-X' `, }, { name: "Test matchers not allowed on root route", in: ` route: receiver: 'team-X' matchers: - severity=critical receivers: - name: 'team-X' `, }, } expected := "root route must not have any matchers" for _, tc := range testCases { t.Run(tc.name, func(t testing.T) { _, err := Load(tc.in) if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } }) } } func TestContinueErrorInRouteRoot(t testing.T) { in := ` route: receiver: team-X-mails continue: true receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "cannot have continue in root route" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestGroupIntervalIsGreaterThanZero(t testing.T) { in := ` route: receiver: team-X-mails group_interval: 0s receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "group_interval cannot be zero" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestRepeatIntervalIsGreaterThanZero(t testing.T) { in := ` route: receiver: team-X-mails repeat_interval: 0s receivers: - name: 'team-X-mails' ` _, err := Load(in) expected := "repeat_interval cannot be zero" if err == nil { t.Fatalf("no error returned, expected:\n%q", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%q\ngot:\n%q", expected, err.Error()) } } func TestHideConfigSecrets(t testing.T) { c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.good.yml", err) } // String method must not reveal authentication credentials. s := c.String() if strings.Count(s, "<secret>") != 13 \|\| strings.Contains(s, "mysecret") { t.Fatal("config's String method reveals authentication credentials.") } } func TestShowMarshalSecretValues(t testing.T) { MarshalSecretValue = true defer func() { MarshalSecretValue = false }() c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.good.yml", err) } // String method must reveal authentication credentials. s := c.String() if strings.Count(s, "<secret>") > 0 \|\| !strings.Contains(s, "mysecret") { t.Fatal("config's String method must reveal authentication credentials when MarshalSecretValue = true.") } } func TestJSONMarshal(t testing.T) { c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) } _, err = json.Marshal(c) if err != nil { t.Fatal("JSON Marshaling failed:", err) } } func TestJSONMarshalHideSecret(t testing.T) { test := struct { S Secret }{ S: Secret("test"), } c, err := json.Marshal(test) if err != nil { t.Fatal(err) } // u003c -> "<" // u003e -> ">" require.Equal(t, "{\"S\":\"\\u003csecret\\u003e\"}", string(c), "Secret not properly elided.") } func TestJSONMarshalShowSecret(t testing.T) { MarshalSecretValue = true defer func() { MarshalSecretValue = false }() test := struct { S Secret }{ S: Secret("test"), } c, err := json.Marshal(test) if err != nil { t.Fatal(err) } require.Equal(t, "{\"S\":\"test\"}", string(c), "config's String method must reveal authentication credentials when MarshalSecretValue = true.") } func TestJSONMarshalHideSecretURL(t testing.T) { urlp, err := url.Parse("http://example.com/") if err != nil { t.Fatal(err) } u := &SecretURL{urlp} c, err := json.Marshal(u) if err != nil { t.Fatal(err) } // u003c -> "<" // u003e -> ">" require.Equal(t, "\"\\u003csecret\\u003e\"", string(c), "SecretURL not properly elided in JSON.") // Check that the marshaled data can be unmarshaled again. out := &SecretURL{} err = json.Unmarshal(c, out) if err != nil { t.Fatal(err) } c, err = yaml.Marshal(u) if err != nil { t.Fatal(err) } require.Equal(t, "<secret>\n", string(c), "SecretURL not properly elided in YAML.") // Check that the marshaled data can be unmarshaled again. out = &SecretURL{} err = yaml.Unmarshal(c, &out) if err != nil { t.Fatal(err) } } func TestJSONMarshalShowSecretURL(t testing.T) { MarshalSecretValue = true defer func() { MarshalSecretValue = false }() urlp, err := url.Parse("http://example.com/") if err != nil { t.Fatal(err) } u := &SecretURL{urlp} c, err := json.Marshal(u) if err != nil { t.Fatal(err) } require.Equal(t, "\"http://example.com/\"", string(c), "config's String method must reveal authentication credentials when MarshalSecretValue = true.") } func TestUnmarshalSecretURL(t testing.T) { b := []byte(`"http://example.com/se cret"`) var u SecretURL err := json.Unmarshal(b, &u) if err != nil { t.Fatal(err) } require.Equal(t, "http://example.com/se%20cret", u.String(), "SecretURL not properly unmarshaled in JSON.") err = yaml.Unmarshal(b, &u) if err != nil { t.Fatal(err) } require.Equal(t, "http://example.com/se%20cret", u.String(), "SecretURL not properly unmarshaled in YAML.") } func TestHideSecretURL(t testing.T) { b := []byte(`"://wrongurl/"`) var u SecretURL err := json.Unmarshal(b, &u) require.Error(t, err) require.NotContains(t, err.Error(), "wrongurl") } func TestShowMarshalSecretURL(t testing.T) { MarshalSecretValue = true defer func() { MarshalSecretValue = false }() b := []byte(`"://wrongurl/"`) var u SecretURL err := json.Unmarshal(b, &u) require.Error(t, err) require.Contains(t, err.Error(), "wrongurl") } func TestMarshalURL(t testing.T) { for name, tc := range map[string]struct { input URL expectedJSON string expectedYAML string }{ "url": { input: mustParseURL("http://example.com/"), expectedJSON: "\"http://example.com/\"", expectedYAML: "http://example.com/\n", }, "wrapped nil value": { input: &URL{}, expectedJSON: "null", expectedYAML: "null\n", }, "wrapped empty URL": { input: &URL{&url.URL{}}, expectedJSON: "\"\"", expectedYAML: "\"\"\n", }, } { t.Run(name, func(t testing.T) { j, err := json.Marshal(tc.input) require.NoError(t, err) require.Equal(t, tc.expectedJSON, string(j), "URL not properly marshaled into JSON.") y, err := yaml.Marshal(tc.input) require.NoError(t, err) require.Equal(t, tc.expectedYAML, string(y), "URL not properly marshaled into YAML.") }) } } func TestUnmarshalNilURL(t testing.T) { b := []byte(`null`) { var u URL err := json.Unmarshal(b, &u) require.Error(t, err, "unsupported scheme \"\" for URL") require.Nil(t, nil, u.URL) } { var u URL err := yaml.Unmarshal(b, &u) require.NoError(t, err) require.Nil(t, nil, u.URL) // UnmarshalYAML is not even called when unmarshalling "null". } } func TestUnmarshalEmptyURL(t testing.T) { b := []byte(`""`) { var u URL err := json.Unmarshal(b, &u) require.Error(t, err, "unsupported scheme \"\" for URL") require.Equal(t, (url.URL)(nil), u.URL) } { var u URL err := yaml.Unmarshal(b, &u) require.Error(t, err, "unsupported scheme \"\" for URL") require.Equal(t, (url.URL)(nil), u.URL) } } func TestUnmarshalURL(t testing.T) { b := []byte(`"http://example.com/a b"`) var u URL err := json.Unmarshal(b, &u) if err != nil { t.Fatal(err) } require.Equal(t, "http://example.com/a%20b", u.String(), "URL not properly unmarshaled in JSON.") err = yaml.Unmarshal(b, &u) if err != nil { t.Fatal(err) } require.Equal(t, "http://example.com/a%20b", u.String(), "URL not properly unmarshaled in YAML.") } func TestUnmarshalInvalidURL(t testing.T) { for _, b := range [][]byte{ []byte(`"://example.com"`), []byte(`"http:example.com"`), []byte(`"telnet://example.com"`), } { var u URL err := json.Unmarshal(b, &u) if err == nil { t.Errorf("Expected an error unmarshaling %q from JSON", string(b)) } err = yaml.Unmarshal(b, &u) if err == nil { t.Errorf("Expected an error unmarshaling %q from YAML", string(b)) } t.Logf("%s", err) } } func TestUnmarshalRelativeURL(t testing.T) { b := []byte(`"/home"`) var u URL err := json.Unmarshal(b, &u) if err == nil { t.Errorf("Expected an error parsing URL") } err = yaml.Unmarshal(b, &u) if err == nil { t.Errorf("Expected an error parsing URL") } } func TestMarshalRegexpWithNilValue(t testing.T) { r := &Regexp{} out, err := json.Marshal(r) require.NoError(t, err) require.Equal(t, "null", string(out)) out, err = yaml.Marshal(r) require.NoError(t, err) require.Equal(t, "null\n", string(out)) } func TestUnmarshalEmptyRegexp(t testing.T) { b := []byte(`""`) { var re Regexp err := json.Unmarshal(b, &re) require.NoError(t, err) require.Equal(t, regexp.MustCompile("^(?:)$"), re.Regexp) require.Equal(t, "", re.original) } { var re Regexp err := yaml.Unmarshal(b, &re) require.NoError(t, err) require.Equal(t, regexp.MustCompile("^(?:)$"), re.Regexp) require.Equal(t, "", re.original) } } func TestUnmarshalNullRegexp(t testing.T) { input := []byte(`null`) { var re Regexp err := json.Unmarshal(input, &re) require.NoError(t, err) require.Nil(t, nil, re.Regexp) require.Equal(t, "", re.original) } { var re Regexp err := yaml.Unmarshal(input, &re) // Interestingly enough, unmarshalling `null` in YAML doesn't even call UnmarshalYAML. require.NoError(t, err) require.Nil(t, re.Regexp) require.Equal(t, "", re.original) } } func TestMarshalEmptyMatchers(t testing.T) { r := Matchers{} out, err := json.Marshal(r) require.NoError(t, err) require.Equal(t, "[]", string(out)) out, err = yaml.Marshal(r) require.NoError(t, err) require.Equal(t, "[]\n", string(out)) } func TestJSONUnmarshal(t testing.T) { c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) } _, err = json.Marshal(c) if err != nil { t.Fatal("JSON Marshaling failed:", err) } } func TestMarshalIdempotency(t testing.T) { c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) } marshaled, err := yaml.Marshal(c) if err != nil { t.Fatal("YAML Marshaling failed:", err) } c = new(Config) if err := yaml.Unmarshal(marshaled, c); err != nil { t.Fatal("YAML Unmarshaling failed:", err) } } func TestGroupByAllNotMarshaled(t testing.T) { in := ` route: receiver: team-X-mails group_by: [...] receivers: - name: 'team-X-mails' ` c, err := Load(in) if err != nil { t.Fatal("load failed:", err) } dat, err := yaml.Marshal(c) if err != nil { t.Fatal("YAML Marshaling failed:", err) } if strings.Contains(string(dat), "groupbyall") { t.Fatal("groupbyall found in config file") } } func TestEmptyFieldsAndRegex(t testing.T) { boolFoo := true regexpFoo := Regexp{ Regexp: regexp.MustCompile("^(?:^(foo1\|foo2\|baz)$)$"), original: "^(foo1\|foo2\|baz)$", } expectedConf := Config{ Global: &GlobalConfig{ HTTPConfig: &commoncfg.HTTPClientConfig{ FollowRedirects: true, EnableHTTP2: true, }, ResolveTimeout: model.Duration(5 time.Minute), SMTPSmarthost: HostPort{Host: "localhost", Port: "25"}, SMTPFrom: "alertmanager@example.org", SMTPTLSConfig: &commoncfg.TLSConfig{ InsecureSkipVerify: false, }, SlackAPIURL: (SecretURL)(mustParseURL("http://slack.example.com/")), SMTPRequireTLS: true, PagerdutyURL: mustParseURL("https://events.pagerduty.com/v2/enqueue"), OpsGenieAPIURL: mustParseURL("https://api.opsgenie.com/"), WeChatAPIURL: mustParseURL("https://qyapi.weixin.qq.com/cgi-bin/"), VictorOpsAPIURL: mustParseURL("https://alert.victorops.com/integrations/generic/20131114/alert/"), TelegramAPIUrl: mustParseURL("https://api.telegram.org"), WebexAPIURL: mustParseURL("https://webexapis.com/v1/messages"), RocketchatAPIURL: mustParseURL("https://open.rocket.chat/"), }, Templates: []string{ "/etc/alertmanager/template/.tmpl", }, Route: &Route{ Receiver: "team-X-mails", GroupBy: []model.LabelName{ "alertname", "cluster", "service", }, GroupByStr: []string{ "alertname", "cluster", "service", }, GroupByAll: false, Routes: []Route{ { Receiver: "team-X-mails", MatchRE: map[string]Regexp{ "service": regexpFoo, }, }, }, }, Receivers: []Receiver{ { Name: "team-X-mails", EmailConfigs: []EmailConfig{ { To: "team-X+alerts@example.org", From: "alertmanager@example.org", Smarthost: HostPort{Host: "localhost", Port: "25"}, HTML: "{{ template \"email.default.html\" . }}", RequireTLS: &boolFoo, TLSConfig: &commoncfg.TLSConfig{ InsecureSkipVerify: false, }, }, }, }, }, } // Load a non-empty configuration to ensure that all fields are overwritten. // See https://github.com/prometheus/alertmanager/issues/1649. _, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Errorf("Error parsing %s: %s", "testdata/conf.good.yml", err) } config, err := LoadFile("testdata/conf.empty-fields.yml") if err != nil { t.Errorf("Error parsing %s: %s", "testdata/conf.empty-fields.yml", err) } configGot, err := yaml.Marshal(config) if err != nil { t.Fatal("YAML Marshaling failed:", err) } configExp, err := yaml.Marshal(expectedConf) if err != nil { t.Fatalf("%s", err) } if !reflect.DeepEqual(configGot, configExp) { t.Fatalf("%s: unexpected config result: \n\n%s\n expected\n\n%s", "testdata/conf.empty-fields.yml", configGot, configExp) } } func TestGlobalAndLocalHTTPConfig(t testing.T) { config, err := LoadFile("testdata/conf.http-config.good.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf-http-config.good.yml", err) } if config.Global.HTTPConfig.FollowRedirects { t.Fatalf("global HTTP config should not follow redirects") } if !config.Receivers[0].SlackConfigs[0].HTTPConfig.FollowRedirects { t.Fatalf("global HTTP config should follow redirects") } } func TestSMTPHello(t testing.T) { c, err := LoadFile("testdata/conf.good.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.good.yml", err) } const refValue = "host.example.org" hostName := c.Global.SMTPHello if hostName != refValue { t.Errorf("Invalid SMTP Hello hostname: %s\nExpected: %s", hostName, refValue) } } func TestSMTPBothPasswordAndFile(t testing.T) { _, err := LoadFile("testdata/conf.smtp-both-password-and-file.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.smtp-both-password-and-file.yml", err) } if err.Error() != "at most one of smtp_auth_password & smtp_auth_password_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of auth_password & auth_password_file must be configured", err.Error()) } } func TestSMTPNoUsernameOrPassword(t testing.T) { _, err := LoadFile("testdata/conf.smtp-no-username-or-password.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.smtp-no-username-or-password.yml", err) } } func TestGlobalAndLocalSMTPPassword(t testing.T) { config, err := LoadFile("testdata/conf.smtp-password-global-and-local.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.smtp-password-global-and-local.yml", err) } require.Equal(t, "/tmp/globaluserpassword", config.Receivers[0].EmailConfigs[0].AuthPasswordFile, "first email should use password file /tmp/globaluserpassword") require.Emptyf(t, config.Receivers[0].EmailConfigs[0].AuthPassword, "password field should be empty when file provided") require.Equal(t, "/tmp/localuser1password", config.Receivers[0].EmailConfigs[1].AuthPasswordFile, "second email should use password file /tmp/localuser1password") require.Emptyf(t, config.Receivers[0].EmailConfigs[1].AuthPassword, "password field should be empty when file provided") require.Equal(t, Secret("mysecret"), config.Receivers[0].EmailConfigs[2].AuthPassword, "third email should use password mysecret") require.Emptyf(t, config.Receivers[0].EmailConfigs[2].AuthPasswordFile, "file field should be empty when password provided") } func TestGroupByAll(t testing.T) { c, err := LoadFile("testdata/conf.group-by-all.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.group-by-all.yml", err) } if !c.Route.GroupByAll { t.Errorf("Invalid group by all param: expected to by true") } } func TestVictorOpsDefaultAPIKey(t testing.T) { conf, err := LoadFile("testdata/conf.victorops-default-apikey.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.victorops-default-apikey.yml", err) } defaultKey := conf.Global.VictorOpsAPIKey overrideKey := Secret("qwe456") if defaultKey != conf.Receivers[0].VictorOpsConfigs[0].APIKey { t.Fatalf("Invalid victorops key: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKey, defaultKey) } if overrideKey != conf.Receivers[1].VictorOpsConfigs[0].APIKey { t.Errorf("Invalid victorops key: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKey, string(overrideKey)) } } func TestVictorOpsDefaultAPIKeyFile(t testing.T) { conf, err := LoadFile("testdata/conf.victorops-default-apikey-file.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.victorops-default-apikey-file.yml", err) } defaultKey := conf.Global.VictorOpsAPIKeyFile overrideKey := "/override_file" if defaultKey != conf.Receivers[0].VictorOpsConfigs[0].APIKeyFile { t.Fatalf("Invalid VictorOps key_file: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKeyFile, defaultKey) } if overrideKey != conf.Receivers[1].VictorOpsConfigs[0].APIKeyFile { t.Errorf("Invalid VictorOps key_file: %s\nExpected: %s", conf.Receivers[0].VictorOpsConfigs[0].APIKeyFile, overrideKey) } } func TestVictorOpsBothAPIKeyAndFile(t testing.T) { _, err := LoadFile("testdata/conf.victorops-both-file-and-apikey.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.victorops-both-file-and-apikey.yml", err) } if err.Error() != "at most one of victorops_api_key & victorops_api_key_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of victorops_api_key & victorops_api_key_file must be configured", err.Error()) } } func TestVictorOpsNoAPIKey(t testing.T) { _, err := LoadFile("testdata/conf.victorops-no-apikey.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.victorops-no-apikey.yml", err) } if err.Error() != "no global VictorOps API Key set" { t.Errorf("Expected: %s\nGot: %s", "no global VictorOps API Key set", err.Error()) } } func TestOpsGenieDefaultAPIKey(t testing.T) { conf, err := LoadFile("testdata/conf.opsgenie-default-apikey.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.opsgenie-default-apikey.yml", err) } defaultKey := conf.Global.OpsGenieAPIKey if defaultKey != conf.Receivers[0].OpsGenieConfigs[0].APIKey { t.Fatalf("Invalid OpsGenie key: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKey, defaultKey) } if defaultKey == conf.Receivers[1].OpsGenieConfigs[0].APIKey { t.Errorf("Invalid OpsGenie key: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKey, "qwe456") } } func TestOpsGenieDefaultAPIKeyFile(t testing.T) { conf, err := LoadFile("testdata/conf.opsgenie-default-apikey-file.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.opsgenie-default-apikey-file.yml", err) } defaultKey := conf.Global.OpsGenieAPIKeyFile if defaultKey != conf.Receivers[0].OpsGenieConfigs[0].APIKeyFile { t.Fatalf("Invalid OpsGenie key_file: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKeyFile, defaultKey) } if defaultKey == conf.Receivers[1].OpsGenieConfigs[0].APIKeyFile { t.Errorf("Invalid OpsGenie key_file: %s\nExpected: %s", conf.Receivers[0].OpsGenieConfigs[0].APIKeyFile, "/override_file") } } func TestOpsGenieBothAPIKeyAndFile(t testing.T) { _, err := LoadFile("testdata/conf.opsgenie-both-file-and-apikey.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.opsgenie-both-file-and-apikey.yml", err) } if err.Error() != "at most one of opsgenie_api_key & opsgenie_api_key_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of opsgenie_api_key & opsgenie_api_key_file must be configured", err.Error()) } } func TestOpsGenieNoAPIKey(t testing.T) { _, err := LoadFile("testdata/conf.opsgenie-no-apikey.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.opsgenie-no-apikey.yml", err) } if err.Error() != "no global OpsGenie API Key set either inline or in a file" { t.Errorf("Expected: %s\nGot: %s", "no global OpsGenie API Key set either inline or in a file", err.Error()) } } func TestOpsGenieDeprecatedTeamSpecified(t testing.T) { _, err := LoadFile("testdata/conf.opsgenie-default-apikey-old-team.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.opsgenie-default-apikey-old-team.yml", err) } const expectedErr = `yaml: unmarshal errors: line 16: field teams not found in type config.plain` if err.Error() != expectedErr { t.Errorf("Expected: %s\nGot: %s", expectedErr, err.Error()) } } func TestSlackBothAPIURLAndFile(t testing.T) { _, err := LoadFile("testdata/conf.slack-both-file-and-url.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.slack-both-file-and-url.yml", err) } if err.Error() != "at most one of slack_api_url & slack_api_url_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of slack_api_url & slack_api_url_file must be configured", err.Error()) } } func TestSlackNoAPIURL(t testing.T) { _, err := LoadFile("testdata/conf.slack-no-api-url.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.slack-no-api-url.yml", err) } if err.Error() != "no global Slack API URL set either inline or in a file" { t.Errorf("Expected: %s\nGot: %s", "no global Slack API URL set either inline or in a file", err.Error()) } } func TestSlackGlobalAPIURLFile(t testing.T) { conf, err := LoadFile("testdata/conf.slack-default-api-url-file.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.slack-default-api-url-file.yml", err) } // no override firstConfig := conf.Receivers[0].SlackConfigs[0] if firstConfig.APIURLFile != "/global_file" \|\| firstConfig.APIURL != nil { t.Fatalf("Invalid Slack URL file: %s\nExpected: %s", firstConfig.APIURLFile, "/global_file") } // override the file secondConfig := conf.Receivers[0].SlackConfigs[1] if secondConfig.APIURLFile != "/override_file" \|\| secondConfig.APIURL != nil { t.Fatalf("Invalid Slack URL file: %s\nExpected: %s", secondConfig.APIURLFile, "/override_file") } // override the global file with an inline URL thirdConfig := conf.Receivers[0].SlackConfigs[2] if thirdConfig.APIURL.String() != "http://mysecret.example.com/" \|\| thirdConfig.APIURLFile != "" { t.Fatalf("Invalid Slack URL: %s\nExpected: %s", thirdConfig.APIURL.String(), "http://mysecret.example.com/") } } func TestValidSNSConfig(t testing.T) { _, err := LoadFile("testdata/conf.sns-topic-arn.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.sns-topic-arn.yml\"", err) } } func TestInvalidSNSConfig(t testing.T) { _, err := LoadFile("testdata/conf.sns-invalid.yml") if err == nil { t.Fatalf("expected error with missing fields on SNS config") } const expectedErr = `must provide either a Target ARN, Topic ARN, or Phone Number for SNS config` if err.Error() != expectedErr { t.Errorf("Expected: %s\nGot: %s", expectedErr, err.Error()) } } func TestRocketchatDefaultToken(t testing.T) { conf, err := LoadFile("testdata/conf.rocketchat-default-token.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.rocketchat-default-token.yml", err) } defaultToken := conf.Global.RocketchatToken overrideToken := Secret("token456") if defaultToken != conf.Receivers[0].RocketchatConfigs[0].Token { t.Fatalf("Invalid rocketchat key: %s\nExpected: %s", string(conf.Receivers[0].RocketchatConfigs[0].Token), string(defaultToken)) } if overrideToken != conf.Receivers[1].RocketchatConfigs[0].Token { t.Errorf("Invalid rocketchat key: %s\nExpected: %s", string(conf.Receivers[0].RocketchatConfigs[0].Token), string(overrideToken)) } } func TestRocketchatDefaultTokenID(t testing.T) { conf, err := LoadFile("testdata/conf.rocketchat-default-token.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.rocketchat-default-token.yml", err) } defaultTokenID := conf.Global.RocketchatTokenID overrideTokenID := Secret("id456") if defaultTokenID != conf.Receivers[0].RocketchatConfigs[0].TokenID { t.Fatalf("Invalid rocketchat key: %s\nExpected: %s", string(conf.Receivers[0].RocketchatConfigs[0].TokenID), string(defaultTokenID)) } if overrideTokenID != conf.Receivers[1].RocketchatConfigs[0].TokenID { t.Errorf("Invalid rocketchat key: %s\nExpected: %s", string(conf.Receivers[0].RocketchatConfigs[0].TokenID), string(overrideTokenID)) } } func TestRocketchatDefaultTokenFile(t testing.T) { conf, err := LoadFile("testdata/conf.rocketchat-default-token-file.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.rocketchat-default-token-file.yml", err) } defaultTokenFile := conf.Global.RocketchatTokenFile overrideTokenFile := "/override_file" if defaultTokenFile != conf.Receivers[0].RocketchatConfigs[0].TokenFile { t.Fatalf("Invalid Rocketchat key_file: %s\nExpected: %s", conf.Receivers[0].RocketchatConfigs[0].TokenFile, defaultTokenFile) } if overrideTokenFile != conf.Receivers[1].RocketchatConfigs[0].TokenFile { t.Errorf("Invalid Rocketchat key_file: %s\nExpected: %s", conf.Receivers[0].RocketchatConfigs[0].TokenFile, overrideTokenFile) } } func TestRocketchatDefaultIDTokenFile(t testing.T) { conf, err := LoadFile("testdata/conf.rocketchat-default-token-file.yml") if err != nil { t.Fatalf("Error parsing %s: %s", "testdata/conf.rocketchat-default-token-file.yml", err) } defaultTokenIDFile := conf.Global.RocketchatTokenIDFile overrideTokenIDFile := "/override_file" if defaultTokenIDFile != conf.Receivers[0].RocketchatConfigs[0].TokenIDFile { t.Fatalf("Invalid Rocketchat key_file: %s\nExpected: %s", conf.Receivers[0].RocketchatConfigs[0].TokenIDFile, defaultTokenIDFile) } if overrideTokenIDFile != conf.Receivers[1].RocketchatConfigs[0].TokenIDFile { t.Errorf("Invalid Rocketchat key_file: %s\nExpected: %s", conf.Receivers[0].RocketchatConfigs[0].TokenIDFile, overrideTokenIDFile) } } func TestRocketchatBothTokenAndTokenFile(t testing.T) { _, err := LoadFile("testdata/conf.rocketchat-both-token-and-tokenfile.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.rocketchat-both-token-and-tokenfile.yml", err) } if err.Error() != "at most one of rocketchat_token & rocketchat_token_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of rocketchat_token & rocketchat_token_file must be configured", err.Error()) } } func TestRocketchatBothTokenIDAndTokenIDFile(t testing.T) { _, err := LoadFile("testdata/conf.rocketchat-both-tokenid-and-tokenidfile.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.rocketchat-both-tokenid-and-tokenidfile.yml", err) } if err.Error() != "at most one of rocketchat_token_id & rocketchat_token_id_file must be configured" { t.Errorf("Expected: %s\nGot: %s", "at most one of rocketchat_token_id & rocketchat_token_id_file must be configured", err.Error()) } } func TestRocketchatNoToken(t testing.T) { _, err := LoadFile("testdata/conf.rocketchat-no-token.yml") if err == nil { t.Fatalf("Expected an error parsing %s: %s", "testdata/conf.rocketchat-no-token.yml", err) } if err.Error() != "no global Rocketchat Token set either inline or in a file" { t.Errorf("Expected: %s\nGot: %s", "no global Rocketchat Token set either inline or in a file", err.Error()) } } func TestUnmarshalHostPort(t testing.T) { for _, tc := range []struct { in string exp HostPort jsonOut string yamlOut string err bool }{ { in: `""`, exp: HostPort{}, yamlOut: `"" `, jsonOut: `""`, }, { in: `"localhost:25"`, exp: HostPort{Host: "localhost", Port: "25"}, yamlOut: `localhost:25 `, jsonOut: `"localhost:25"`, }, { in: `":25"`, exp: HostPort{Host: "", Port: "25"}, yamlOut: `:25 `, jsonOut: `":25"`, }, { in: `"localhost"`, err: true, }, { in: `"localhost:"`, err: true, }, } { tc := tc t.Run(tc.in, func(t testing.T) { hp := HostPort{} err := yaml.Unmarshal([]byte(tc.in), &hp) if tc.err { require.Error(t, err) return } require.NoError(t, err) require.Equal(t, tc.exp, hp) b, err := yaml.Marshal(&hp) require.NoError(t, err) require.Equal(t, tc.yamlOut, string(b)) b, err = json.Marshal(&hp) require.NoError(t, err) require.Equal(t, tc.jsonOut, string(b)) }) } } func TestNilRegexp(t testing.T) { for _, tc := range []struct { file string errMsg string }{ { file: "testdata/conf.nil-match_re-route.yml", errMsg: "invalid_label", }, { file: "testdata/conf.nil-source_match_re-inhibition.yml", errMsg: "invalid_source_label", }, { file: "testdata/conf.nil-target_match_re-inhibition.yml", errMsg: "invalid_target_label", }, } { t.Run(tc.file, func(t testing.T) { _, err := os.Stat(tc.file) require.NoError(t, err) _, err = LoadFile(tc.file) require.Error(t, err) require.Contains(t, err.Error(), tc.errMsg) }) } } func TestInhibitRuleEqual(t testing.T) { c, err := LoadFile("testdata/conf.inhibit-equal.yml") require.NoError(t, err) // The inhibition rule should have the expected equal labels. require.Len(t, c.InhibitRules, 1) r := c.InhibitRules[0] require.Equal(t, []string{"qux", "corge"}, r.Equal) // Should not be able to load configuration with UTF-8 in equals list. _, err = LoadFile("testdata/conf.inhibit-equal-utf8.yml") require.Error(t, err) require.Equal(t, "invalid label name \"qux🙂\" in equal list", err.Error()) // Change the mode to UTF-8 mode. ff, err := featurecontrol.NewFlags(promslog.NewNopLogger(), featurecontrol.FeatureUTF8StrictMode) require.NoError(t, err) compat.InitFromFlags(promslog.NewNopLogger(), ff) // Restore the mode to classic at the end of the test. ff, err = featurecontrol.NewFlags(promslog.NewNopLogger(), featurecontrol.FeatureClassicMode) require.NoError(t, err) defer compat.InitFromFlags(promslog.NewNopLogger(), ff) c, err = LoadFile("testdata/conf.inhibit-equal.yml") require.NoError(t, err) // The inhibition rule should have the expected equal labels. require.Len(t, c.InhibitRules, 1) r = c.InhibitRules[0] require.Equal(t, []string{"qux", "corge"}, r.Equal) // Should also be able to load configuration with UTF-8 in equals list. c, err = LoadFile("testdata/conf.inhibit-equal-utf8.yml") require.NoError(t, err) // The inhibition rule should have the expected equal labels. require.Len(t, c.InhibitRules, 1) r = c.InhibitRules[0] require.Equal(t, []string{"qux🙂", "corge"}, r.Equal) }	39.25 KB	2025-05-25 12:27
📄 coordinator.go // Copyright 2019 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 config import ( "crypto/md5" "encoding/binary" "log/slog" "sync" "github.com/prometheus/client_golang/prometheus" ) // Coordinator coordinates Alertmanager configurations beyond the lifetime of a // single configuration. type Coordinator struct { configFilePath string logger slog.Logger // Protects config and subscribers mutex sync.Mutex config Config subscribers []func(Config) error configHashMetric prometheus.Gauge configSuccessMetric prometheus.Gauge configSuccessTimeMetric prometheus.Gauge } // NewCoordinator returns a new coordinator with the given configuration file // path. It does not yet load the configuration from file. This is done in // `Reload()`. func NewCoordinator(configFilePath string, r prometheus.Registerer, l slog.Logger) Coordinator { c := &Coordinator{ configFilePath: configFilePath, logger: l, } c.registerMetrics(r) return c } func (c Coordinator) registerMetrics(r prometheus.Registerer) { configHash := prometheus.NewGauge(prometheus.GaugeOpts{ Name: "alertmanager_config_hash", Help: "Hash of the currently loaded alertmanager configuration. Note that this is not a cryptographically strong hash.", }) configSuccess := prometheus.NewGauge(prometheus.GaugeOpts{ Name: "alertmanager_config_last_reload_successful", Help: "Whether the last configuration reload attempt was successful.", }) configSuccessTime := prometheus.NewGauge(prometheus.GaugeOpts{ Name: "alertmanager_config_last_reload_success_timestamp_seconds", Help: "Timestamp of the last successful configuration reload.", }) r.MustRegister(configHash, configSuccess, configSuccessTime) c.configHashMetric = configHash c.configSuccessMetric = configSuccess c.configSuccessTimeMetric = configSuccessTime } // Subscribe subscribes the given Subscribers to configuration changes. func (c Coordinator) Subscribe(ss ...func(Config) error) { c.mutex.Lock() defer c.mutex.Unlock() c.subscribers = append(c.subscribers, ss...) } func (c Coordinator) notifySubscribers() error { for _, s := range c.subscribers { if err := s(c.config); err != nil { return err } } return nil } // loadFromFile triggers a configuration load, discarding the old configuration. func (c Coordinator) loadFromFile() error { conf, err := LoadFile(c.configFilePath) if err != nil { return err } c.config = conf return nil } // Reload triggers a configuration reload from file and notifies all // configuration change subscribers. func (c *Coordinator) Reload() error { c.mutex.Lock() defer c.mutex.Unlock() c.logger.Info( "Loading configuration file", "file", c.configFilePath, ) if err := c.loadFromFile(); err != nil { c.logger.Error( "Loading configuration file failed", "file", c.configFilePath, "err", err, ) c.configSuccessMetric.Set(0) return err } c.logger.Info( "Completed loading of configuration file", "file", c.configFilePath, ) if err := c.notifySubscribers(); err != nil { c.logger.Error( "one or more config change subscribers failed to apply new config", "file", c.configFilePath, "err", err, ) c.configSuccessMetric.Set(0) return err } c.configSuccessMetric.Set(1) c.configSuccessTimeMetric.SetToCurrentTime() hash := md5HashAsMetricValue([]byte(c.config.original)) c.configHashMetric.Set(hash) return nil } func md5HashAsMetricValue(data []byte) float64 { sum := md5.Sum(data) // We only want 48 bits as a float64 only has a 53 bit mantissa. smallSum := sum[0:6] bytes := make([]byte, 8) copy(bytes, smallSum) return float64(binary.LittleEndian.Uint64(bytes)) }	4.14 KB	2025-05-25 12:27
📄 coordinator_test.go // Copyright 2019 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 config import ( "errors" "testing" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/promslog" ) type fakeRegisterer struct { registeredCollectors []prometheus.Collector } func (r fakeRegisterer) Register(prometheus.Collector) error { return nil } func (r fakeRegisterer) MustRegister(c ...prometheus.Collector) { r.registeredCollectors = append(r.registeredCollectors, c...) } func (r fakeRegisterer) Unregister(prometheus.Collector) bool { return false } func TestCoordinatorRegistersMetrics(t testing.T) { fr := fakeRegisterer{} NewCoordinator("testdata/conf.good.yml", &fr, promslog.NewNopLogger()) if len(fr.registeredCollectors) == 0 { t.Error("expected NewCoordinator to register metrics on the given registerer") } } func TestCoordinatorNotifiesSubscribers(t testing.T) { callBackCalled := false c := NewCoordinator("testdata/conf.good.yml", prometheus.NewRegistry(), promslog.NewNopLogger()) c.Subscribe(func(Config) error { callBackCalled = true return nil }) err := c.Reload() if err != nil { t.Fatal(err) } if !callBackCalled { t.Fatal("expected coordinator.Reload() to call subscribers") } } func TestCoordinatorFailReloadWhenSubscriberFails(t testing.T) { errMessage := "something happened" c := NewCoordinator("testdata/conf.good.yml", prometheus.NewRegistry(), promslog.NewNopLogger()) c.Subscribe(func(Config) error { return errors.New(errMessage) }) err := c.Reload() if err == nil { t.Fatal("expected reload to throw an error") } if err.Error() != errMessage { t.Fatalf("expected error message %q but got %q", errMessage, err) } }	2.19 KB	2025-05-25 12:27
📄 notifiers.go // Copyright 2015 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 config import ( "errors" "fmt" "net/textproto" "regexp" "strings" "text/template" "time" commoncfg "github.com/prometheus/common/config" "github.com/prometheus/common/model" "github.com/prometheus/sigv4" ) var ( // DefaultWebhookConfig defines default values for Webhook configurations. DefaultWebhookConfig = WebhookConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, } // DefaultWebexConfig defines default values for Webex configurations. DefaultWebexConfig = WebexConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Message: `{{ template "webex.default.message" . }}`, } // DefaultDiscordConfig defines default values for Discord configurations. DefaultDiscordConfig = DiscordConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Title: `{{ template "discord.default.title" . }}`, Message: `{{ template "discord.default.message" . }}`, } // DefaultEmailConfig defines default values for Email configurations. DefaultEmailConfig = EmailConfig{ NotifierConfig: NotifierConfig{ VSendResolved: false, }, HTML: `{{ template "email.default.html" . }}`, Text: ``, } // DefaultEmailSubject defines the default Subject header of an Email. DefaultEmailSubject = `{{ template "email.default.subject" . }}` // DefaultPagerdutyDetails defines the default values for PagerDuty details. DefaultPagerdutyDetails = map[string]string{ "firing": `{{ template "pagerduty.default.instances" .Alerts.Firing }}`, "resolved": `{{ template "pagerduty.default.instances" .Alerts.Resolved }}`, "num_firing": `{{ .Alerts.Firing \| len }}`, "num_resolved": `{{ .Alerts.Resolved \| len }}`, } // DefaultPagerdutyConfig defines default values for PagerDuty configurations. DefaultPagerdutyConfig = PagerdutyConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Description: `{{ template "pagerduty.default.description" .}}`, Client: `{{ template "pagerduty.default.client" . }}`, ClientURL: `{{ template "pagerduty.default.clientURL" . }}`, } // DefaultSlackConfig defines default values for Slack configurations. DefaultSlackConfig = SlackConfig{ NotifierConfig: NotifierConfig{ VSendResolved: false, }, Color: `{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}`, Username: `{{ template "slack.default.username" . }}`, Title: `{{ template "slack.default.title" . }}`, TitleLink: `{{ template "slack.default.titlelink" . }}`, IconEmoji: `{{ template "slack.default.iconemoji" . }}`, IconURL: `{{ template "slack.default.iconurl" . }}`, Pretext: `{{ template "slack.default.pretext" . }}`, Text: `{{ template "slack.default.text" . }}`, Fallback: `{{ template "slack.default.fallback" . }}`, CallbackID: `{{ template "slack.default.callbackid" . }}`, Footer: `{{ template "slack.default.footer" . }}`, } // DefaultRocketchatConfig defines default values for Rocketchat configurations. DefaultRocketchatConfig = RocketchatConfig{ NotifierConfig: NotifierConfig{ VSendResolved: false, }, Color: `{{ if eq .Status "firing" }}red{{ else }}green{{ end }}`, Emoji: `{{ template "rocketchat.default.emoji" . }}`, IconURL: `{{ template "rocketchat.default.iconurl" . }}`, Text: `{{ template "rocketchat.default.text" . }}`, Title: `{{ template "rocketchat.default.title" . }}`, TitleLink: `{{ template "rocketchat.default.titlelink" . }}`, } // DefaultOpsGenieConfig defines default values for OpsGenie configurations. DefaultOpsGenieConfig = OpsGenieConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Message: `{{ template "opsgenie.default.message" . }}`, Description: `{{ template "opsgenie.default.description" . }}`, Source: `{{ template "opsgenie.default.source" . }}`, // TODO: Add a details field with all the alerts. } // DefaultWechatConfig defines default values for wechat configurations. DefaultWechatConfig = WechatConfig{ NotifierConfig: NotifierConfig{ VSendResolved: false, }, Message: `{{ template "wechat.default.message" . }}`, ToUser: `{{ template "wechat.default.to_user" . }}`, ToParty: `{{ template "wechat.default.to_party" . }}`, ToTag: `{{ template "wechat.default.to_tag" . }}`, AgentID: `{{ template "wechat.default.agent_id" . }}`, } // DefaultVictorOpsConfig defines default values for VictorOps configurations. DefaultVictorOpsConfig = VictorOpsConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, MessageType: `CRITICAL`, StateMessage: `{{ template "victorops.default.state_message" . }}`, EntityDisplayName: `{{ template "victorops.default.entity_display_name" . }}`, MonitoringTool: `{{ template "victorops.default.monitoring_tool" . }}`, } // DefaultPushoverConfig defines default values for Pushover configurations. DefaultPushoverConfig = PushoverConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Title: `{{ template "pushover.default.title" . }}`, Message: `{{ template "pushover.default.message" . }}`, URL: `{{ template "pushover.default.url" . }}`, Priority: `{{ if eq .Status "firing" }}2{{ else }}0{{ end }}`, // emergency (firing) or normal Retry: duration(1 * time.Minute), Expire: duration(1 * time.Hour), HTML: false, } // DefaultSNSConfig defines default values for SNS configurations. DefaultSNSConfig = SNSConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Subject: `{{ template "sns.default.subject" . }}`, Message: `{{ template "sns.default.message" . }}`, } DefaultTelegramConfig = TelegramConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, DisableNotifications: false, Message: `{{ template "telegram.default.message" . }}`, ParseMode: "HTML", } DefaultMSTeamsConfig = MSTeamsConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Title: `{{ template "msteams.default.title" . }}`, Summary: `{{ template "msteams.default.summary" . }}`, Text: `{{ template "msteams.default.text" . }}`, } DefaultMSTeamsV2Config = MSTeamsV2Config{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Title: `{{ template "msteamsv2.default.title" . }}`, Text: `{{ template "msteamsv2.default.text" . }}`, } DefaultJiraConfig = JiraConfig{ NotifierConfig: NotifierConfig{ VSendResolved: true, }, Summary: `{{ template "jira.default.summary" . }}`, Description: `{{ template "jira.default.description" . }}`, Priority: `{{ template "jira.default.priority" . }}`, } ) // NotifierConfig contains base options common across all notifier configurations. type NotifierConfig struct { VSendResolved bool `yaml:"send_resolved" json:"send_resolved"` } func (nc NotifierConfig) SendResolved() bool { return nc.VSendResolved } // WebexConfig configures notifications via Webex. type WebexConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIURL URL `yaml:"api_url,omitempty" json:"api_url,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` RoomID string `yaml:"room_id" json:"room_id"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c WebexConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultWebexConfig type plain WebexConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.RoomID == "" { return errors.New("missing room_id on webex_config") } if c.HTTPConfig == nil \|\| c.HTTPConfig.Authorization == nil { return errors.New("missing webex_configs.http_config.authorization") } return nil } // DiscordConfig configures notifications via Discord. type DiscordConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` WebhookURL SecretURL `yaml:"webhook_url,omitempty" json:"webhook_url,omitempty"` WebhookURLFile string `yaml:"webhook_url_file,omitempty" json:"webhook_url_file,omitempty"` Content string `yaml:"content,omitempty" json:"content,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` Username string `yaml:"username,omitempty" json:"username,omitempty"` AvatarURL string `yaml:"avatar_url,omitempty" json:"avatar_url,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c DiscordConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultDiscordConfig type plain DiscordConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.WebhookURL == nil && c.WebhookURLFile == "" { return errors.New("one of webhook_url or webhook_url_file must be configured") } if c.WebhookURL != nil && len(c.WebhookURLFile) > 0 { return errors.New("at most one of webhook_url & webhook_url_file must be configured") } return nil } // EmailConfig configures notifications via mail. type EmailConfig struct { NotifierConfig `yaml:",inline" json:",inline"` // Email address to notify. To string `yaml:"to,omitempty" json:"to,omitempty"` From string `yaml:"from,omitempty" json:"from,omitempty"` Hello string `yaml:"hello,omitempty" json:"hello,omitempty"` Smarthost HostPort `yaml:"smarthost,omitempty" json:"smarthost,omitempty"` AuthUsername string `yaml:"auth_username,omitempty" json:"auth_username,omitempty"` AuthPassword Secret `yaml:"auth_password,omitempty" json:"auth_password,omitempty"` AuthPasswordFile string `yaml:"auth_password_file,omitempty" json:"auth_password_file,omitempty"` AuthSecret Secret `yaml:"auth_secret,omitempty" json:"auth_secret,omitempty"` AuthIdentity string `yaml:"auth_identity,omitempty" json:"auth_identity,omitempty"` Headers map[string]string `yaml:"headers,omitempty" json:"headers,omitempty"` HTML string `yaml:"html,omitempty" json:"html,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` RequireTLS bool `yaml:"require_tls,omitempty" json:"require_tls,omitempty"` TLSConfig commoncfg.TLSConfig `yaml:"tls_config,omitempty" json:"tls_config,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c EmailConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultEmailConfig type plain EmailConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.To == "" { return errors.New("missing to address in email config") } // Header names are case-insensitive, check for collisions. normalizedHeaders := map[string]string{} for h, v := range c.Headers { normalized := textproto.CanonicalMIMEHeaderKey(h) if _, ok := normalizedHeaders[normalized]; ok { return fmt.Errorf("duplicate header %q in email config", normalized) } normalizedHeaders[normalized] = v } c.Headers = normalizedHeaders return nil } // PagerdutyConfig configures notifications via PagerDuty. type PagerdutyConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` ServiceKey Secret `yaml:"service_key,omitempty" json:"service_key,omitempty"` ServiceKeyFile string `yaml:"service_key_file,omitempty" json:"service_key_file,omitempty"` RoutingKey Secret `yaml:"routing_key,omitempty" json:"routing_key,omitempty"` RoutingKeyFile string `yaml:"routing_key_file,omitempty" json:"routing_key_file,omitempty"` URL URL `yaml:"url,omitempty" json:"url,omitempty"` Client string `yaml:"client,omitempty" json:"client,omitempty"` ClientURL string `yaml:"client_url,omitempty" json:"client_url,omitempty"` Description string `yaml:"description,omitempty" json:"description,omitempty"` Details map[string]string `yaml:"details,omitempty" json:"details,omitempty"` Images []PagerdutyImage `yaml:"images,omitempty" json:"images,omitempty"` Links []PagerdutyLink `yaml:"links,omitempty" json:"links,omitempty"` Source string `yaml:"source,omitempty" json:"source,omitempty"` Severity string `yaml:"severity,omitempty" json:"severity,omitempty"` Class string `yaml:"class,omitempty" json:"class,omitempty"` Component string `yaml:"component,omitempty" json:"component,omitempty"` Group string `yaml:"group,omitempty" json:"group,omitempty"` } // PagerdutyLink is a link. type PagerdutyLink struct { Href string `yaml:"href,omitempty" json:"href,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` } // PagerdutyImage is an image. type PagerdutyImage struct { Src string `yaml:"src,omitempty" json:"src,omitempty"` Alt string `yaml:"alt,omitempty" json:"alt,omitempty"` Href string `yaml:"href,omitempty" json:"href,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c PagerdutyConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultPagerdutyConfig type plain PagerdutyConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.RoutingKey == "" && c.ServiceKey == "" && c.RoutingKeyFile == "" && c.ServiceKeyFile == "" { return errors.New("missing service or routing key in PagerDuty config") } if len(c.RoutingKey) > 0 && len(c.RoutingKeyFile) > 0 { return errors.New("at most one of routing_key & routing_key_file must be configured") } if len(c.ServiceKey) > 0 && len(c.ServiceKeyFile) > 0 { return errors.New("at most one of service_key & service_key_file must be configured") } if c.Details == nil { c.Details = make(map[string]string) } if c.Source == "" { c.Source = c.Client } for k, v := range DefaultPagerdutyDetails { if _, ok := c.Details[k]; !ok { c.Details[k] = v } } return nil } // SlackAction configures a single Slack action that is sent with each notification. // See https://api.slack.com/docs/message-attachments#action_fields and https://api.slack.com/docs/message-buttons // for more information. type SlackAction struct { Type string `yaml:"type,omitempty" json:"type,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` URL string `yaml:"url,omitempty" json:"url,omitempty"` Style string `yaml:"style,omitempty" json:"style,omitempty"` Name string `yaml:"name,omitempty" json:"name,omitempty"` Value string `yaml:"value,omitempty" json:"value,omitempty"` ConfirmField SlackConfirmationField `yaml:"confirm,omitempty" json:"confirm,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for SlackAction. func (c SlackAction) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain SlackAction if err := unmarshal((plain)(c)); err != nil { return err } if c.Type == "" { return errors.New("missing type in Slack action configuration") } if c.Text == "" { return errors.New("missing text in Slack action configuration") } if c.URL != "" { // Clear all message action fields. c.Name = "" c.Value = "" c.ConfirmField = nil } else if c.Name != "" { c.URL = "" } else { return errors.New("missing name or url in Slack action configuration") } return nil } // SlackConfirmationField protect users from destructive actions or particularly distinguished decisions // by asking them to confirm their button click one more time. // See https://api.slack.com/docs/interactive-message-field-guide#confirmation_fields for more information. type SlackConfirmationField struct { Text string `yaml:"text,omitempty" json:"text,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` OkText string `yaml:"ok_text,omitempty" json:"ok_text,omitempty"` DismissText string `yaml:"dismiss_text,omitempty" json:"dismiss_text,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for SlackConfirmationField. func (c SlackConfirmationField) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain SlackConfirmationField if err := unmarshal((plain)(c)); err != nil { return err } if c.Text == "" { return errors.New("missing text in Slack confirmation configuration") } return nil } // SlackField configures a single Slack field that is sent with each notification. // Each field must contain a title, value, and optionally, a boolean value to indicate if the field // is short enough to be displayed next to other fields designated as short. // See https://api.slack.com/docs/message-attachments#fields for more information. type SlackField struct { Title string `yaml:"title,omitempty" json:"title,omitempty"` Value string `yaml:"value,omitempty" json:"value,omitempty"` Short bool `yaml:"short,omitempty" json:"short,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface for SlackField. func (c SlackField) UnmarshalYAML(unmarshal func(interface{}) error) error { type plain SlackField if err := unmarshal((plain)(c)); err != nil { return err } if c.Title == "" { return errors.New("missing title in Slack field configuration") } if c.Value == "" { return errors.New("missing value in Slack field configuration") } return nil } // SlackConfig configures notifications via Slack. type SlackConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIURL SecretURL `yaml:"api_url,omitempty" json:"api_url,omitempty"` APIURLFile string `yaml:"api_url_file,omitempty" json:"api_url_file,omitempty"` // Slack channel override, (like #other-channel or @username). Channel string `yaml:"channel,omitempty" json:"channel,omitempty"` Username string `yaml:"username,omitempty" json:"username,omitempty"` Color string `yaml:"color,omitempty" json:"color,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` TitleLink string `yaml:"title_link,omitempty" json:"title_link,omitempty"` Pretext string `yaml:"pretext,omitempty" json:"pretext,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` Fields []SlackField `yaml:"fields,omitempty" json:"fields,omitempty"` ShortFields bool `yaml:"short_fields" json:"short_fields,omitempty"` Footer string `yaml:"footer,omitempty" json:"footer,omitempty"` Fallback string `yaml:"fallback,omitempty" json:"fallback,omitempty"` CallbackID string `yaml:"callback_id,omitempty" json:"callback_id,omitempty"` IconEmoji string `yaml:"icon_emoji,omitempty" json:"icon_emoji,omitempty"` IconURL string `yaml:"icon_url,omitempty" json:"icon_url,omitempty"` ImageURL string `yaml:"image_url,omitempty" json:"image_url,omitempty"` ThumbURL string `yaml:"thumb_url,omitempty" json:"thumb_url,omitempty"` LinkNames bool `yaml:"link_names" json:"link_names,omitempty"` MrkdwnIn []string `yaml:"mrkdwn_in,omitempty" json:"mrkdwn_in,omitempty"` Actions []SlackAction `yaml:"actions,omitempty" json:"actions,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c SlackConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultSlackConfig type plain SlackConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.APIURL != nil && len(c.APIURLFile) > 0 { return errors.New("at most one of api_url & api_url_file must be configured") } return nil } // WebhookConfig configures notifications via a generic webhook. type WebhookConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` // URL to send POST request to. URL SecretURL `yaml:"url" json:"url"` URLFile string `yaml:"url_file" json:"url_file"` // MaxAlerts is the maximum number of alerts to be sent per webhook message. // Alerts exceeding this threshold will be truncated. Setting this to 0 // allows an unlimited number of alerts. MaxAlerts uint64 `yaml:"max_alerts" json:"max_alerts"` // Timeout is the maximum time allowed to invoke the webhook. Setting this to 0 // does not impose a timeout. Timeout time.Duration `yaml:"timeout" json:"timeout"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c WebhookConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultWebhookConfig type plain WebhookConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.URL == nil && c.URLFile == "" { return errors.New("one of url or url_file must be configured") } if c.URL != nil && c.URLFile != "" { return errors.New("at most one of url & url_file must be configured") } return nil } // WechatConfig configures notifications via Wechat. type WechatConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APISecret Secret `yaml:"api_secret,omitempty" json:"api_secret,omitempty"` CorpID string `yaml:"corp_id,omitempty" json:"corp_id,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` APIURL URL `yaml:"api_url,omitempty" json:"api_url,omitempty"` ToUser string `yaml:"to_user,omitempty" json:"to_user,omitempty"` ToParty string `yaml:"to_party,omitempty" json:"to_party,omitempty"` ToTag string `yaml:"to_tag,omitempty" json:"to_tag,omitempty"` AgentID string `yaml:"agent_id,omitempty" json:"agent_id,omitempty"` MessageType string `yaml:"message_type,omitempty" json:"message_type,omitempty"` } const wechatValidTypesRe = `^(text\|markdown)$` var wechatTypeMatcher = regexp.MustCompile(wechatValidTypesRe) // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c WechatConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultWechatConfig type plain WechatConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.MessageType == "" { c.MessageType = "text" } if !wechatTypeMatcher.MatchString(c.MessageType) { return fmt.Errorf("weChat message type %q does not match valid options %s", c.MessageType, wechatValidTypesRe) } return nil } // OpsGenieConfig configures notifications via OpsGenie. type OpsGenieConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIKey Secret `yaml:"api_key,omitempty" json:"api_key,omitempty"` APIKeyFile string `yaml:"api_key_file,omitempty" json:"api_key_file,omitempty"` APIURL URL `yaml:"api_url,omitempty" json:"api_url,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` Description string `yaml:"description,omitempty" json:"description,omitempty"` Source string `yaml:"source,omitempty" json:"source,omitempty"` Details map[string]string `yaml:"details,omitempty" json:"details,omitempty"` Entity string `yaml:"entity,omitempty" json:"entity,omitempty"` Responders []OpsGenieConfigResponder `yaml:"responders,omitempty" json:"responders,omitempty"` Actions string `yaml:"actions,omitempty" json:"actions,omitempty"` Tags string `yaml:"tags,omitempty" json:"tags,omitempty"` Note string `yaml:"note,omitempty" json:"note,omitempty"` Priority string `yaml:"priority,omitempty" json:"priority,omitempty"` UpdateAlerts bool `yaml:"update_alerts,omitempty" json:"update_alerts,omitempty"` } const opsgenieValidTypesRe = `^(team\|teams\|user\|escalation\|schedule)$` var opsgenieTypeMatcher = regexp.MustCompile(opsgenieValidTypesRe) // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c OpsGenieConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultOpsGenieConfig type plain OpsGenieConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.APIKey != "" && len(c.APIKeyFile) > 0 { return errors.New("at most one of api_key & api_key_file must be configured") } for _, r := range c.Responders { if r.ID == "" && r.Username == "" && r.Name == "" { return fmt.Errorf("opsGenieConfig responder %v has to have at least one of id, username or name specified", r) } if strings.Contains(r.Type, "{{") { _, err := template.New("").Parse(r.Type) if err != nil { return fmt.Errorf("opsGenieConfig responder %v type is not a valid template: %w", r, err) } } else { r.Type = strings.ToLower(r.Type) if !opsgenieTypeMatcher.MatchString(r.Type) { return fmt.Errorf("opsGenieConfig responder %v type does not match valid options %s", r, opsgenieValidTypesRe) } } } return nil } type OpsGenieConfigResponder struct { // One of those 3 should be filled. ID string `yaml:"id,omitempty" json:"id,omitempty"` Name string `yaml:"name,omitempty" json:"name,omitempty"` Username string `yaml:"username,omitempty" json:"username,omitempty"` // team, user, escalation, schedule etc. Type string `yaml:"type,omitempty" json:"type,omitempty"` } // VictorOpsConfig configures notifications via VictorOps. type VictorOpsConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIKey Secret `yaml:"api_key,omitempty" json:"api_key,omitempty"` APIKeyFile string `yaml:"api_key_file,omitempty" json:"api_key_file,omitempty"` APIURL URL `yaml:"api_url" json:"api_url"` RoutingKey string `yaml:"routing_key" json:"routing_key"` MessageType string `yaml:"message_type" json:"message_type"` StateMessage string `yaml:"state_message" json:"state_message"` EntityDisplayName string `yaml:"entity_display_name" json:"entity_display_name"` MonitoringTool string `yaml:"monitoring_tool" json:"monitoring_tool"` CustomFields map[string]string `yaml:"custom_fields,omitempty" json:"custom_fields,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c VictorOpsConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultVictorOpsConfig type plain VictorOpsConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.RoutingKey == "" { return errors.New("missing Routing key in VictorOps config") } if c.APIKey != "" && len(c.APIKeyFile) > 0 { return errors.New("at most one of api_key & api_key_file must be configured") } reservedFields := []string{"routing_key", "message_type", "state_message", "entity_display_name", "monitoring_tool", "entity_id", "entity_state"} for _, v := range reservedFields { if _, ok := c.CustomFields[v]; ok { return fmt.Errorf("victorOps config contains custom field %s which cannot be used as it conflicts with the fixed/static fields", v) } } return nil } type duration time.Duration func (d duration) UnmarshalText(text []byte) error { parsed, err := time.ParseDuration(string(text)) if err == nil { d = duration(parsed) } return err } func (d duration) MarshalText() ([]byte, error) { return []byte(time.Duration(d).String()), nil } type PushoverConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` UserKey Secret `yaml:"user_key,omitempty" json:"user_key,omitempty"` UserKeyFile string `yaml:"user_key_file,omitempty" json:"user_key_file,omitempty"` Token Secret `yaml:"token,omitempty" json:"token,omitempty"` TokenFile string `yaml:"token_file,omitempty" json:"token_file,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` URL string `yaml:"url,omitempty" json:"url,omitempty"` URLTitle string `yaml:"url_title,omitempty" json:"url_title,omitempty"` Device string `yaml:"device,omitempty" json:"device,omitempty"` Sound string `yaml:"sound,omitempty" json:"sound,omitempty"` Priority string `yaml:"priority,omitempty" json:"priority,omitempty"` Retry duration `yaml:"retry,omitempty" json:"retry,omitempty"` Expire duration `yaml:"expire,omitempty" json:"expire,omitempty"` TTL duration `yaml:"ttl,omitempty" json:"ttl,omitempty"` HTML bool `yaml:"html" json:"html,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c PushoverConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultPushoverConfig type plain PushoverConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.UserKey == "" && c.UserKeyFile == "" { return errors.New("one of user_key or user_key_file must be configured") } if c.UserKey != "" && c.UserKeyFile != "" { return errors.New("at most one of user_key & user_key_file must be configured") } if c.Token == "" && c.TokenFile == "" { return errors.New("one of token or token_file must be configured") } if c.Token != "" && c.TokenFile != "" { return errors.New("at most one of token & token_file must be configured") } return nil } type SNSConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIUrl string `yaml:"api_url,omitempty" json:"api_url,omitempty"` Sigv4 sigv4.SigV4Config `yaml:"sigv4" json:"sigv4"` TopicARN string `yaml:"topic_arn,omitempty" json:"topic_arn,omitempty"` PhoneNumber string `yaml:"phone_number,omitempty" json:"phone_number,omitempty"` TargetARN string `yaml:"target_arn,omitempty" json:"target_arn,omitempty"` Subject string `yaml:"subject,omitempty" json:"subject,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` Attributes map[string]string `yaml:"attributes,omitempty" json:"attributes,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c SNSConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultSNSConfig type plain SNSConfig if err := unmarshal((plain)(c)); err != nil { return err } if (c.TargetARN == "") != (c.TopicARN == "") != (c.PhoneNumber == "") { return errors.New("must provide either a Target ARN, Topic ARN, or Phone Number for SNS config") } return nil } // TelegramConfig configures notifications via Telegram. type TelegramConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIUrl URL `yaml:"api_url" json:"api_url,omitempty"` BotToken Secret `yaml:"bot_token,omitempty" json:"token,omitempty"` BotTokenFile string `yaml:"bot_token_file,omitempty" json:"token_file,omitempty"` ChatID int64 `yaml:"chat_id,omitempty" json:"chat,omitempty"` MessageThreadID int `yaml:"message_thread_id,omitempty" json:"message_thread_id,omitempty"` Message string `yaml:"message,omitempty" json:"message,omitempty"` DisableNotifications bool `yaml:"disable_notifications,omitempty" json:"disable_notifications,omitempty"` ParseMode string `yaml:"parse_mode,omitempty" json:"parse_mode,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c TelegramConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultTelegramConfig type plain TelegramConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.BotToken == "" && c.BotTokenFile == "" { return errors.New("missing bot_token or bot_token_file on telegram_config") } if c.BotToken != "" && c.BotTokenFile != "" { return errors.New("at most one of bot_token & bot_token_file must be configured") } if c.ChatID == 0 { return errors.New("missing chat_id on telegram_config") } if c.ParseMode != "" && c.ParseMode != "Markdown" && c.ParseMode != "MarkdownV2" && c.ParseMode != "HTML" { return errors.New("unknown parse_mode on telegram_config, must be Markdown, MarkdownV2, HTML or empty string") } return nil } type MSTeamsConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` WebhookURL SecretURL `yaml:"webhook_url,omitempty" json:"webhook_url,omitempty"` WebhookURLFile string `yaml:"webhook_url_file,omitempty" json:"webhook_url_file,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` Summary string `yaml:"summary,omitempty" json:"summary,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` } func (c MSTeamsConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultMSTeamsConfig type plain MSTeamsConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.WebhookURL == nil && c.WebhookURLFile == "" { return errors.New("one of webhook_url or webhook_url_file must be configured") } if c.WebhookURL != nil && len(c.WebhookURLFile) > 0 { return errors.New("at most one of webhook_url & webhook_url_file must be configured") } return nil } type MSTeamsV2Config struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` WebhookURL SecretURL `yaml:"webhook_url,omitempty" json:"webhook_url,omitempty"` WebhookURLFile string `yaml:"webhook_url_file,omitempty" json:"webhook_url_file,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` } func (c MSTeamsV2Config) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultMSTeamsV2Config type plain MSTeamsV2Config if err := unmarshal((plain)(c)); err != nil { return err } if c.WebhookURL == nil && c.WebhookURLFile == "" { return errors.New("one of webhook_url or webhook_url_file must be configured") } if c.WebhookURL != nil && len(c.WebhookURLFile) > 0 { return errors.New("at most one of webhook_url & webhook_url_file must be configured") } return nil } type JiraConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIURL URL `yaml:"api_url,omitempty" json:"api_url,omitempty"` Project string `yaml:"project,omitempty" json:"project,omitempty"` Summary string `yaml:"summary,omitempty" json:"summary,omitempty"` Description string `yaml:"description,omitempty" json:"description,omitempty"` Labels []string `yaml:"labels,omitempty" json:"labels,omitempty"` Priority string `yaml:"priority,omitempty" json:"priority,omitempty"` IssueType string `yaml:"issue_type,omitempty" json:"issue_type,omitempty"` ReopenTransition string `yaml:"reopen_transition,omitempty" json:"reopen_transition,omitempty"` ResolveTransition string `yaml:"resolve_transition,omitempty" json:"resolve_transition,omitempty"` WontFixResolution string `yaml:"wont_fix_resolution,omitempty" json:"wont_fix_resolution,omitempty"` ReopenDuration model.Duration `yaml:"reopen_duration,omitempty" json:"reopen_duration,omitempty"` Fields map[string]any `yaml:"fields,omitempty" json:"custom_fields,omitempty"` } func (c JiraConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultJiraConfig type plain JiraConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.Project == "" { return errors.New("missing project in jira_config") } if c.IssueType == "" { return errors.New("missing issue_type in jira_config") } return nil } type RocketchatAttachmentField struct { Short bool `json:"short"` Title string `json:"title,omitempty"` Value string `json:"value,omitempty"` } const ( ProcessingTypeSendMessage = "sendMessage" ProcessingTypeRespondWithMessage = "respondWithMessage" ) type RocketchatAttachmentAction struct { Type string `json:"type,omitempty"` Text string `json:"text,omitempty"` URL string `json:"url,omitempty"` ImageURL string `json:"image_url,omitempty"` IsWebView bool `json:"is_webview"` WebviewHeightRatio string `json:"webview_height_ratio,omitempty"` Msg string `json:"msg,omitempty"` MsgInChatWindow bool `json:"msg_in_chat_window"` MsgProcessingType string `json:"msg_processing_type,omitempty"` } // RocketchatConfig configures notifications via Rocketchat. type RocketchatConfig struct { NotifierConfig `yaml:",inline" json:",inline"` HTTPConfig commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"` APIURL URL `yaml:"api_url,omitempty" json:"api_url,omitempty"` TokenID Secret `yaml:"token_id,omitempty" json:"token_id,omitempty"` TokenIDFile string `yaml:"token_id_file,omitempty" json:"token_id_file,omitempty"` Token Secret `yaml:"token,omitempty" json:"token,omitempty"` TokenFile string `yaml:"token_file,omitempty" json:"token_file,omitempty"` // RocketChat channel override, (like #other-channel or @username). Channel string `yaml:"channel,omitempty" json:"channel,omitempty"` Color string `yaml:"color,omitempty" json:"color,omitempty"` Title string `yaml:"title,omitempty" json:"title,omitempty"` TitleLink string `yaml:"title_link,omitempty" json:"title_link,omitempty"` Text string `yaml:"text,omitempty" json:"text,omitempty"` Fields []RocketchatAttachmentField `yaml:"fields,omitempty" json:"fields,omitempty"` ShortFields bool `yaml:"short_fields" json:"short_fields,omitempty"` Emoji string `yaml:"emoji,omitempty" json:"emoji,omitempty"` IconURL string `yaml:"icon_url,omitempty" json:"icon_url,omitempty"` ImageURL string `yaml:"image_url,omitempty" json:"image_url,omitempty"` ThumbURL string `yaml:"thumb_url,omitempty" json:"thumb_url,omitempty"` LinkNames bool `yaml:"link_names" json:"link_names,omitempty"` Actions []RocketchatAttachmentAction `yaml:"actions,omitempty" json:"actions,omitempty"` } // UnmarshalYAML implements the yaml.Unmarshaler interface. func (c RocketchatConfig) UnmarshalYAML(unmarshal func(interface{}) error) error { c = DefaultRocketchatConfig type plain RocketchatConfig if err := unmarshal((plain)(c)); err != nil { return err } if c.Token != nil && len(c.TokenFile) > 0 { return errors.New("at most one of token & token_file must be configured") } if c.TokenID != nil && len(c.TokenIDFile) > 0 { return errors.New("at most one of token_id & token_id_file must be configured") } return nil }	40.07 KB	2025-05-25 12:27
📄 notifiers_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 config import ( "errors" "net/mail" "reflect" "strings" "testing" "github.com/stretchr/testify/require" "gopkg.in/yaml.v2" ) func TestEmailToIsPresent(t testing.T) { in := ` to: '' ` var cfg EmailConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "missing to address in email config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestEmailHeadersCollision(t testing.T) { in := ` to: 'to@email.com' headers: Subject: 'Alert' subject: 'New Alert' ` var cfg EmailConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "duplicate header \"Subject\" in email config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestEmailToAllowsMultipleAdresses(t testing.T) { in := ` to: 'a@example.com, ,b@example.com,c@example.com' ` var cfg EmailConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatal(err) } expected := []mail.Address{ {Address: "a@example.com"}, {Address: "b@example.com"}, {Address: "c@example.com"}, } res, err := mail.ParseAddressList(cfg.To) if err != nil { t.Fatal(err) } if !reflect.DeepEqual(res, expected) { t.Fatalf("expected %v, got %v", expected, res) } } func TestEmailDisallowMalformed(t testing.T) { in := ` to: 'a@' ` var cfg EmailConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatal(err) } _, err = mail.ParseAddressList(cfg.To) if err == nil { t.Fatalf("no error returned, expected:\n%v", "mail: no angle-addr") } } func TestPagerdutyTestRoutingKey(t testing.T) { t.Run("error if no routing key or key file", func(t testing.T) { in := ` routing_key: '' ` var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "missing service or routing key in PagerDuty config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) t.Run("error if both routing key and key file", func(t testing.T) { in := ` routing_key: 'xyz' routing_key_file: 'xyz' ` var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of routing_key & routing_key_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) } func TestPagerdutyServiceKey(t testing.T) { t.Run("error if no service key or key file", func(t testing.T) { in := ` service_key: '' ` var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "missing service or routing key in PagerDuty config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) t.Run("error if both service key and key file", func(t testing.T) { in := ` service_key: 'xyz' service_key_file: 'xyz' ` var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of service_key & service_key_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) } func TestPagerdutyDetails(t testing.T) { tests := []struct { in string checkFn func(map[string]string) }{ { in: ` routing_key: 'xyz' `, checkFn: func(d map[string]string) { if len(d) != 4 { t.Errorf("expected 4 items, got: %d", len(d)) } }, }, { in: ` routing_key: 'xyz' details: key1: val1 `, checkFn: func(d map[string]string) { if len(d) != 5 { t.Errorf("expected 5 items, got: %d", len(d)) } }, }, { in: ` routing_key: 'xyz' details: key1: val1 key2: val2 firing: firing `, checkFn: func(d map[string]string) { if len(d) != 6 { t.Errorf("expected 6 items, got: %d", len(d)) } }, }, } for _, tc := range tests { var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(tc.in), &cfg) if err != nil { t.Errorf("expected no error, got:%v", err) } if tc.checkFn != nil { tc.checkFn(cfg.Details) } } } func TestPagerDutySource(t testing.T) { for _, tc := range []struct { title string in string expectedSource string }{ { title: "check source field is backward compatible", in: ` routing_key: 'xyz' client: 'alert-manager-client' `, expectedSource: "alert-manager-client", }, { title: "check source field is set", in: ` routing_key: 'xyz' client: 'alert-manager-client' source: 'alert-manager-source' `, expectedSource: "alert-manager-source", }, } { t.Run(tc.title, func(t testing.T) { var cfg PagerdutyConfig err := yaml.UnmarshalStrict([]byte(tc.in), &cfg) require.NoError(t, err) require.Equal(t, tc.expectedSource, cfg.Source) }) } } func TestWebhookURLIsPresent(t testing.T) { in := `{}` var cfg WebhookConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "one of url or url_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestWebhookURLOrURLFile(t testing.T) { in := ` url: 'http://example.com' url_file: 'http://example.com' ` var cfg WebhookConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of url & url_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestWebhookHttpConfigIsValid(t testing.T) { in := ` url: 'http://example.com' http_config: bearer_token: foo bearer_token_file: /tmp/bar ` var cfg WebhookConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of bearer_token & bearer_token_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestWebhookHttpConfigIsOptional(t testing.T) { in := ` url: 'http://example.com' ` var cfg WebhookConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatalf("no error expected, returned:\n%v", err.Error()) } } func TestWebhookPasswordIsObfuscated(t testing.T) { in := ` url: 'http://example.com' http_config: basic_auth: username: foo password: supersecret ` var cfg WebhookConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatalf("no error expected, returned:\n%v", err.Error()) } ycfg, err := yaml.Marshal(cfg) if err != nil { t.Fatalf("no error expected, returned:\n%v", err.Error()) } if strings.Contains(string(ycfg), "supersecret") { t.Errorf("Found password in the YAML cfg: %s\n", ycfg) } } func TestVictorOpsConfiguration(t testing.T) { t.Run("valid configuration", func(t testing.T) { in := ` routing_key: test api_key_file: /global_file ` var cfg VictorOpsConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatalf("no error was expected:\n%v", err) } }) t.Run("routing key is missing", func(t testing.T) { in := ` routing_key: '' ` var cfg VictorOpsConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "missing Routing key in VictorOps config" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) t.Run("api_key and api_key_file both defined", func(t testing.T) { in := ` routing_key: test api_key: xyz api_key_file: /global_file ` var cfg VictorOpsConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of api_key & api_key_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } }) } func TestVictorOpsCustomFieldsValidation(t testing.T) { in := ` routing_key: 'test' custom_fields: entity_state: 'state_message' ` var cfg VictorOpsConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "victorOps config contains custom field entity_state which cannot be used as it conflicts with the fixed/static fields" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } in = ` routing_key: 'test' custom_fields: my_special_field: 'special_label' ` err = yaml.UnmarshalStrict([]byte(in), &cfg) expected = "special_label" if err != nil { t.Fatalf("Unexpected error returned, got:\n%v", err.Error()) } val, ok := cfg.CustomFields["my_special_field"] if !ok { t.Fatalf("Expected Custom Field to have value %v set, field is empty", expected) } if val != expected { t.Errorf("\nexpected custom field my_special_field value:\n%v\ngot:\n%v", expected, val) } } func TestPushoverUserKeyIsPresent(t testing.T) { in := ` user_key: '' ` var cfg PushoverConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "one of user_key or user_key_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestPushoverUserKeyOrUserKeyFile(t testing.T) { in := ` user_key: 'user key' user_key_file: /pushover/user_key ` var cfg PushoverConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of user_key & user_key_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestPushoverTokenIsPresent(t testing.T) { in := ` user_key: '<user_key>' token: '' ` var cfg PushoverConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "one of token or token_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestPushoverTokenOrTokenFile(t testing.T) { in := ` token: 'pushover token' token_file: /pushover/token user_key: 'user key' ` var cfg PushoverConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) expected := "at most one of token & token_file must be configured" if err == nil { t.Fatalf("no error returned, expected:\n%v", expected) } if err.Error() != expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", expected, err.Error()) } } func TestLoadSlackConfiguration(t testing.T) { tests := []struct { in string expected SlackConfig }{ { in: ` color: green username: mark channel: engineering title_link: http://example.com/ image_url: https://example.com/logo.png `, expected: SlackConfig{ Color: "green", Username: "mark", Channel: "engineering", TitleLink: "http://example.com/", ImageURL: "https://example.com/logo.png", }, }, { in: ` color: green username: mark channel: alerts title_link: http://example.com/alert1 mrkdwn_in: - pretext - text `, expected: SlackConfig{ Color: "green", Username: "mark", Channel: "alerts", MrkdwnIn: []string{"pretext", "text"}, TitleLink: "http://example.com/alert1", }, }, } for _, rt := range tests { var cfg SlackConfig err := yaml.UnmarshalStrict([]byte(rt.in), &cfg) if err != nil { t.Fatalf("\nerror returned when none expected, error:\n%v", err) } if rt.expected.Color != cfg.Color { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.Color, cfg.Color) } if rt.expected.Username != cfg.Username { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.Username, cfg.Username) } if rt.expected.Channel != cfg.Channel { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.Channel, cfg.Channel) } if rt.expected.ThumbURL != cfg.ThumbURL { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.ThumbURL, cfg.ThumbURL) } if rt.expected.TitleLink != cfg.TitleLink { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.TitleLink, cfg.TitleLink) } if rt.expected.ImageURL != cfg.ImageURL { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.ImageURL, cfg.ImageURL) } if len(rt.expected.MrkdwnIn) != len(cfg.MrkdwnIn) { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected.MrkdwnIn, cfg.MrkdwnIn) } for i := range cfg.MrkdwnIn { if rt.expected.MrkdwnIn[i] != cfg.MrkdwnIn[i] { t.Errorf("\nexpected:\n%v\ngot:\n%v\nat index %v", rt.expected.MrkdwnIn[i], cfg.MrkdwnIn[i], i) } } } } func TestSlackFieldConfigValidation(t testing.T) { tests := []struct { in string expected string }{ { in: ` fields: - title: first value: hello - title: second `, expected: "missing value in Slack field configuration", }, { in: ` fields: - title: first value: hello short: true - value: world short: true `, expected: "missing title in Slack field configuration", }, { in: ` fields: - title: first value: hello short: true - title: second value: world `, expected: "", }, } for _, rt := range tests { var cfg SlackConfig err := yaml.UnmarshalStrict([]byte(rt.in), &cfg) // Check if an error occurred when it was NOT expected to. if rt.expected == "" && err != nil { t.Fatalf("\nerror returned when none expected, error:\n%v", err) } // Check that an error occurred if one was expected to. if rt.expected != "" && err == nil { t.Fatalf("\nno error returned, expected:\n%v", rt.expected) } // Check that the error that occurred was what was expected. if err != nil && err.Error() != rt.expected { t.Errorf("\nexpected:\n%v\ngot:\n%v", rt.expected, err.Error()) } } } func TestSlackFieldConfigUnmarshaling(t testing.T) { in := ` fields: - title: first value: hello short: true - title: second value: world - title: third value: slack field test short: false ` expected := []SlackField{ { Title: "first", Value: "hello", Short: newBoolPointer(true), }, { Title: "second", Value: "world", Short: nil, }, { Title: "third", Value: "slack field test", Short: newBoolPointer(false), }, } var cfg SlackConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatalf("\nerror returned when none expected, error:\n%v", err) } for index, field := range cfg.Fields { exp := expected[index] if field.Title != exp.Title { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Title, field.Title) } if field.Value != exp.Value { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Value, field.Value) } if exp.Short == nil && field.Short != nil { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Short, field.Short) } if exp.Short != nil && field.Short == nil { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Short, field.Short) } if exp.Short != nil && exp.Short != field.Short { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Short, field.Short) } } } func TestSlackActionsValidation(t testing.T) { in := ` actions: - type: button text: hello url: https://localhost style: danger - type: button text: hello name: something style: default confirm: title: please confirm text: are you sure? ok_text: yes dismiss_text: no ` expected := []SlackAction{ { Type: "button", Text: "hello", URL: "https://localhost", Style: "danger", }, { Type: "button", Text: "hello", Name: "something", Style: "default", ConfirmField: &SlackConfirmationField{ Title: "please confirm", Text: "are you sure?", OkText: "yes", DismissText: "no", }, }, } var cfg SlackConfig err := yaml.UnmarshalStrict([]byte(in), &cfg) if err != nil { t.Fatalf("\nerror returned when none expected, error:\n%v", err) } for index, action := range cfg.Actions { exp := expected[index] if action.Type != exp.Type { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Type, action.Type) } if action.Text != exp.Text { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Text, action.Text) } if action.URL != exp.URL { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.URL, action.URL) } if action.Style != exp.Style { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Style, action.Style) } if action.Name != exp.Name { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Name, action.Name) } if action.Value != exp.Value { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.Value, action.Value) } if action.ConfirmField != nil && exp.ConfirmField == nil \|\| action.ConfirmField == nil && exp.ConfirmField != nil { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.ConfirmField, action.ConfirmField) } else if action.ConfirmField != nil && exp.ConfirmField != nil { if action.ConfirmField.Title != exp.ConfirmField.Title { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.ConfirmField.Title, action.ConfirmField.Title) } if action.ConfirmField.Text != exp.ConfirmField.Text { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.ConfirmField.Text, action.ConfirmField.Text) } if action.ConfirmField.OkText != exp.ConfirmField.OkText { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.ConfirmField.OkText, action.ConfirmField.OkText) } if action.ConfirmField.DismissText != exp.ConfirmField.DismissText { t.Errorf("\nexpected:\n%v\ngot:\n%v", exp.ConfirmField.DismissText, action.ConfirmField.DismissText) } } } } func TestOpsgenieTypeMatcher(t testing.T) { good := []string{"team", "user", "escalation", "schedule"} for _, g := range good { if !opsgenieTypeMatcher.MatchString(g) { t.Fatalf("failed to match with %s", g) } } bad := []string{"0user", "team1", "2escalation3", "sche4dule", "User", "TEAM"} for _, b := range bad { if opsgenieTypeMatcher.MatchString(b) { t.Errorf("mistakenly match with %s", b) } } } func TestOpsGenieConfiguration(t testing.T) { for _, tc := range []struct { name string in string err bool }{ { name: "valid configuration", in: `api_key: xyz responders: - id: foo type: scheDule - name: bar type: teams - username: fred type: USER api_url: http://example.com `, }, { name: "api_key and api_key_file both defined", in: `api_key: xyz api_key_file: xyz api_url: http://example.com `, err: true, }, { name: "invalid responder type", in: `api_key: xyz responders: - id: foo type: wrong api_url: http://example.com `, err: true, }, { name: "missing responder field", in: `api_key: xyz responders: - type: schedule api_url: http://example.com `, err: true, }, { name: "valid responder type template", in: `api_key: xyz responders: - id: foo type: "{{/* valid comment /}}team" api_url: http://example.com `, }, { name: "invalid responder type template", in: `api_key: xyz responders: - id: foo type: "{{/ invalid comment }}team" api_url: http://example.com `, err: true, }, } { t.Run(tc.name, func(t testing.T) { var cfg OpsGenieConfig err := yaml.UnmarshalStrict([]byte(tc.in), &cfg) if tc.err { if err == nil { t.Fatalf("expected error but got none") } return } if err != nil { t.Errorf("expected no error, got %v", err) } }) } } func TestSNS(t testing.T) { for _, tc := range []struct { in string err bool }{ { // Valid configuration without sigv4. in: `target_arn: target`, err: false, }, { // Valid configuration without sigv4. in: `topic_arn: topic`, err: false, }, { // Valid configuration with sigv4. in: `phone_number: phone sigv4: access_key: abc secret_key: abc `, err: false, }, { // at most one of 'target_arn', 'topic_arn' or 'phone_number' must be provided without sigv4. in: `topic_arn: topic target_arn: target `, err: true, }, { // at most one of 'target_arn', 'topic_arn' or 'phone_number' must be provided without sigv4. in: `topic_arn: topic phone_number: phone `, err: true, }, { // one of 'target_arn', 'topic_arn' or 'phone_number' must be provided without sigv4. in: "{}", err: true, }, { // one of 'target_arn', 'topic_arn' or 'phone_number' must be provided with sigv4. in: `sigv4: access_key: abc secret_key: abc `, err: true, }, { // 'secret_key' must be provided with 'access_key'. in: `topic_arn: topic sigv4: access_key: abc `, err: true, }, { // 'access_key' must be provided with 'secret_key'. in: `topic_arn: topic sigv4: secret_key: abc `, err: true, }, } { t.Run("", func(t testing.T) { var cfg SNSConfig err := yaml.UnmarshalStrict([]byte(tc.in), &cfg) if err != nil { if !tc.err { t.Errorf("expecting no error, got %q", err) } return } if tc.err { t.Logf("%#v", cfg) t.Error("expecting error, got none") } }) } } func TestWeChatTypeMatcher(t testing.T) { good := []string{"text", "markdown"} for _, g := range good { if !wechatTypeMatcher.MatchString(g) { t.Fatalf("failed to match with %s", g) } } bad := []string{"TEXT", "MarkDOwn"} for _, b := range bad { if wechatTypeMatcher.MatchString(b) { t.Errorf("mistakenly match with %s", b) } } } func TestWebexConfiguration(t testing.T) { tc := []struct { name string in string expected error }{ { name: "with no room_id - it fails", in: ` message: xyz123 `, expected: errors.New("missing room_id on webex_config"), }, { name: "with room_id and http_config.authorization set - it succeeds", in: ` room_id: 2 http_config: authorization: credentials: "xxxyyyzz" `, }, } for _, tt := range tc { t.Run(tt.name, func(t testing.T) { var cfg WebexConfig err := yaml.UnmarshalStrict([]byte(tt.in), &cfg) require.Equal(t, tt.expected, err) }) } } func TestTelegramConfiguration(t testing.T) { tc := []struct { name string in string expected error }{ { name: "with both bot_token & bot_token_file - it fails", in: ` bot_token: xyz bot_token_file: /file `, expected: errors.New("at most one of bot_token & bot_token_file must be configured"), }, { name: "with no bot_token & bot_token_file - it fails", in: ` bot_token: '' bot_token_file: '' `, expected: errors.New("missing bot_token or bot_token_file on telegram_config"), }, { name: "with bot_token and chat_id set - it succeeds", in: ` bot_token: xyz chat_id: 123 `, }, { name: "with bot_token, chat_id and message_thread_id set - it succeeds", in: ` bot_token: xyz chat_id: 123 message_thread_id: 456 `, }, { name: "with bot_token_file and chat_id set - it succeeds", in: ` bot_token_file: /file chat_id: 123 `, }, { name: "with no chat_id set - it fails", in: ` bot_token: xyz `, expected: errors.New("missing chat_id on telegram_config"), }, { name: "with unknown parse_mode - it fails", in: ` bot_token: xyz chat_id: 123 parse_mode: invalid `, expected: errors.New("unknown parse_mode on telegram_config, must be Markdown, MarkdownV2, HTML or empty string"), }, } for _, tt := range tc { t.Run(tt.name, func(t testing.T) { var cfg TelegramConfig err := yaml.UnmarshalStrict([]byte(tt.in), &cfg) require.Equal(t, tt.expected, err) }) } } func newBoolPointer(b bool) *bool { return &b }	23.96 KB	2025-05-25 12:27
📁 receiver	-	2025-05-25 12:27
📁 testdata	-	2025-05-25 12:27

Terminal