automod: abstract out notification (slack msgs)

automod/engine/context.go

···
 	c.effects.IncrementPeriod(name, val, period)
 }
 
+func (c *BaseContext) Notify(srv string) {
+	c.effects.Notify(srv)
+}
+
 func (c *AccountContext) AddAccountFlag(val string) {
 	c.effects.AddAccountFlag(val)
 }

automod/engine/effects.go

···
 	BlobTakedowns []string
 	// If "true", indicates that a rule indicates that the action causing the event should be blocked or prevented
 	RejectEvent bool
+	// Services, if any, which should blast out a notification about this even (eg, Slack)
+	NotifyServices []string
 }
 
 // Enqueues the named counter to be incremented at the end of all rule processing. Will automatically increment for all time periods.
···
 		}
 	}
 	e.BlobTakedowns = append(e.BlobTakedowns, cid)
+}
+
+// Records that the given service should be notified about this event
+func (e *Effects) Notify(srv string) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	for _, v := range e.NotifyServices {
+		if v == srv {
+			return
+		}
+	}
+	e.NotifyServices = append(e.NotifyServices, srv)
 }
 
 func (e *Effects) Reject() {

automod/engine/engine.go

···
 //
 // NOTE: careful when initializing: several fields must not be nil or zero, even though they are pointer type.
 type Engine struct {
-	Logger      *slog.Logger
-	Directory   identity.Directory
-	Rules       RuleSet
-	Counters    countstore.CountStore
-	Sets        setstore.SetStore
-	Cache       cachestore.CacheStore
-	Flags       flagstore.FlagStore
+	Logger    *slog.Logger
+	Directory identity.Directory
+	Rules     RuleSet
+	Counters  countstore.CountStore
+	Sets      setstore.SetStore
+	Cache     cachestore.CacheStore
+	Flags     flagstore.FlagStore
+	// unlike the other sub-modules, this field (Notifier) may be nil
+	Notifier Notifier
+	// TODO: unused; remove?
 	RelayClient *xrpc.Client
-	BskyClient  *xrpc.Client
+	// use to fetch public account metadata from AppView
+	BskyClient *xrpc.Client
 	// used to persist moderation actions in mod service (optional)
-	AdminClient     *xrpc.Client
-	SlackWebhookURL string
+	AdminClient *xrpc.Client
 }
 
 // Entrypoint for external code pushing arbitrary identity events in to the engine.

automod/engine/notifier.go

···
+package engine
+
+import (
+	"context"
+)
+
+// Interface for a type that can handle sending notifications
+type Notifier interface {
+	SendAccount(ctx context.Context, service string, c *AccountContext) error
+	SendRecord(ctx context.Context, service string, c *RecordContext) error
+}

automod/engine/persist.go

···
 	}
 
 	anyModActions := newTakedown || len(newLabels) > 0 || len(newFlags) > 0 || len(newReports) > 0
