Something went wrong. Try again.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337package engine
import ( "context" "fmt" "log/slog" "net/http" "time"
comatproto "github.com/bluesky-social/indigo/api/atproto" "github.com/bluesky-social/indigo/atproto/identity" "github.com/bluesky-social/indigo/atproto/syntax" "github.com/bluesky-social/indigo/automod/cachestore" "github.com/bluesky-social/indigo/automod/countstore" "github.com/bluesky-social/indigo/automod/flagstore" "github.com/bluesky-social/indigo/automod/setstore" "github.com/bluesky-social/indigo/xrpc")
// runtime for executing rules, managing state, and recording moderation actions.//// 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 // unlike the other sub-modules, this field (Notifier) may be nil Notifier Notifier // use to fetch public account metadata from AppView; no auth BskyClient *xrpc.Client // used to persist moderation actions in ozone moderation service; optional, admin auth OzoneClient *xrpc.Client // used to fetch private account metadata from PDS or entryway; optional, admin auth AdminClient *xrpc.Client // used to fetch blobs from upstream PDS instances BlobClient *http.Client
// internal configuration Config EngineConfig}
type EngineConfig struct { // if enabled, account metadata is not hydrated for every event by default SkipAccountMeta bool // time period within which automod will not re-report an account for the same reasonType ReportDupePeriod time.Duration // number of reports automod can file per day, for all subjects and types combined (circuit breaker) QuotaModReportDay int // number of takedowns automod can action per day, for all subjects combined (circuit breaker) QuotaModTakedownDay int // number of misc actions automod can do per day, for all subjects combined (circuit breaker) QuotaModActionDay int
// timeout for record event processing (total, including all setup, rules, and teardown) RecordEventTimeout time.Duration // timeout for identity event and account event processing (total, including all setup, rules, and teardown) IdentityEventTimeout time.Duration // timeout for event processing (total, including all setup, rules, and teardown) OzoneEventTimeout time.Duration
// number of blobs fetched and processed concurrently per record (there may be many records processed in parallel). If zero, a sane default is used (`DEFAULT_BLOB_PROCESSING_CONCURRENCY`). If negative, no limit. BlobProcessingConcurrency int}
// Entrypoint for external code pushing #identity events in to the engine.//// This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.func (eng *Engine) ProcessIdentityEvent(ctx context.Context, evt comatproto.SyncSubscribeRepos_Identity) error { eventProcessCount.WithLabelValues("identity").Inc() start := time.Now() defer func() { duration := time.Since(start) eventProcessDuration.WithLabelValues("identity").Observe(duration.Seconds()) }()
did, err := syntax.ParseDID(evt.Did) if err != nil { return fmt.Errorf("bad DID in repo #identity event (%s): %w", evt.Did, err) }
// similar to an HTTP server, we want to recover any panics from rule execution defer func() { if r := recover(); r != nil { eng.Logger.Error("automod event execution exception", "err", r, "did", did, "type", "identity") eventErrorCount.WithLabelValues("identity").Inc() } }() var cancel context.CancelFunc if eng.Config.IdentityEventTimeout != 0 { ctx, cancel = context.WithTimeout(ctx, eng.Config.IdentityEventTimeout) defer cancel() }
// first purge any caches; we need to re-resolve from scratch on identity updates if err := eng.PurgeAccountCaches(ctx, did); err != nil { eng.Logger.Error("failed to purge identity cache; identity rule may not run correctly", "err", err) } // TODO(bnewbold): if it was a tombstone, this might fail ident, err := eng.Directory.LookupDID(ctx, did) if err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("resolving identity: %w", err) } if ident == nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("identity not found for DID: %s", did.String()) }
var am *AccountMeta if !eng.Config.SkipAccountMeta { am, err = eng.GetAccountMeta(ctx, ident) if err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("failed to fetch account metadata: %w", err) } } else { am = &AccountMeta{ Identity: ident, Profile: ProfileSummary{}, } } ac := NewAccountContext(ctx, eng, *am) if err := eng.Rules.CallIdentityRules(&ac); err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("rule execution failed: %w", err) } eng.CanonicalLogLineAccount(&ac) if err := eng.persistAccountModActions(&ac); err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("failed to persist actions for identity event: %w", err) } if err := eng.persistCounters(ctx, ac.effects); err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("failed to persist counters for identity event: %w", err) } return nil}
// Entrypoint for external code pushing #account events in to the engine.//// This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.func (eng *Engine) ProcessAccountEvent(ctx context.Context, evt comatproto.SyncSubscribeRepos_Account) error { eventProcessCount.WithLabelValues("account").Inc() start := time.Now() defer func() { duration := time.Since(start) eventProcessDuration.WithLabelValues("account").Observe(duration.Seconds()) }()
did, err := syntax.ParseDID(evt.Did) if err != nil { return fmt.Errorf("bad DID in repo #account event (%s): %w", evt.Did, err) }
// similar to an HTTP server, we want to recover any panics from rule execution defer func() { if r := recover(); r != nil { eng.Logger.Error("automod event execution exception", "err", r, "did", did, "type", "account") eventErrorCount.WithLabelValues("account").Inc() } }() var cancel context.CancelFunc if eng.Config.IdentityEventTimeout != 0 { ctx, cancel = context.WithTimeout(ctx, eng.Config.IdentityEventTimeout) defer cancel() }
// first purge any caches; we need to re-resolve from scratch on account updates if err := eng.PurgeAccountCaches(ctx, did); err != nil { eng.Logger.Error("failed to purge account cache; account rule may not run correctly", "err", err) } // TODO(bnewbold): if it was a tombstone, this might fail ident, err := eng.Directory.LookupDID(ctx, did) if err != nil { eventErrorCount.WithLabelValues("account").Inc() return fmt.Errorf("resolving identity: %w", err) } if ident == nil { eventErrorCount.WithLabelValues("account").Inc() return fmt.Errorf("identity not found for DID: %s", did.String()) }
var am *AccountMeta if !eng.Config.SkipAccountMeta { am, err = eng.GetAccountMeta(ctx, ident) if err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("failed to fetch account metadata: %w", err) } } else { am = &AccountMeta{ Identity: ident, Profile: ProfileSummary{}, } } ac := NewAccountContext(ctx, eng, *am) if err := eng.Rules.CallAccountRules(&ac); err != nil { eventErrorCount.WithLabelValues("account").Inc() return fmt.Errorf("rule execution failed: %w", err) } eng.CanonicalLogLineAccount(&ac) if err := eng.persistAccountModActions(&ac); err != nil { eventErrorCount.WithLabelValues("account").Inc() return fmt.Errorf("failed to persist actions for account event: %w", err) } if err := eng.persistCounters(ctx, ac.effects); err != nil { eventErrorCount.WithLabelValues("account").Inc() return fmt.Errorf("failed to persist counters for account event: %w", err) } return nil}
// Entrypoint for external code pushing repository updates. A simple repo commit results in multiple calls.//// This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.func (eng *Engine) ProcessRecordOp(ctx context.Context, op RecordOp) error { eventProcessCount.WithLabelValues("record").Inc() start := time.Now() defer func() { duration := time.Since(start) eventProcessDuration.WithLabelValues("record").Observe(duration.Seconds()) }()
// similar to an HTTP server, we want to recover any panics from rule execution defer func() { if r := recover(); r != nil { eng.Logger.Error("automod event execution exception", "err", r, "did", op.DID, "collection", op.Collection, "rkey", op.RecordKey) } }() var cancel context.CancelFunc if eng.Config.RecordEventTimeout != 0 { ctx, cancel = context.WithTimeout(ctx, eng.Config.RecordEventTimeout) defer cancel() }
if err := op.Validate(); err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("bad record op: %w", err) } ident, err := eng.Directory.LookupDID(ctx, op.DID) if err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("resolving identity: %w", err) } if ident == nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("identity not found for DID: %s", op.DID) }
var am *AccountMeta if !eng.Config.SkipAccountMeta { am, err = eng.GetAccountMeta(ctx, ident) if err != nil { eventErrorCount.WithLabelValues("identity").Inc() return fmt.Errorf("failed to fetch account metadata: %w", err) } } else { am = &AccountMeta{ Identity: ident, Profile: ProfileSummary{}, } } rc := NewRecordContext(ctx, eng, *am, op) rc.Logger.Debug("processing record") switch op.Action { case CreateOp, UpdateOp: if err := eng.Rules.CallRecordRules(&rc); err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("rule execution failed: %w", err) } case DeleteOp: if err := eng.Rules.CallRecordDeleteRules(&rc); err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("rule execution failed: %w", err) } default: eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("unexpected op action: %s", op.Action) } eng.CanonicalLogLineRecord(&rc) // purge the account meta cache when profile is updated if rc.RecordOp.Collection == "app.bsky.actor.profile" { if err := eng.PurgeAccountCaches(ctx, op.DID); err != nil { eng.Logger.Error("failed to purge identity cache", "err", err) } } if err := eng.persistRecordModActions(&rc); err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("failed to persist actions for record event: %w", err) } if err := eng.persistCounters(ctx, rc.effects); err != nil { eventErrorCount.WithLabelValues("record").Inc() return fmt.Errorf("failed to persist counts for record event: %w", err) } return nil}
// Purge metadata caches for a specific account.func (e *Engine) PurgeAccountCaches(ctx context.Context, did syntax.DID) error { e.Logger.Debug("purging account caches", "did", did.String()) dirErr := e.Directory.Purge(ctx, did.AtIdentifier()) cacheErr := e.Cache.Purge(ctx, "acct", did.String()) if dirErr != nil { return dirErr } return cacheErr}
func (e *Engine) CanonicalLogLineAccount(c *AccountContext) { c.Logger.Info("canonical-event-line", "accountLabels", c.effects.AccountLabels, "accountFlags", c.effects.AccountFlags, "accountTags", c.effects.AccountTags, "accountTakedown", c.effects.AccountTakedown, "accountReports", len(c.effects.AccountReports), )}
func (e *Engine) CanonicalLogLineRecord(c *RecordContext) { c.Logger.Info("canonical-event-line", "accountLabels", c.effects.AccountLabels, "accountFlags", c.effects.AccountFlags, "accountTags", c.effects.AccountTags, "accountTakedown", c.effects.AccountTakedown, "accountReports", len(c.effects.AccountReports), "recordLabels", c.effects.RecordLabels, "recordFlags", c.effects.RecordFlags, "recordTags", c.effects.RecordTags, "recordTakedown", c.effects.RecordTakedown, "recordReports", len(c.effects.RecordReports), )}