Add alert metadata

alert/alert.go

@@ -57,6 +57,7 @@ func (a Alert) Normalize() (*Alert, error) {
 	}
 	a.Summary = strings.Replace(a.Summary, "\n", " ", -1)
 	a.Summary = strings.Replace(a.Summary, "  ", " ", -1)
+
 	err := validate.Many(
 		validate.Text("Summary", a.Summary, 1, MaxSummaryLength),
 		validate.Text("Details", a.Details, 0, MaxDetailsLength),

alert/metadata.go

@@ -0,0 +1,158 @@
+package alert
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+
+	"github.com/sqlc-dev/pqtype"
+	"github.com/target/goalert/gadb"
+	"github.com/target/goalert/permission"
+	"github.com/target/goalert/validation"
+	"github.com/target/goalert/validation/validate"
+)
+
+const metaV1 = "alert_meta_v1"
+
+type metadataDBFormat struct {
+	Type        string
+	AlertMetaV1 map[string]string
+}
+
+// Metadata returns the metadata for a single alert.
+func (s *Store) Metadata(ctx context.Context, db gadb.DBTX, alertID int) (map[string]string, error) {
+	err := permission.LimitCheckAny(ctx, permission.System, permission.User)
+	if err != nil {
+		return nil, err
+	}
+
+	md, err := gadb.New(db).AlertMetadata(ctx, int64(alertID))
+	if errors.Is(err, sql.ErrNoRows) || !md.Valid {
+		return map[string]string{}, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	var doc metadataDBFormat
+	err = json.Unmarshal(md.RawMessage, &doc)
+	if err != nil {
+		return nil, err
+	}
+
+	if doc.Type != metaV1 || doc.AlertMetaV1 == nil {
+		return nil, errors.New("unsupported metadata type")
+	}
+
+	return doc.AlertMetaV1, nil
+}
+
+type MetadataAlertID struct {
+	// AlertID is the ID of the alert.
+	ID   int64
+	Meta map[string]string
+}
+
+func (s Store) FindManyMetadata(ctx context.Context, db gadb.DBTX, alertIDs []int) ([]MetadataAlertID, 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([]int64, len(alertIDs))
+	for i, id := range alertIDs {
+		ids[i] = int64(id)
+	}
+
+	rows, err := gadb.New(db).AlertManyMetadata(ctx, ids)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	res := make([]MetadataAlertID, len(rows))
+	for i, r := range rows {
+		var doc metadataDBFormat
+		err = json.Unmarshal(r.Metadata.RawMessage, &doc)
+		if err != nil {
+			return nil, err
+		}
+
+		if doc.Type != metaV1 || doc.AlertMetaV1 == nil {
+			return nil, errors.New("unsupported metadata type")
+		}
+
+		res[i] = MetadataAlertID{
+			ID:   r.AlertID,
+			Meta: doc.AlertMetaV1,
+		}
+	}
+
+	return res, nil
+}
+
+func (s Store) SetMetadataTx(ctx context.Context, db gadb.DBTX, alertID int, meta map[string]string) error {
+	err := permission.LimitCheckAny(ctx, permission.User, permission.Service)
+	if err != nil {
+		return err
+	}
+
+	err = ValidateMetadata(meta)
+	if err != nil {
+		return err
+	}
+
+	var doc metadataDBFormat
+	doc.Type = metaV1
+	doc.AlertMetaV1 = meta
+
+	md, err := json.Marshal(&doc)
+	if err != nil {
+		return err
+	}
+
+	rowCount, err := gadb.New(db).AlertSetMetadata(ctx, gadb.AlertSetMetadataParams{
+		ID:        int64(alertID),
+		ServiceID: permission.ServiceNullUUID(ctx), // only provide service_id restriction if request is from a service
+		Metadata:  pqtype.NullRawMessage{Valid: true, RawMessage: json.RawMessage(md)},
+	})
+	if err != nil {
+		return err
+	}
+
+	if rowCount == 0 {
+		// shouldn't happen, but just in case
+		return permission.NewAccessDenied("alert closed, invalid, or wrong service")
+	}
+
+	return nil
+}
+
+func ValidateMetadata(m map[string]string) error {
+	if m == nil {
+		return validation.NewFieldError("Meta", "cannot be nil")
+	}
+
+	var totalSize int
+	for k, v := range m {
+		err := validate.ASCII("Meta[<key>]", k, 1, 255)
+		if err != nil {
+			return err
+		}
+
+		totalSize += len(k) + len(v)
+	}
+
+	if totalSize > 32768 {
+		return validation.NewFieldError("Meta", "cannot exceed 32KiB in size")
+	}
+
+	return nil
+}

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,38 @@ ON CONFLICT (alert_id)
     RETURNING
         alert_id;
 
+-- name: AlertMetadata :one
+SELECT
+    metadata
+FROM
+    alert_data
+WHERE
+    alert_id = $1;
+
+-- name: AlertManyMetadata :many
+SELECT
+    alert_id,
+    metadata
+FROM
+    alert_data
+WHERE
+    alert_id = ANY (@alert_ids::bigint[]);
+
+-- name: AlertSetMetadata :execrows
+INSERT INTO alert_data(alert_id, metadata)
+SELECT
+    a.id,
+    $2
+FROM
+    alerts a
+WHERE
+    a.id = $1
+    AND a.status != 'closed'
+    AND (a.service_id = $3
+        OR $3 IS NULL) -- ensure the alert is associated with the service, if coming from an integration
+ON CONFLICT (alert_id)
+    DO UPDATE SET
+        metadata = $2
+    WHERE
+        alert_data.alert_id = $1;
+

alert/store.go

@@ -610,6 +610,15 @@ func (s *Store) CreateOrUpdateTx(ctx context.Context, tx *sql.Tx, a *Alert) (*Al
 // In the case that Status is closed but a matching alert is not present, nil is returned.
 // Otherwise the current alert is returned.
 func (s *Store) CreateOrUpdate(ctx context.Context, a *Alert) (*Alert, bool, error) {
+	return s.createOrUpdate(ctx, a, nil)
+}
+
+// CreateOrUpdateWithMeta will create an alert and sets alert's metadata
+func (s *Store) CreateOrUpdateWithMeta(ctx context.Context, a *Alert, meta map[string]string) (*Alert, bool, error) {
+	return s.createOrUpdate(ctx, a, meta)
+}
+
+func (s *Store) createOrUpdate(ctx context.Context, a *Alert, meta map[string]string) (*Alert, bool, error) {
 	err := permission.LimitCheckAny(ctx,
 		permission.System,
 		permission.Admin,
@@ -631,10 +640,19 @@ func (s *Store) CreateOrUpdate(ctx context.Context, a *Alert) (*Alert, bool, err
 		return nil, false, err
 	}
 
+	// Set metadata only if meta is not nil and isNew is true
+	if meta != nil && isNew {
+		err = s.SetMetadataTx(ctx, tx, n.ID, meta)
+		if err != nil {
+			return nil, false, err
+		}
+	}
+
 	err = tx.Commit()
 	if err != nil {
 		return nil, false, err
 	}
+
 	if n == nil {
 		return nil, false, nil
 	}

engine/sendmessage.go

@@ -71,6 +71,10 @@ func (p *Engine) sendMessage(ctx context.Context, msg *message.Message) (*notifi
 			// set to nil if it's the current message
 			stat = nil
 		}
+		meta, err := p.a.Metadata(ctx, p.b.db, msg.AlertID)
+		if err != nil {
+			return nil, errors.Wrap(err, "lookup alertmeta")
+		}
 		notifMsg = notification.Alert{
 			Dest:        msg.Dest,
 			AlertID:     msg.AlertID,
@@ -79,6 +83,7 @@ func (p *Engine) sendMessage(ctx context.Context, msg *message.Message) (*notifi
 			CallbackID:  msg.ID,
 			ServiceID:   a.ServiceID,
 			ServiceName: name,
+			Meta:        meta,
 
 			OriginalStatus: stat,
 		}