-	if anyModActions && eng.SlackWebhookURL != "" {
-		msg := slackBody("⚠️ Automod Account Action ⚠️\n", c.Account, newLabels, newFlags, newReports, newTakedown)
-		if err := eng.SendSlackMsg(ctx, msg); err != nil {
-			c.Logger.Error("sending slack webhook", "err", err)
+	if anyModActions && eng.Notifier != nil {
+		for _, srv := range dedupeStrings(c.effects.NotifyServices) {
+			if err := eng.Notifier.SendAccount(ctx, srv, c); err != nil {
+				c.Logger.Error("failed to deliver notification", "service", srv, "err", err)
+			}
 		}
 	}
 
···
 	atURI := fmt.Sprintf("at://%s/%s/%s", c.Account.Identity.DID, c.RecordOp.Collection, c.RecordOp.RecordKey)
 
 	if newTakedown || len(newLabels) > 0 || len(newFlags) > 0 || len(newReports) > 0 {
-		if eng.SlackWebhookURL != "" {
-			msg := slackBody("⚠️ Automod Record Action ⚠️\n", c.Account, newLabels, newFlags, newReports, newTakedown)
-			msg += fmt.Sprintf("`%s`\n", atURI)
-			if err := eng.SendSlackMsg(ctx, msg); err != nil {
-				c.Logger.Error("sending slack webhook", "err", err)
+		if eng.Notifier != nil {
+			for _, srv := range dedupeStrings(c.effects.NotifyServices) {
+				if err := eng.Notifier.SendRecord(ctx, srv, c); err != nil {
+					c.Logger.Error("failed to deliver notification", "service", srv, "err", err)
+				}
 			}
 		}
 	}

automod/engine/persisthelpers.go

···
 import (
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
···
 	}
 	return true, nil
 }
-
-func slackBody(header string, acct AccountMeta, newLabels, newFlags []string, newReports []ModReport, newTakedown bool) string {
-	msg := header
-	msg += fmt.Sprintf("`%s` / `%s` / <https://bsky.app/profile/%s|bsky> / <https://admin.prod.bsky.dev/repositories/%s|ozone>\n",
-		acct.Identity.DID,
-		acct.Identity.Handle,
-		acct.Identity.DID,
-		acct.Identity.DID,
-	)
-	if len(newLabels) > 0 {
-		msg += fmt.Sprintf("New Labels: `%s`\n", strings.Join(newLabels, ", "))
-	}
-	if len(newFlags) > 0 {
-		msg += fmt.Sprintf("New Flags: `%s`\n", strings.Join(newFlags, ", "))
-	}
-	for _, rep := range newReports {
-		msg += fmt.Sprintf("Report `%s`: %s\n", rep.ReasonType, rep.Comment)
-	}
-	if newTakedown {
-		msg += fmt.Sprintf("Takedown!\n")
-	}
-	return msg
-}

automod/engine/slack.go

···
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"strings"
 )
 
+type SlackNotifier struct {
+	SlackWebhookURL string
+}
+
+func (n *SlackNotifier) SendAccount(ctx context.Context, service string, c *AccountContext) error {
+	if service != "slack" {
+		return nil
+	}
+	msg := slackBody("⚠️ Automod Account Action ⚠️\n", c.Account, c.effects.AccountLabels, c.effects.AccountFlags, c.effects.AccountReports, c.effects.AccountTakedown)
+	c.Logger.Debug("sending slack notification")
+	return n.sendSlackMsg(ctx, msg)
+}
+
+func (n *SlackNotifier) SendRecord(ctx context.Context, service string, c *RecordContext) error {
+	if service != "slack" {
+		return nil
+	}
+	atURI := fmt.Sprintf("at://%s/%s/%s", c.Account.Identity.DID, c.RecordOp.Collection, c.RecordOp.RecordKey)
+	msg := slackBody("⚠️ Automod Record Action ⚠️\n", c.Account, c.effects.RecordLabels, c.effects.RecordFlags, c.effects.RecordReports, c.effects.RecordTakedown)
+	msg += fmt.Sprintf("`%s`\n", atURI)
+	c.Logger.Debug("sending slack notification")
+	return n.sendSlackMsg(ctx, msg)
+}
+
 type SlackWebhookBody struct {
 	Text string `json:"text"`
 }
···
 // Sends a simple slack message to a channel via "incoming webhook".
 //
 // The slack incoming webhook must be already configured in the slack workplace.
-func (e *Engine) SendSlackMsg(ctx context.Context, msg string) error {
+func (n *SlackNotifier) sendSlackMsg(ctx context.Context, msg string) error {
 	// loosely based on: https://golangcode.com/send-slack-messages-without-a-library/
 
 	body, err := json.Marshal(SlackWebhookBody{Text: msg})
 	if err != nil {
 		return err
 	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, e.SlackWebhookURL, bytes.NewBuffer(body))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, n.SlackWebhookURL, bytes.NewBuffer(body))
 	if err != nil {
 		return err
 	}
···
 	}
 	return nil
 }
+
+func slackBody(header string, acct AccountMeta, newLabels, newFlags []string, newReports []ModReport, newTakedown bool) string {
+	msg := header
+	msg += fmt.Sprintf("`%s` / `%s` / <https://bsky.app/profile/%s|bsky> / <https://admin.prod.bsky.dev/repositories/%s|ozone>\n",
+		acct.Identity.DID,
+		acct.Identity.Handle,
+		acct.Identity.DID,
+		acct.Identity.DID,
+	)
+	if len(newLabels) > 0 {
+		msg += fmt.Sprintf("Labels: `%s`\n", strings.Join(newLabels, ", "))
+	}
+	if len(newFlags) > 0 {
+		msg += fmt.Sprintf("Flags: `%s`\n", strings.Join(newFlags, ", "))
+	}
+	for _, rep := range newReports {
+		msg += fmt.Sprintf("Report `%s`: %s\n", rep.ReasonType, rep.Comment)
+	}
+	if newTakedown {
+		msg += fmt.Sprintf("Takedown!\n")
+	}
+	return msg
+}