Method heartbeatTick

coderd/x/chatd/chatd.go:4850–4899

heartbeatTick issues a single batch UPDATE for all running chats owned by this worker. Chats missing from the result set are interrupted (stolen by another replica or already completed).

(ctx context.Context)

// owned by this worker. Chats missing from the result set are
// interrupted (stolen by another replica or already completed).
func (p *Server) heartbeatTick(ctx context.Context) {
	// Snapshot the registry under the lock.
	p.heartbeatMu.Lock()
	snapshot := maps.Clone(p.heartbeatRegistry)
	p.heartbeatMu.Unlock()

	if len(snapshot) == 0 {
		return
	}

	// Collect the IDs we believe we own.
	ids := slices.Collect(maps.Keys(snapshot))

	//nolint:gocritic // AsChatd provides narrowly-scoped daemon
	// access for batch-updating heartbeats.
	chatdCtx := dbauthz.AsChatd(ctx)
	updatedIDs, err := p.db.UpdateChatHeartbeats(chatdCtx, database.UpdateChatHeartbeatsParams{
		IDs:      ids,
		WorkerID: p.workerID,
		Now:      p.clock.Now(),
	})
	if err != nil {
		p.logger.Error(ctx, "batch heartbeat failed", slog.Error(err))
		return
	}

	// Build a set of IDs that were successfully updated.
	updated := make(map[uuid.UUID]struct{}, len(updatedIDs))
	for _, id := range updatedIDs {
		updated[id] = struct{}{}
	}

	// Interrupt registered chats that were not in the result
	// (stolen by another replica or already completed).
	for id, entry := range snapshot {
		if _, ok := updated[id]; !ok {
			entry.logger.Warn(ctx, "chat not in batch heartbeat result, interrupting")
			entry.cancelWithCause(chatloop.ErrInterrupted)
			continue
		}
		// Bump workspace usage for surviving chats.
		newWsID := p.trackWorkspaceUsage(ctx, entry.chatID, entry.workspaceID, entry.logger)
		// Update workspace ID in the registry for next tick.
		p.heartbeatMu.Lock()
		if current, exists := p.heartbeatRegistry[id]; exists {
			current.workspaceID = newWsID
		}
		p.heartbeatMu.Unlock()
	}
}

// streamSubscriberControlFetchContext keeps a control-path lookup tied to the
// requesting subscriber while applying a fallback timeout when the caller has