Add alert metadata

alert/alert.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/target/goalert/validation"
 	"github.com/target/goalert/validation/validate"
 )
 
@@ -25,6 +26,7 @@ type Alert struct {
 	ServiceID string    `json:"service_id"`
 	CreatedAt time.Time `json:"created_at"`
 	Dedup     *DedupID  `json:"dedup"`
+	Meta      AlertMeta `json:"meta"`
 }
 
 // DedupKey will return the de-duplication key for the alert.
@@ -57,12 +59,21 @@ func (a Alert) Normalize() (*Alert, error) {
 	}
 	a.Summary = strings.Replace(a.Summary, "\n", " ", -1)
 	a.Summary = strings.Replace(a.Summary, "  ", " ", -1)
+
+	var validateMeta error
+	for k := range a.Meta.AlertMetaV1 {
+		if k == "" {
+			validateMeta = validation.NewFieldError("Meta", "key must be non empty string")
+		}
+	}
+
 	err := validate.Many(
 		validate.Text("Summary", a.Summary, 1, MaxSummaryLength),
 		validate.Text("Details", a.Details, 0, MaxDetailsLength),
 		validate.OneOf("Source", a.Source, SourceManual, SourceGrafana, SourceSite24x7, SourcePrometheusAlertmanager, SourceEmail, SourceGeneric),
 		validate.OneOf("Status", a.Status, StatusTriggered, StatusActive, StatusClosed),
 		validate.UUID("ServiceID", a.ServiceID),
+		validateMeta,
 	)
 	if err != nil {
 		return nil, err

alert/meta.go

@@ -0,0 +1,26 @@
+package alert
+
+const TypeAlertMetaV1 = "alert_meta_v1"
+
+type AlertMeta struct {
+	Type        string        `json:"type"`
+	AlertMetaV1 AlertMetaData `json:"alert_meta_v1"`
+}
+
+type AlertMetaData map[string]string
+
+type AlertMetaInput []struct {
+	Key   string `json:"key"`
+	Value string `json:"value"`
+}
+
+func ToAlertMeta(meta AlertMetaInput) AlertMeta {
+	alertMeta := AlertMetaData{}
+	for _, v := range meta {
+		alertMeta[v.Key] = v.Value
+	}
+	return AlertMeta{
+		Type:        TypeAlertMetaV1,
+		AlertMetaV1: alertMeta,
+	}
+}

alert/queries.sql

@@ -9,6 +9,23 @@ WHERE
     alerts.id = $1
 FOR UPDATE;
 
+-- name: Insert :one
+INSERT INTO alerts(summary, details, service_id, source, status, dedup_key)
+    VALUES ($1, $2, $3, $4, $5, $6)
+RETURNING
+    id, created_at;
+
+-- name: NoStepsByService :one
+SELECT
+    COALESCE((
+        SELECT
+            TRUE
+        FROM escalation_policies pol
+        JOIN services svc ON svc.id = $1
+        WHERE
+            pol.id = svc.escalation_policy_id
+            AND pol.step_count = 0), FALSE) AS no_steps_by_service;
+
 -- name: RequestAlertEscalationByTime :one
 UPDATE
     escalation_policy_state
@@ -60,3 +77,21 @@ ON CONFLICT (alert_id)
     RETURNING
         alert_id;
 
+-- name: AlertMetadataMany :many
+SELECT
+    alert_id,
+    metadata
+FROM
+    alerts_metadata
+WHERE
+    alert_id = ANY ($1::int[]);
+
+-- name: SetAlertMetadata :exec
+INSERT INTO alerts_metadata(alert_id, metadata)
+    VALUES ($1, $2)
+ON CONFLICT (alert_id)
+    DO UPDATE SET
+        metadata = $2
+    WHERE
+        alerts_metadata.alert_id = $1;
+

alert/store.go

@@ -3,9 +3,11 @@ package alert
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"fmt"
 	"time"
 
+	"github.com/sqlc-dev/pqtype"
 	"github.com/target/goalert/alert/alertlog"
 	"github.com/target/goalert/gadb"
 	"github.com/target/goalert/permission"
@@ -527,6 +529,14 @@ func (s *Store) _create(ctx context.Context, tx *sql.Tx, a Alert) (*Alert, *aler
 		return nil, nil, err
 	}
 
+	// insert alert metadata
+	err = s.insertMetaData(tx, ctx, a.ID, a.Meta.AlertMetaV1)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	ctx = log.WithFields(ctx, log.Fields{"AlertID": a.ID, "Meta": a.Meta.AlertMetaV1})
+	log.Logf(ctx, "Alert created.")
 	err = tx.StmtContext(ctx, s.noStepsBySvc).QueryRowContext(ctx, a.ServiceID).Scan(&meta.EPNoSteps)
 	if err != nil {
 		return nil, nil, err
@@ -585,6 +595,11 @@ func (s *Store) CreateOrUpdateTx(ctx context.Context, tx *sql.Tx, a *Alert) (*Al
 			if stepErr != nil {
 				return nil, false, err
 			}
+			// insert alert metadata
+			err = s.insertMetaData(tx, ctx, n.ID, a.Meta.AlertMetaV1)
+			if err != nil {
+				return nil, false, err
+			}
 		}
 		meta = &m
 	case StatusActive:
@@ -741,6 +756,8 @@ func (s *Store) FindMany(ctx context.Context, alertIDs []int) ([]Alert, error) {
 	}
 	defer rows.Close()
 
+	amd, _ := s.MetadataMany(ctx, alertIDs)
+
 	alerts := make([]Alert, 0, len(alertIDs))
 
 	for rows.Next() {
@@ -749,6 +766,11 @@ func (s *Store) FindMany(ctx context.Context, alertIDs []int) ([]Alert, error) {
 		if err != nil {
 			return nil, err
 		}
+		if val, ok := amd[int32(a.ID)]; ok {
+			a.Meta = AlertMeta{
+				AlertMetaV1: val,
+			}
+		}
 		alerts = append(alerts, a)
 	}
 
@@ -881,3 +903,68 @@ func (s Store) UpdateFeedback(ctx context.Context, feedback *Feedback) error {
 
 	return nil
 }
+
+func (s Store) Metadata(ctx context.Context, alertID int) (AlertMetaData, error) {
+	err := permission.LimitCheckAny(ctx, permission.System, permission.User)
+	if err != nil {
+		return nil, err
+	}
+	md, err := s.MetadataMany(ctx, []int{alertID})
+	if err != nil {
+		return nil, err
+	}
+	if amd, ok := md[int32(alertID)]; ok {
+		return amd, nil
+	}
+	return nil, validation.NewFieldError("ID", "not found")
+}
+
+func (s Store) MetadataMany(ctx context.Context, alertIDs []int) (map[int32]AlertMetaData, error) {
+	err := permission.LimitCheckAny(ctx, permission.System, permission.User)
+	if err != nil {
+		return nil, err
+	}
+
+	err = validate.Range("AlertIDs", len(alertIDs), 1, maxBatch)
+	if err != nil {
+		return nil, err
+	}
+	ids := make([]int32, len(alertIDs))
+	for _, id := range alertIDs {
+		ids = append(ids, int32(id))
+	}
+
+	amd := map[int32]AlertMetaData{}
+	rows, err := gadb.New(s.db).AlertMetadataMany(ctx, ids)
+	if errors.Is(err, sql.ErrNoRows) {
+		return amd, err
+	}
+	if err != nil {
+		return amd, err
+	}
+
+	for _, r := range rows {
+		if r.Metadata.Valid {
+			var md AlertMetaData
+			err = json.Unmarshal(r.Metadata.RawMessage, &md)
+			if err == nil {
+				amd[r.AlertID] = md
+			} else {
+				amd[r.AlertID] = nil
+			}
+		}
+	}
+	return amd, err
+}
+
+func (s Store) insertMetaData(tx *sql.Tx, ctx context.Context, alertID int, metaData AlertMetaData) error {
+	meta, err := json.Marshal(&metaData)
+	if err != nil {
+		return err
+	}
+	err = gadb.New(tx).SetAlertMetadata(ctx, gadb.SetAlertMetadataParams{
+		AlertID:  int32(alertID),
+		Metadata: pqtype.NullRawMessage{Valid: metaData != nil, RawMessage: json.RawMessage(meta)},
+	})
+	return err
+}

engine/sendmessage.go

@@ -71,6 +71,12 @@ func (p *Engine) sendMessage(ctx context.Context, msg *message.Message) (*notifi
 			// set to nil if it's the current message
 			stat = nil
 		}
+		var meta []notification.AlertMeta
+		if a.Meta.AlertMetaV1 != nil {
+			for k, v := range a.Meta.AlertMetaV1 {
+				meta = append(meta, notification.AlertMeta{Key: k, Value: v})
+			}
+		}
 		notifMsg = notification.Alert{
 			Dest:        msg.Dest,
 			AlertID:     msg.AlertID,
@@ -79,6 +85,7 @@ func (p *Engine) sendMessage(ctx context.Context, msg *message.Message) (*notifi
 			CallbackID:  msg.ID,
 			ServiceID:   a.ServiceID,
 			ServiceName: name,
+			Meta:        meta,
 
 			OriginalStatus: stat,
 		}