Method dispatchChatAutoArchive

coderd/database/dbpurge/dbpurge.go:536–611

dispatchChatAutoArchive audits every archived root chat and enqueues one notification per owner covering the roots archived in this tick. Children inherit their root's archival decision and are skipped for audit, matching the manual archive path (patchChat audits the root only). Enqueue is per-tick:

(auditCtx, enqueueCtx context.Context, tickStart time.Time, autoArchiveDays, retentionDays int32, archived []database.AutoArchiveInactiveChatsRow)

// is the cancellable parent: on shutdown we abandon any remaining digests
// rather than blocking Close.
func (i *instance) dispatchChatAutoArchive(auditCtx, enqueueCtx context.Context, tickStart time.Time, autoArchiveDays, retentionDays int32, archived []database.AutoArchiveInactiveChatsRow) {
	// Children inherit their root's archival decision and are skipped
	// for both audit and digest. Partition once so the two loops
	// cannot drift apart if the cascade shape ever changes.
	roots := slice.Filter(archived, func(r database.AutoArchiveInactiveChatsRow) bool {
		return !r.ParentChatID.Valid
	})

	auditor := *i.auditor.Load()
	for _, row := range roots {
		after := chatFromAutoArchiveRow(i.logger, row)
		before := after
		before.Archived = false
		audit.BackgroundAudit(auditCtx, &audit.BackgroundAuditParams[database.Chat]{
			Audit:            auditor,
			Log:              i.logger,
			UserID:           row.OwnerID,
			OrganizationID:   row.OrganizationID,
			Action:           database.AuditActionWrite,
			Old:              before,
			New:              after,
			Status:           http.StatusOK,
			AdditionalFields: audit.BackgroundTaskFieldsBytes(auditCtx, i.logger, audit.BackgroundSubsystemChatAutoArchive),
		})
	}

	// Group archived roots by owner. Inline because this is the
	// only call site and the loop body is self-explanatory.
	rootsByOwner := make(map[uuid.UUID][]database.AutoArchiveInactiveChatsRow, len(roots))
	for _, row := range roots {
		rootsByOwner[row.OwnerID] = append(rootsByOwner[row.OwnerID], row)
	}

	// Sort owner IDs so shutdown abandons a deterministic tail of the dispatch list.
	ownerIDs := make([]uuid.UUID, 0, len(rootsByOwner))
	for id := range rootsByOwner {
		ownerIDs = append(ownerIDs, id)
	}
	slices.SortFunc(ownerIDs, func(a, b uuid.UUID) int {
		return cmp.Compare(a.String(), b.String())
	})

	dispatched := 0
	for _, ownerID := range ownerIDs {
		// Check between iterations so shutdown unblocks promptly. A
		// hung in-flight enqueue is unblocked by enqueueCtx propagating
		// cancellation into the DB call. Skipped owners are not
		// re-notified on the next tick because AutoArchiveInactiveChats
		// only returns rows with archived = false; we accept that
		// tradeoff over hanging shutdown.
		if err := enqueueCtx.Err(); err != nil {
			i.logger.Warn(enqueueCtx, "chat auto-archive digest dispatch canceled",
				slog.F("remaining_owners", len(ownerIDs)-dispatched),
				slog.Error(err))
			return
		}
		dispatched++