Show muted alerts in the Alert Groups API

This commit updates the Alert Groups API (/api/v2/alerts/groups)
to show if an alert is suppressed from one or more active or
mute time intervals. It does not update the Alerts API
(/api/v2/alerts) because that API does not take aggregation or
routing into consideration.

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

Author: grobinson-grafana

api/api.go

@@ -45,16 +45,19 @@ type API struct {
 	inFlightSem              chan struct{}
 }
 
-// Options for the creation of an API object. Alerts, Silences, and StatusFunc
+// Options for the creation of an API object. Alerts, Silences, and AlertStatusFunc
 // are mandatory to set. The zero value for everything else is a safe default.
 type Options struct {
 	// Alerts to be used by the API. Mandatory.
 	Alerts provider.Alerts
 	// Silences to be used by the API. Mandatory.
 	Silences *silence.Silences
-	// StatusFunc is used be the API to retrieve the AlertStatus of an
+	// AlertStatusFunc is used be the API to retrieve the AlertStatus of an
 	// alert. Mandatory.
-	StatusFunc func(model.Fingerprint) types.AlertStatus
+	AlertStatusFunc func(model.Fingerprint) types.AlertStatus
+	// GroupMutedFunc is used be the API to know if an alert is muted.
+	// Mandatory.
+	GroupMutedFunc func(string) ([]string, bool)
 	// Peer from the gossip cluster. If nil, no clustering will be used.
 	Peer cluster.ClusterPeer
 	// Timeout for all HTTP connections. The zero value (and negative
@@ -83,8 +86,11 @@ func (o Options) validate() error {
 	if o.Silences == nil {
 		return errors.New("mandatory field Silences not set")
 	}
-	if o.StatusFunc == nil {
-		return errors.New("mandatory field StatusFunc not set")
+	if o.AlertStatusFunc == nil {
+		return errors.New("mandatory field AlertStatusFunc not set")
+	}
+	if o.GroupMutedFunc == nil {
+		return errors.New("mandatory field GroupMutedFunc not set")
 	}
 	if o.GroupFunc == nil {
 		return errors.New("mandatory field GroupFunc not set")
@@ -113,7 +119,8 @@ func New(opts Options) (*API, error) {
 	v2, err := apiv2.NewAPI(
 		opts.Alerts,
 		opts.GroupFunc,
-		opts.StatusFunc,
+		opts.AlertStatusFunc,
+		opts.GroupMutedFunc,
 		opts.Silences,
 		opts.Peer,
 		log.With(l, "version", "v2"),

api/v2/api.go

@@ -60,6 +60,7 @@ type API struct {
 	alerts         provider.Alerts
 	alertGroups    groupsFn
 	getAlertStatus getAlertStatusFn
+	groupMutedFunc groupMutedFunc
 	uptime         time.Time
 
 	// mtx protects alertmanagerConfig, setAlertStatus and route.
@@ -78,6 +79,7 @@ type API struct {
 
 type (
 	groupsFn         func(func(*dispatch.Route) bool, func(*types.Alert, time.Time) bool) (dispatch.AlertGroups, map[prometheus_model.Fingerprint][]string)
+	groupMutedFunc   func(groupKey string) ([]string, bool)
 	getAlertStatusFn func(prometheus_model.Fingerprint) types.AlertStatus
 	setAlertStatusFn func(prometheus_model.LabelSet)
 )
@@ -86,16 +88,18 @@ type (
 func NewAPI(
 	alerts provider.Alerts,
 	gf groupsFn,
-	sf getAlertStatusFn,
+	asf getAlertStatusFn,
+	gmf groupMutedFunc,
 	silences *silence.Silences,
 	peer cluster.ClusterPeer,
 	l log.Logger,
 	r prometheus.Registerer,
 ) (*API, error) {
 	api := API{
 		alerts:         alerts,
-		getAlertStatus: sf,
+		getAlertStatus: asf,
 		alertGroups:    gf,
+		groupMutedFunc: gmf,
 		peer:           peer,
 		silences:       silences,
 		logger:         l,
@@ -410,14 +414,16 @@ func (api *API) getAlertGroupsHandler(params alertgroup_ops.GetAlertGroupsParams
 		ag := &open_api_models.AlertGroup{
 			Receiver: &open_api_models.Receiver{Name: &alertGroup.Receiver},
 			Labels:   ModelLabelSetToAPILabelSet(alertGroup.Labels),
-			Alerts:   make([]*open_api_models.GettableAlert, 0, len(alertGroup.Alerts)),
+			Alerts:   make([]*open_api_models.AlertGroupGettableAlert, 0, len(alertGroup.Alerts)),
 		}
 
+		mutedBy, isMuted := api.groupMutedFunc(alertGroup.GroupKey)
 		for _, alert := range alertGroup.Alerts {
 			fp := alert.Fingerprint()
 			receivers := allReceivers[fp]
 			status := api.getAlertStatus(fp)
-			apiAlert := AlertToOpenAPIAlert(alert, status, receivers)
+			tmp := AlertToOpenAPIAlert(alert, status, receivers)
+			apiAlert := ToGroupAlert(tmp, isMuted, mutedBy)
 			ag.Alerts = append(ag.Alerts, apiAlert)
 		}
 		res = append(res, ag)

api/v2/api_test.go

@@ -412,23 +412,25 @@ func TestAlertToOpenAPIAlert(t *testing.T) {
 	)
 	openAPIAlert := AlertToOpenAPIAlert(alert, types.AlertStatus{State: types.AlertStateActive}, receivers)
 	require.Equal(t, &open_api_models.GettableAlert{
-		Annotations: open_api_models.LabelSet{},
-		Alert: open_api_models.Alert{
-			Labels: open_api_models.LabelSet{"severity": "critical", "alertname": "alert1"},
+		BaseAlert: open_api_models.BaseAlert{
+			Annotations: open_api_models.LabelSet{},
+			Alert: open_api_models.Alert{
+				Labels: open_api_models.LabelSet{"severity": "critical", "alertname": "alert1"},
+			},
+			StartsAt:    convertDateTime(start),
+			EndsAt:      convertDateTime(time.Time{}),
+			UpdatedAt:   convertDateTime(updated),
+			Fingerprint: &fp,
+			Receivers: []*open_api_models.Receiver{
+				{Name: &receivers[0]},
+				{Name: &receivers[1]},
+			},
 		},
 		Status: &open_api_models.AlertStatus{
 			State:       &active,
 			InhibitedBy: []string{},
 			SilencedBy:  []string{},
 		},
-		StartsAt:    convertDateTime(start),
-		EndsAt:      convertDateTime(time.Time{}),
-		UpdatedAt:   convertDateTime(updated),
-		Fingerprint: &fp,
-		Receivers: []*open_api_models.Receiver{
-			{Name: &receivers[0]},
-			{Name: &receivers[1]},
-		},
 	}, openAPIAlert)
 }
 

api/v2/compat.go

@@ -130,16 +130,18 @@ func AlertToOpenAPIAlert(alert *types.Alert, status types.AlertStatus, receivers
 	fp := alert.Fingerprint().String()
 	state := string(status.State)
 	aa := &open_api_models.GettableAlert{
-		Alert: open_api_models.Alert{
-			GeneratorURL: strfmt.URI(alert.GeneratorURL),
-			Labels:       ModelLabelSetToAPILabelSet(alert.Labels),
+		BaseAlert: open_api_models.BaseAlert{
+			Alert: open_api_models.Alert{
+				GeneratorURL: strfmt.URI(alert.GeneratorURL),
+				Labels:       ModelLabelSetToAPILabelSet(alert.Labels),
+			},
+			Annotations: ModelLabelSetToAPILabelSet(alert.Annotations),
+			StartsAt:    &startsAt,
+			UpdatedAt:   &updatedAt,
+			EndsAt:      &endsAt,
+			Fingerprint: &fp,
+			Receivers:   apiReceivers,
 		},
-		Annotations: ModelLabelSetToAPILabelSet(alert.Annotations),
-		StartsAt:    &startsAt,
-		UpdatedAt:   &updatedAt,
-		EndsAt:      &endsAt,
-		Fingerprint: &fp,
-		Receivers:   apiReceivers,
 		Status: &open_api_models.AlertStatus{
 			State:       &state,
 			SilencedBy:  status.SilencedBy,
@@ -158,6 +160,32 @@ func AlertToOpenAPIAlert(alert *types.Alert, status types.AlertStatus, receivers
 	return aa
 }
 
+func ToGroupAlert(alert *open_api_models.GettableAlert, isMuted bool, mutedBy []string) *open_api_models.AlertGroupGettableAlert {
+	status := open_api_models.AlertGroupAlertStatus{}
+	if alert.Status != nil {
+		status.AlertStatus = *alert.Status
+	}
+	if status.SilencedBy == nil {
+		status.SilencedBy = []string{}
+	}
+	if status.InhibitedBy == nil {
+		status.InhibitedBy = []string{}
+	}
+	if status.MutedBy == nil {
+		status.MutedBy = []string{}
+	}
+	result := open_api_models.AlertGroupGettableAlert{
+		BaseAlert: alert.BaseAlert,
+		Status:    &status,
+	}
+	if isMuted {
+		state := open_api_models.AlertStatusStateSuppressed
+		result.Status.MutedBy = mutedBy
+		result.Status.State = &state
+	}
+	return &result
+}
+
 // OpenAPIAlertsToAlerts converts open_api_models.PostableAlerts to []*types.Alert.
 func OpenAPIAlertsToAlerts(apiAlerts open_api_models.PostableAlerts) []*types.Alert {
 	alerts := []*types.Alert{}