matrix-nodejs-homeserver 0.3.3 → 0.3.4

package/README.md

@@ -4,7 +4,7 @@
 [![Load test: SQLite](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fsqlite.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
 [![Load test: Postgres](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-nocluster.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
 [![Load test: Postgres cluster, 1 node](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-cluster-1.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
-[![Load test: Postgres cluster, 5 nodes](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-cluster-5.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
+[![Load test: Postgres cluster, 2 nodes](https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fk18k%2Fmatrix-nodejs-homeserver%2Floadtest-results%2Fbadges%2Fpg-cluster-2.json)](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml)
 
 A [Matrix](https://matrix.org) homeserver as an importable Node.js library. It isn't
 tied to any HTTP framework, database, auth system or deployment shape. You can use
@@ -516,42 +516,53 @@ BASE_URL=http://localhost:8008 ONLINE_USERS=1000 MESSAGES_PER_SECOND=50 ROOMS=25
 
 <!-- loadtest-results:start -->
 The badges at the top come from the [Load test workflow](https://github.com/k18k/matrix-nodejs-homeserver/actions/workflows/loadtest.yml) on main: the same
-scenario on one GitHub runner (4 CPUs), with k6 on the same machine. Each run's job summary has
+scenario on one GitHub runner (4 CPUs), with k6 on the same machine, and clusters of two nodes
+(five nodes would compete with Postgres and k6 for four CPUs). Each run's job summary has
 the full table.
 
-Latest results: 1000 users online in 25 rooms (40 per room), 50 messages/s, 30 s ramp-up then
-30 s at full load, on one developer machine (WSL2, Docker Desktop). Times are p50 / p95.
-
-| Setup | req/s | send | /sync | join | delivery | messages delivered | failed |
-|---|---|---|---|---|---|---|---|
-| SQLite, 1 process | 662 | 97 ms / 0.16 s | 0.87 s / 1.6 s | 10 ms / 91 ms | 1.64 s / 2.70 s | 53,935 | 0% |
-| Postgres, no cluster | 670 | 15 ms / 19 ms | 1.1 s / 1.8 s | 14 ms / 23 ms | 1.76 s / 2.31 s | 58,667 | 0% |
-| Postgres, cluster, 1 node | 593 | 27 ms / 38 ms | 1.3 s / 2.0 s | 36 ms / 51 ms | 1.96 s / 2.57 s | 58,493 | 0% |
-| Postgres, cluster, 5 nodes | 871 | 60 ms / 88 ms | 0.50 s / 1.1 s | 62 ms / 119 ms | 0.70 s / 1.09 s | 59,298 | 0% |
-
-What the load tests found and fixed so far: presence written on every `/sync` (#26), one commit
-per push notification (#27), a missing index (#28), Postgres cluster locks that could deadlock
-the pool (#29), stream writes serialized per instance (#30), `/sync` reading every change on the
-server (#31) and every joined room (#33), lock handover by polling (#32). Then `/sync` reads were batched
-(#34) and a process builds at most four sync responses at once (#35), so sends no longer queue
-behind the syncs a message wakes.
-
-Since 0.3.2 (#38–#45), Postgres delivery time fell by about 55% on one node and 50% on five:
-- changed rooms are built concurrently, with fewer reads each (#38);
-- push notifications of a message are written in one statement (#39);
-- Postgres statements are prepared once per connection (#40);
-- push rules are no longer copied per member (#41);
-- to-device acknowledgements run only when needed (#42);
-- reads issued at the same moment by concurrent requests share one statement (#43);
-- presence and device-list changes are found through a stream index (#44);
-- batched reads take half as long to plan (#45).
-
-On SQLite, commits no longer wait for an fsync (#46). Database calls also yield to the event
-loop (#47): before that, a wave of syncs could hold it for seconds, sends took 0.74 s and the
-server took in only about 40% of the messages the scenario sends.
-
-With every user receiving about two messages a second, delivery time is how long it takes a
-process to rebuild every user's `/sync` in turn: about 750 per second per Postgres node here.
+Latest results, on one developer machine (WSL2, Docker Desktop): 1000 users online in 25 rooms
+(40 per room), 30 s ramp-up, then 30 s of messages. Times are p50 / p95; "sent" is the share of
+the messages the scenario asks for that the server accepted (a server that falls behind takes
+fewer, and then looks faster than it is).
+
+At 10 messages/s (every user receiving one message every 2.5 s):
+
+| Setup | send | delivery | sent | failed |
+|---|---|---|---|---|
+| SQLite, 1 process | 5 ms / 15 ms | 14 ms / 0.18 s | 100% | 0% |
+| Postgres, no cluster | 9 ms / 30 ms | 29 ms / 0.60 s | 100% | 0% |
+
+At 50 messages/s (every user receiving two messages a second, 59,000 deliveries in 30 s):
+
+| Setup | req/s | send | /sync | delivery | sent | failed |
+|---|---|---|---|---|---|---|
+| SQLite, 1 process | 722 | 11 ms / 25 ms | 0.77 s / 1.3 s | 1.2 s / 1.6 s | 100% | 0% |
+| Postgres, no cluster | 687 | 35 ms / 49 ms | 0.79 s / 1.2 s | 1.2 s / 1.6 s | 100% | 0% |
+| Postgres, cluster, 1 node | 766 | 72 ms / 98 ms | 1.1 s / 1.5 s | 1.7 s / 2.2 s | 100% | 0% |
+| Postgres, cluster, 5 nodes | 910 | 146 ms / 233 ms | 0.42 s / 1.6 s | 0.37 s / 1.5 s | 100% | 0% |
+
+At 50 messages/s, delivery time is how long a process takes to rebuild the `/sync` of every
+user in turn, since every user has something new in nearly every rebuild.
+
+What the load tests found and fixed:
+- presence written on every `/sync` (#26), one commit per push notification (#27), a missing
+  index (#28), Postgres cluster locks that could deadlock the pool (#29), stream writes
+  serialized per instance (#30), `/sync` reading every change on the server (#31) and every
+  joined room (#33), lock handover by polling (#32), unbatched `/sync` reads (#34), syncs
+  crowding out sends (#35);
+- in 0.3.3 (#38–#47): rooms built one after another (#38), a statement per push notification
+  (#39), Postgres re-planning every statement (#40), push rules copied per member (#41),
+  needless to-device deletes (#42), concurrent reads as separate statements (#43), presence and
+  device lists looked up per user (#44), costly batched reads (#45), an fsync per SQLite commit
+  (#46), a blocked event loop (#47);
+- since 0.3.3: waiting `/sync` requests rebuilt whenever anything on the server changed, and
+  about two thirds of all rebuilds found nothing new (#50); a single instance now keeps track of
+  where data last changed, so `/sync` skips reads that would find nothing, like Synapse's stream
+  change caches (#51); queued syncs held the event loop, and yielding per statement made sends
+  slow (#52).
+
+The load test itself was fixed too: its senders registered during the measurement, so a slow
+server was sent fewer messages, and nginx could start after k6 (a red badge with "100% failed").
 <!-- loadtest-results:end -->
 
 ## License

package/dist/api/longpoll.js

@@ -0,0 +1,61 @@
+//#region src/api/longpoll.ts
+/**
+* The long-poll loop of `/sync` and sliding sync: build a response up to the current stream
+* position, and while it has nothing new, wait for a change for `userId` and build again.
+*
+* https://github.com/k18k/matrix-nodejs-homeserver/issues/50: after a build with nothing new, the
+* loop used to build again whenever the server-wide position had moved, which under load is
+* always, so waiting requests rebuilt back to back. Now it registers for the user's wake-ups
+* before reading the position, so none is missed during a build, and otherwise sleeps. A wake-up
+* says which position its change has; if the next build cannot see it yet (another write in
+* flight holds the position back), the loop waits for the position to get there.
+*
+* `build(to)` returns whether the response is final (`done`); returns the last built value, the
+* position it was built at, and whether the request was aborted while waiting.
+*/
+async function longPoll(hs, userId, timeoutMs, signal, build) {
+	const deadline = Date.now() + timeoutMs;
+	let pending = 0;
+	for (;;) {
+		const listener = hs.notifier.listen(userId);
+		pending = Math.max(pending, listener.recent);
+		let to;
+		let built;
+		try {
+			to = await hs.streams.position();
+			if (pending > to) to = await hs.streams.position(true);
+			built = await build(to);
+		} catch (err) {
+			listener.cancel();
+			throw err;
+		}
+		if (pending <= to) pending = 0;
+		const remaining = deadline - Date.now();
+		if (built.done || remaining <= 0 || signal?.aborted) {
+			listener.cancel();
+			return {
+				value: built.value,
+				to,
+				aborted: !!signal?.aborted
+			};
+		}
+		if (pending > to) {
+			listener.cancel();
+			if (await hs.streams.waitFor(pending, remaining, signal)) continue;
+			return {
+				value: built.value,
+				to,
+				aborted: !!signal?.aborted
+			};
+		}
+		const woke = await listener.wait(remaining, signal);
+		if (woke === null) return {
+			value: built.value,
+			to,
+			aborted: !!signal?.aborted
+		};
+		pending = Math.max(pending, woke);
+	}
+}
+//#endregion
+export { longPoll };

package/dist/api/slidingsync.js

@@ -6,6 +6,7 @@ import { getState } from "../core/authrules.js";
 import { record, string, unknown } from "../vendor/zod/v4/classic/schemas.js";
 import { body, lenient } from "../http/input.js";
 import { procedure } from "../http/procedure.js";
+import { longPoll } from "./longpoll.js";
 import { roomEphemeral, roomTimeline, toStripped } from "./sync.js";
 //#region src/api/slidingsync.ts
 const slidingSyncBody = body({
@@ -104,37 +105,34 @@ async function slidingSync(ctx) {
 			rooms: {}
 		};
 	}
-	const deadline = Date.now() + timeout;
-	for (;;) {
-		const to = await hs.streams.position();
-		const { response, empty, next } = await buildResponse(hs, s, body, conn, since, to);
-		const remaining = deadline - Date.now();
-		if (since === null || !empty || remaining <= 0) {
-			await hs.db.upsert("sliding_sync_connections", {
-				user_id: s.userId,
-				device_id: s.deviceId,
-				conn_id: connId,
-				pos: to,
-				state: {
-					...next,
-					prevPos: since
-				},
-				updated_ts: Date.now()
-			});
-			return {
-				pos: String(to),
-				...response
-			};
-		}
-		if (await hs.streams.position() > to) continue;
-		await hs.notifier.wait(s.userId, remaining, ctx.request.signal);
-		if (ctx.request.signal?.aborted) return {
-			pos: String(since),
-			lists: {},
-			rooms: {},
-			extensions: {}
+	const { value, to, aborted } = await longPoll(hs, s.userId, timeout, ctx.request.signal, async (to) => {
+		const built = await buildResponse(hs, s, body, conn, since, to);
+		return {
+			value: built,
+			done: since === null || !built.empty
 		};
-	}
+	});
+	if (aborted && value.empty) return {
+		pos: String(since),
+		lists: {},
+		rooms: {},
+		extensions: {}
+	};
+	await hs.db.upsert("sliding_sync_connections", {
+		user_id: s.userId,
+		device_id: s.deviceId,
+		conn_id: connId,
+		pos: to,
+		state: {
+			...value.next,
+			prevPos: since
+		},
+		updated_ts: Date.now()
+	});
+	return {
+		pos: String(to),
+		...value.response
+	};
 }
 async function buildResponse(hs, s, body, conn, since, to) {
 	const userId = s.userId;

package/dist/api/sync.js

@@ -8,7 +8,9 @@ import { deviceListChangesQuery } from "../core/keys.js";
 import { body } from "../http/input.js";
 import { procedure } from "../http/procedure.js";
 import { readBatch } from "../storage/batch.js";
+import { trackedReads } from "../core/changes.js";
 import { matchesFilter, roomAllowed, validateSyncFilter } from "./filters.js";
+import { longPoll } from "./longpoll.js";
 import { Semaphore } from "../core/semaphore.js";
 import { fullProfile } from "../core/profile.js";
 //#region src/api/sync.ts
@@ -330,6 +332,8 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		operator: "lte",
 		value: p.to
 	}];
+	const logs = hs.changes?.logs;
+	const mayHaveChanged = (log, rooms) => logs ? logs[log].filterChanged(rooms, since) : rooms;
 	const chunks = (list) => Array.from({ length: Math.ceil(list.length / 500) }, (_, i) => list.slice(i * 500, i * 500 + 500));
 	const inRooms = (chunk) => ({
 		field: "room_id",
@@ -337,31 +341,34 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 		value: chunk
 	});
 	const queries = [];
-	for (const chunk of chunks(joined)) {
-		queries.push({
-			model: "events",
-			opts: {
-				where: [inRooms(chunk), ...range],
-				fields: ["room_id"]
-			}
-		});
-		queries.push({
-			model: "receipts",
-			opts: { where: [inRooms(chunk), ...range] }
-		});
-		queries.push({
-			model: "partial_state_rooms",
-			opts: {
-				where: [inRooms(chunk), {
-					field: "completed_stream",
-					operator: "gt",
-					value: since
-				}],
-				fields: ["room_id"]
-			}
-		});
-	}
-	for (const chunk of chunks(anyMembership)) queries.push({
+	const kinds = [];
+	const add = (kind, query) => {
+		kinds.push(kind);
+		queries.push(query);
+	};
+	for (const chunk of chunks(mayHaveChanged("roomEvents", joined))) add("events", {
+		model: "events",
+		opts: {
+			where: [inRooms(chunk), ...range],
+			fields: ["room_id"]
+		}
+	});
+	for (const chunk of chunks(mayHaveChanged("roomReceipts", joined))) add("receipts", {
+		model: "receipts",
+		opts: { where: [inRooms(chunk), ...range] }
+	});
+	for (const chunk of chunks(mayHaveChanged("roomPartialState", joined))) add("completed", {
+		model: "partial_state_rooms",
+		opts: {
+			where: [inRooms(chunk), {
+				field: "completed_stream",
+				operator: "gt",
+				value: since
+			}],
+			fields: ["room_id"]
+		}
+	});
+	for (const chunk of chunks(mayHaveChanged("roomMembers", anyMembership))) add("members", {
 		model: "memberships",
 		opts: { where: [inRooms(chunk), {
 			field: "stream",
@@ -369,20 +376,18 @@ async function changesSince(hs, p, memberships, since, accountRows) {
 			value: since
 		}] }
 	});
-	const results = await readBatch(hs.db, queries);
+	const results = queries.length ? await readBatch(hs.db, queries) : [];
 	const touched = /* @__PURE__ */ new Set();
 	const receipts = /* @__PURE__ */ new Map();
-	const joinedChunks = Math.ceil(joined.length / 500);
-	for (let c = 0; c < joinedChunks; c++) {
-		const [events, receiptRows, completed] = results.slice(c * 3, c * 3 + 3);
-		for (const r of events) touched.add(r.room_id);
-		for (const r of receiptRows) {
-			touched.add(r.room_id);
-			receipts.set(r.room_id, [...receipts.get(r.room_id) ?? [], r]);
+	const memberChanges = [];
+	results.forEach((rows, i) => {
+		const kind = kinds[i];
+		for (const r of rows) {
+			if (kind === "members") memberChanges.push(r);
+			else touched.add(r.room_id);
+			if (kind === "receipts") receipts.set(r.room_id, [...receipts.get(r.room_id) ?? [], r]);
 		}
-		for (const r of completed) touched.add(r.room_id);
-	}
-	const memberChanges = results.slice(joinedChunks * 3).flat();
+	});
 	const accountData = /* @__PURE__ */ new Map();
 	for (const r of accountRows) {
 		if (r.room_id) touched.add(r.room_id);
@@ -428,76 +433,115 @@ async function buildSync(hs, p) {
 		operator: "lte",
 		value: p.since.toDevice
 	}]) : Promise.resolve(0);
-	const [memberships, ignoredRows, toDeviceRows, oneTimeKeyRows, fallbackRows, accountRows = []] = await readBatch(hs.db, [
+	const device = `${userId}|${p.session.deviceId}`;
+	const [memberships, ignoredRows, toDeviceRows, oneTimeKeyRows, fallbackRows, accountRows = []] = await trackedReads(hs.db, hs.changes, [
 		{
-			model: "memberships",
-			opts: { where: [{
-				field: "user_id",
-				value: userId
-			}] }
-		},
-		{
-			model: "account_data",
-			opts: { where: [
-				{
+			query: {
+				model: "memberships",
+				opts: { where: [{
 					field: "user_id",
 					value: userId
-				},
-				{
-					field: "room_id",
-					value: ""
-				},
-				{
-					field: "type",
-					value: M.IGNORED_USER_LIST
-				}
-			] }
+				}] }
+			},
+			cached: {
+				name: "userMemberships",
+				key: userId
+			}
 		},
 		{
-			model: "to_device",
-			opts: {
-				where: [...deviceWhere, {
-					field: "stream",
-					operator: "gt",
-					value: p.since?.toDevice ?? 0
-				}],
-				sortBy: {
-					field: "stream",
-					direction: "asc"
-				},
-				limit: 100
+			query: {
+				model: "account_data",
+				opts: { where: [
+					{
+						field: "user_id",
+						value: userId
+					},
+					{
+						field: "room_id",
+						value: ""
+					},
+					{
+						field: "type",
+						value: M.IGNORED_USER_LIST
+					}
+				] }
+			},
+			cached: {
+				name: "ignoredUsers",
+				key: userId
 			}
 		},
 		{
-			model: "one_time_keys",
-			opts: {
-				where: [...deviceWhere, {
-					field: "fallback",
-					value: false
-				}],
-				fields: ["algorithm"]
+			query: {
+				model: "to_device",
+				opts: {
+					where: [...deviceWhere, {
+						field: "stream",
+						operator: "gt",
+						value: p.since?.toDevice ?? 0
+					}],
+					sortBy: {
+						field: "stream",
+						direction: "asc"
+					},
+					limit: 100
+				}
+			},
+			unlessChanged: {
+				log: "toDevice",
+				key: device,
+				after: p.since?.toDevice ?? 0
 			}
 		},
 		{
-			model: "fallback_keys",
-			opts: {
-				where: [...deviceWhere, {
-					field: "used",
-					value: false
-				}],
-				fields: ["algorithm"]
+			query: {
+				model: "one_time_keys",
+				opts: {
+					where: [...deviceWhere, {
+						field: "fallback",
+						value: false
+					}],
+					fields: ["algorithm"]
+				}
+			},
+			cached: {
+				name: "oneTimeKeys",
+				key: device
+			}
+		},
+		{
+			query: {
+				model: "fallback_keys",
+				opts: {
+					where: [...deviceWhere, {
+						field: "used",
+						value: false
+					}],
+					fields: ["algorithm"]
+				}
+			},
+			cached: {
+				name: "fallbackKeys",
+				key: device
 			}
 		},
 		...incremental ? [{
-			model: "account_data",
-			opts: { where: [{
-				field: "user_id",
-				value: userId
-			}, {
-				field: "stream",
-				operator: "gt",
-				value: since
-			}] }
+			query: {
+				model: "account_data",
+				opts: { where: [{
+					field: "user_id",
+					value: userId
+				}, {
+					field: "stream",
+					operator: "gt",
+					value: since
+				}] }
+			},
+			unlessChanged: {
+				log: "accountData",
+				key: userId,
+				after: since
+			}
 		}] : []
 	]);
 	p = {
@@ -644,17 +688,31 @@ async function buildSync(hs, p) {
 			value: []
 		}] }
 	};
-	let [presenceRows = [], newlySharedPresence = [], deviceRows] = await readBatch(hs.db, [
-		presenceQuery,
-		{
+	let [presenceRows = [], newlySharedPresence = [], deviceRows] = await trackedReads(hs.db, hs.changes, [
+		since === null ? { query: presenceQuery } : {
+			query: presenceQuery,
+			unlessChanged: {
+				log: "presence",
+				key: "*",
+				after: since
+			}
+		},
+		{ query: {
 			model: "presence",
 			opts: { where: [{
 				field: "user_id",
 				operator: "in",
 				value: [...newlyShared]
 			}] }
-		},
-		...since !== null ? [recent("device_list_changes")] : []
+		} },
+		...since !== null ? [{
+			query: recent("device_list_changes"),
+			unlessChanged: {
+				log: "deviceLists",
+				key: "*",
+				after: since
+			}
+		}] : []
 	]);
 	if (since !== null) {
 		if (presenceRows.length > RECENT_CHANGES) presenceRows = await hs.db.findMany("presence", { where: [{
@@ -745,14 +803,12 @@ async function sync(ctx) {
 	const timeout = Math.min(Math.max(Number.parseInt(ctx.query.get("timeout") ?? "0", 10) || 0, 0), hs.config.maxSyncTimeoutMs);
 	const setPresence = ctx.query.get("set_presence") ?? "online";
 	if (setPresence !== "offline") await touchPresence(hs, session.userId, setPresence);
-	const deadline = Date.now() + timeout;
-	for (;;) {
-		const to = await hs.streams.position();
-		const ignored = /* @__PURE__ */ new Set();
-		const stable = ctx.query.get("use_state_after") === "true";
-		const unstable = ctx.query.get(UNSTABLE.ORG.MATRIX.MSC4222.USE_STATE_AFTER) === "true";
-		const useStateAfter = stable || unstable;
-		const stateAfterKey = stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER;
+	const ignored = /* @__PURE__ */ new Set();
+	const stable = ctx.query.get("use_state_after") === "true";
+	const unstable = ctx.query.get(UNSTABLE.ORG.MATRIX.MSC4222.USE_STATE_AFTER) === "true";
+	const useStateAfter = stable || unstable;
+	const stateAfterKey = stable ? "state_after" : UNSTABLE.ORG.MATRIX.MSC4222.STATE_AFTER;
+	const { value } = await longPoll(hs, session.userId, timeout, ctx.request.signal, async (to) => {
 		const { body, empty } = await syncSlots(hs).run(() => buildSync(hs, {
 			session,
 			ignored,
@@ -763,20 +819,21 @@ async function sync(ctx) {
 			useStateAfter,
 			stateAfterKey
 		}));
-		const remaining = deadline - Date.now();
-		if (!since || !empty || remaining <= 0 || fullState) return body;
-		if (await hs.streams.position() > to) continue;
-		await hs.notifier.wait(session.userId, remaining, ctx.request.signal);
-		if (ctx.request.signal?.aborted) return body;
-	}
+		return {
+			value: body,
+			done: !since || !empty || fullState
+		};
+	});
+	return value;
 }
 const LAST_ACTIVE_GRANULARITY_MS = 6e4;
 async function touchPresence(hs, userId, presence) {
 	const state = presence === "unavailable" ? "unavailable" : "online";
-	const row = await hs.db.findOne("presence", [{
+	const read = () => hs.db.findOne("presence", [{
 		field: "user_id",
 		value: userId
 	}]);
+	const row = hs.changes ? await hs.changes.values.presenceRow.get(userId, read) : await read();
 	if (row && row.presence === state) {
 		if (Date.now() - row.last_active_ts >= LAST_ACTIVE_GRANULARITY_MS) await hs.db.update("presence", [{
 			field: "user_id",
@@ -784,13 +841,17 @@ async function touchPresence(hs, userId, presence) {
 		}], { last_active_ts: Date.now() });
 		return;
 	}
-	await hs.streams.write((stream) => hs.db.upsert("presence", {
-		user_id: userId,
-		presence: state,
-		status_msg: row?.status_msg ?? null,
-		last_active_ts: Date.now(),
-		stream
-	}));
+	const stream = await hs.streams.write(async (stream) => {
+		await hs.db.upsert("presence", {
+			user_id: userId,
+			presence: state,
+			status_msg: row?.status_msg ?? null,
+			last_active_ts: Date.now(),
+			stream
+		});
+		return stream;
+	});
+	hs.notifier.notify([userId, ...await hs.rooms.usersSharingRooms(userId)], stream);
 	await hs.federation.onPresence(userId, state, row?.status_msg ?? null).catch(() => {});
 }
 function registerSyncRoutes(r) {

package/dist/core/admin.js

@@ -301,6 +301,7 @@ var AdminService = class {
 			content: { tags: { [M.SERVER_NOTICE]: { order: .5 } } },
 			stream
 		}));
+		this.hs.notifier.notify([userId]);
 		return room_id;
 	}
 };