feat: support global PagerDuty details template overrides

Signed-off-by: Mihir Dixit <dixitmihir1@gmail.com>

Author: mihir-dixit2k27

config/config.go

@@ -114,6 +114,223 @@ func (s *SecretTemplateURL) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+// applyGlobalReceiverTemplates merges global template defaults into each
+// receiver config, using the 3-tier priority:
+//
+//	built-in default < global template override < per-receiver explicit value
+func applyGlobalReceiverTemplates(receivers []Receiver, global *GlobalConfig) {
+	var gt *GlobalReceiverTemplates
+	if global != nil {
+		gt = global.ReceiverTemplates
+	}
+
+	for i := range receivers {
+		r := &receivers[i]
+
+		for j := range r.SlackConfigs {
+			var slackGt *GlobalSlackTemplates
+			if gt != nil {
+				slackGt = gt.Slack
+			}
+			applySlackTemplates(r.SlackConfigs[j], slackGt)
+		}
+
+		for j := range r.EmailConfigs {
+			var emailGt *GlobalEmailTemplates
+			if gt != nil {
+				emailGt = gt.Email
+			}
+			applyEmailTemplates(r.EmailConfigs[j], emailGt)
+		}
+
+		for j := range r.PagerdutyConfigs {
+			var pdGt *GlobalPagerDutyTemplates
+			if gt != nil {
+				pdGt = gt.PagerDuty
+			}
+			applyPagerDutyTemplates(r.PagerdutyConfigs[j], pdGt)
+		}
+
+		for j := range r.OpsGenieConfigs {
+			var ogGt *GlobalOpsGenieTemplates
+			if gt != nil {
+				ogGt = gt.OpsGenie
+			}
+			applyOpsGenieTemplates(r.OpsGenieConfigs[j], ogGt)
+		}
+
+		for j := range r.VictorOpsConfigs {
+			var voGt *GlobalVictorOpsTemplates
+			if gt != nil {
+				voGt = gt.VictorOps
+			}
+			applyVictorOpsTemplates(r.VictorOpsConfigs[j], voGt)
+		}
+
+		for j := range r.PushoverConfigs {
+			var poGt *GlobalPushoverTemplates
+			if gt != nil {
+				poGt = gt.Pushover
+			}
+			applyPushoverTemplates(r.PushoverConfigs[j], poGt)
+		}
+
+		for j := range r.WechatConfigs {
+			var wcGt *GlobalWeChatTemplates
+			if gt != nil {
+				wcGt = gt.WeChat
+			}
+			applyWeChatTemplates(r.WechatConfigs[j], wcGt)
+		}
+
+		for j := range r.TelegramConfigs {
+			var tcGt *GlobalTelegramTemplates
+			if gt != nil {
+				tcGt = gt.Telegram
+			}
+			applyTelegramTemplates(r.TelegramConfigs[j], tcGt)
+		}
+	}
+}
+
+func applySlackTemplates(sc *SlackConfig, gt *GlobalSlackTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&sc.Username, gt.Username, DefaultSlackConfig.Username)
+		applyGlobalTemplateOverride(&sc.IconEmoji, gt.IconEmoji, DefaultSlackConfig.IconEmoji)
+		applyGlobalTemplateOverride(&sc.IconURL, gt.IconURL, DefaultSlackConfig.IconURL)
+		applyGlobalTemplateOverride(&sc.Pretext, gt.Pretext, DefaultSlackConfig.Pretext)
+		applyGlobalTemplateOverride(&sc.Title, gt.Title, DefaultSlackConfig.Title)
+		applyGlobalTemplateOverride(&sc.TitleLink, gt.TitleLink, DefaultSlackConfig.TitleLink)
+		applyGlobalTemplateOverride(&sc.Text, gt.Text, DefaultSlackConfig.Text)
+		applyGlobalTemplateOverride(&sc.Fallback, gt.Fallback, DefaultSlackConfig.Fallback)
+		applyGlobalTemplateOverride(&sc.Footer, gt.Footer, DefaultSlackConfig.Footer)
+		applyGlobalTemplateOverride(&sc.Color, gt.Color, DefaultSlackConfig.Color)
+	}
+}
+
+func applyEmailTemplates(ec *EmailConfig, gt *GlobalEmailTemplates) {
+	if gt != nil {
+		if gt.Subject != "" {
+			if ec.Headers == nil {
+				ec.Headers = make(map[string]string)
+			}
+			if val, ok := ec.Headers["Subject"]; !ok || val == DefaultEmailSubject {
+				ec.Headers["Subject"] = gt.Subject
+			}
+		}
+		applyGlobalTemplateOverride(&ec.HTML, gt.HTML, DefaultEmailConfig.HTML)
+		applyGlobalTemplateOverride(&ec.Text, gt.Text, DefaultEmailConfig.Text)
+	}
+}
+
+func applyPagerDutyTemplates(pc *PagerdutyConfig, gt *GlobalPagerDutyTemplates) {
+	if gt == nil {
+		return
+	}
+
+	applyGlobalTemplateOverride(&pc.Description, gt.Description, DefaultPagerdutyConfig.Description)
+	applyGlobalTemplateOverride(&pc.Client, gt.Client, DefaultPagerdutyConfig.Client)
+	applyGlobalTemplateOverride(&pc.ClientURL, gt.ClientURL, DefaultPagerdutyConfig.ClientURL)
+
+	// Merge global template overrides into the receiver `details` map.
+	//
+	// Precedence model:
+	// - built-in defaults < global receiver_templates < per-receiver explicit value
+	//
+	// For "standard" keys present in DefaultPagerdutyDetails, we only override
+	// receiver values when they are still set to the built-in default template
+	// string (so explicit empty-string overrides like `firing: ""` are preserved).
+	//
+	// For arbitrary/custom keys not present in DefaultPagerdutyDetails, we never
+	// override existing per-receiver values; we only add the key if it's absent.
+	if gt.Details == nil {
+		return
+	}
+	if pc.Details == nil {
+		pc.Details = make(map[string]any)
+	}
+
+	for k, gv := range gt.Details {
+		if gv == "" {
+			// Treat global empty string as "not set" (consistent with applyGlobalTemplateOverride).
+			continue
+		}
+
+		receiverVal, receiverHasKey := pc.Details[k]
+		if !receiverHasKey {
+			// Key absent on receiver: global value becomes the default.
+			pc.Details[k] = gv
+			continue
+		}
+
+		// Key exists on receiver:
+		// - if it's a standard key, override only when receiver still equals the built-in default
+		// - if it's a custom key, never override an existing per-receiver value
+		builtInVal, builtInHasKey := DefaultPagerdutyDetails[k]
+		if !builtInHasKey {
+			continue
+		}
+		builtInStr, builtInOK := builtInVal.(string)
+		receiverStr, receiverOK := receiverVal.(string)
+		if !builtInOK || !receiverOK {
+			continue
+		}
+		if receiverStr == builtInStr {
+			pc.Details[k] = gv
+		}
+	}
+}
+
+func applyOpsGenieTemplates(oc *OpsGenieConfig, gt *GlobalOpsGenieTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&oc.Message, gt.Message, DefaultOpsGenieConfig.Message)
+		applyGlobalTemplateOverride(&oc.Description, gt.Description, DefaultOpsGenieConfig.Description)
+		applyGlobalTemplateOverride(&oc.Source, gt.Source, DefaultOpsGenieConfig.Source)
+		applyGlobalTemplateOverride(&oc.Note, gt.Note, DefaultOpsGenieConfig.Note)
+	}
+}
+
+func applyVictorOpsTemplates(vc *VictorOpsConfig, gt *GlobalVictorOpsTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&vc.MessageType, gt.MessageType, DefaultVictorOpsConfig.MessageType)
+		applyGlobalTemplateOverride(&vc.EntityDisplayName, gt.EntityDisplayName, DefaultVictorOpsConfig.EntityDisplayName)
+		applyGlobalTemplateOverride(&vc.StateMessage, gt.StateMessage, DefaultVictorOpsConfig.StateMessage)
+	}
+}
+
+func applyPushoverTemplates(pc *PushoverConfig, gt *GlobalPushoverTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&pc.Title, gt.Title, DefaultPushoverConfig.Title)
+		applyGlobalTemplateOverride(&pc.Message, gt.Message, DefaultPushoverConfig.Message)
+		applyGlobalTemplateOverride(&pc.URL, gt.URL, DefaultPushoverConfig.URL)
+	}
+}
+
+func applyWeChatTemplates(wc *WechatConfig, gt *GlobalWeChatTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&wc.Message, gt.Message, DefaultWechatConfig.Message)
+		applyGlobalTemplateOverride(&wc.MessageType, gt.MessageType, DefaultWechatConfig.MessageType)
+	}
+}
+
+func applyTelegramTemplates(tc *TelegramConfig, gt *GlobalTelegramTemplates) {
+	if gt != nil {
+		applyGlobalTemplateOverride(&tc.Message, gt.Message, DefaultTelegramConfig.Message)
+	}
+}
+
+// applyGlobalTemplateOverride sets *dst to gtValue only if *dst is currently exactly equal to defaultVal.
+// This properly distinguishes between an omitted field (which defaults to defaultVal) and an explicit
+// empty string override (like `title: ""`), assuming defaultVal is not literally `""`.
+func applyGlobalTemplateOverride(dst *string, gtValue string, defaultVal string) {
+	if gtValue == "" {
+		return
+	}
+	if *dst == defaultVal {
+		*dst = gtValue
+	}
+}
+
 // Load parses the YAML input s into a Config.
 func Load(s string) (*Config, error) {
 	cfg := &Config{}
@@ -350,6 +567,8 @@ func (c *Config) UnmarshalYAML(unmarshal func(any) error) error {
 		return errors.New("at most one of mattermost_webhook_url & mattermost_webhook_url_file must be configured")
 	}
 
+	applyGlobalReceiverTemplates(c.Receivers, c.Global)
+
 	names := map[string]struct{}{}
 
 	for _, rcv := range c.Receivers {
@@ -838,6 +1057,9 @@ type GlobalConfig struct {
 	RocketchatTokenIDFile    string                 `yaml:"rocketchat_token_id_file,omitempty" json:"rocketchat_token_id_file,omitempty"`
 	MattermostWebhookURL     *amcommoncfg.SecretURL `yaml:"mattermost_webhook_url,omitempty" json:"mattermost_webhook_url,omitempty"`
 	MattermostWebhookURLFile string                 `yaml:"mattermost_webhook_url_file,omitempty" json:"mattermost_webhook_url_file,omitempty"`
+
+	// per-receiver-type global template overrides
+	ReceiverTemplates *GlobalReceiverTemplates `yaml:"receiver_templates,omitempty" json:"receiver_templates,omitempty"`
 }
 
 // UnmarshalYAML implements the yaml.Unmarshaler interface for GlobalConfig.