Modules can use Synapse's module API to register callbacks. Callbacks are functions that
-Synapse will call when performing specific actions. Callbacks must be asynchronous, and
-are split in categories. A single module may implement callbacks from multiple categories,
-and is under no obligation to implement all callbacks from the categories it registers
-callbacks for.
+Synapse will call when performing specific actions. Callbacks must be asynchronous (unless
+specified otherwise), and are split in categories. A single module may implement callbacks
+from multiple categories, and is under no obligation to implement all callbacks from the
+categories it registers callbacks for.
Note that the appropriate values for those fields depend on the amount
of free memory the database host has available.
+Additionally, admins of large deployments might want to consider using huge pages
+to help manage memory, especially when using large values of shared_buffers. You
+can read more about that here.
Note that the appropriate values for those fields depend on the amount
of free memory the database host has available.
+Additionally, admins of large deployments might want to consider using huge pages
+to help manage memory, especially when using large values of shared_buffers. You
+can read more about that here.
reason: information on the event that triggered the email to be sent. It's an
@@ -6302,7 +6348,7 @@ Edit your Synapse config file and change the oidc_config section:
-Dex is a simple, open-source, certified OpenID Connect Provider.
+
Dex is a simple, open-source OpenID Connect Provider.
Although it is designed to help building a full-blown provider with an
external database, it can be configured with static passwords in a config file.
Follow the Getting Started guide
@@ -6702,7 +6748,7 @@ documentation on setting up SiWA.
config:
email_template: "{{ user.email }}"
-
+
django-oauth-toolkit is a
Django application providing out of the box all the endpoints, data and logic
needed to add OAuth2 capabilities to your Django projects. It supports
@@ -7861,14 +7907,14 @@ configuration file takes priority.
Modules must register their web resources in their __init__ method.
Modules can use Synapse's module API to register callbacks. Callbacks are functions that
-Synapse will call when performing specific actions. Callbacks must be asynchronous, and
-are split in categories. A single module may implement callbacks from multiple categories,
-and is under no obligation to implement all callbacks from the categories it registers
-callbacks for.
+Synapse will call when performing specific actions. Callbacks must be asynchronous (unless
+specified otherwise), and are split in categories. A single module may implement callbacks
+from multiple categories, and is under no obligation to implement all callbacks from the
+categories it registers callbacks for.
Modules can register callbacks using one of the module API's register_[...]_callbacks
methods. The callback functions are passed to these methods as keyword arguments, with
-the callback name as the argument name and the function as its value. This is demonstrated
-in the example below. A register_[...]_callbacks method exists for each category.
+the callback name as the argument name and the function as its value. A
+register_[...]_callbacks method exists for each category.
Callbacks for each category can be found on their respective page of the
Synapse documentation website.
@@ -8479,6 +8525,53 @@ class MyAuthProvider:
if self.credentials.get(username) == login_dict.get("password"):
return self.api.get_qualified_user_id(username)
+
+Background update controller callbacks allow module developers to control (e.g. rate-limit)
+how database background updates are run. A database background update is an operation
+Synapse runs on its database in the background after it starts. It's usually used to run
+database operations that would take too long if they were run at the same time as schema
+updates (which are run on startup) and delay Synapse's startup too much: populating a
+table with a big amount of data, adding an index on a big table, deleting superfluous data,
+etc.
+Background update controller callbacks can be registered using the module API's
+register_background_update_controller_callbacks method. Only the first module (in order
+of appearance in Synapse's configuration file) calling this method can register background
+update controller callbacks, subsequent calls are ignored.
+The available background update controller callbacks are:
+
+First introduced in Synapse v1.49.0
+def on_update(update_name: str, database_name: str, one_shot: bool) -> AsyncContextManager[int]
+
+Called when about to do an iteration of a background update. The module is given the name
+of the update, the name of the database, and a flag to indicate whether the background
+update will happen in one go and may take a long time (e.g. creating indices). If this last
+argument is set to False, the update will be run in batches.
+The module must return an async context manager. It will be entered before Synapse runs a
+background update; this should return the desired duration of the iteration, in
+milliseconds.
+The context manager will be exited when the iteration completes. Note that the duration
+returned by the context manager is a target, and an iteration may take substantially longer
+or shorter. If the one_shot flag is set to True, the duration returned is ignored.
+Note: Unlike most module callbacks in Synapse, this one is synchronous. This is
+because asynchronous operations are expected to be run by the async context manager.
+This callback is required when registering any other background update controller callback.
+
+First introduced in Synapse v1.49.0
+async def default_batch_size(update_name: str, database_name: str) -> int
+
+Called before the first iteration of a background update, with the name of the update and
+of the database. The module must return the number of elements to process in this first
+iteration.
+If this callback is not defined, Synapse will use a default value of 100.
+
+First introduced in Synapse v1.49.0
+async def min_batch_size(update_name: str, database_name: str) -> int
+
+Called before running a new batch for a background update, with the name of the update and
+of the database. The module must return an integer representing the minimum number of
+elements to process in this iteration. This number must be at least 1, and is used to
+ensure that progress is always made.
+If this callback is not defined, Synapse will use a default value of 100.
In order to port a module that uses Synapse's old module interface, its author needs to:
@@ -8661,7 +8754,7 @@ expressions:
^/_matrix/federation/v1/get_groups_publicised$
^/_matrix/key/v2/query
^/_matrix/federation/unstable/org.matrix.msc2946/spaces/
-^/_matrix/federation/unstable/org.matrix.msc2946/hierarchy/
+^/_matrix/federation/(v1|unstable/org.matrix.msc2946)/hierarchy/
# Inbound federation transaction request
^/_matrix/federation/v1/send/
@@ -8674,7 +8767,7 @@ expressions:
^/_matrix/client/(api/v1|r0|v3|unstable)/rooms/.*/members$
^/_matrix/client/(api/v1|r0|v3|unstable)/rooms/.*/state$
^/_matrix/client/unstable/org.matrix.msc2946/rooms/.*/spaces$
-^/_matrix/client/unstable/org.matrix.msc2946/rooms/.*/hierarchy$
+^/_matrix/client/(v1|unstable/org.matrix.msc2946)/rooms/.*/hierarchy$
^/_matrix/client/unstable/im.nheko.summary/rooms/.*/summary$
^/_matrix/client/(api/v1|r0|v3|unstable)/account/3pid$
^/_matrix/client/(api/v1|r0|v3|unstable)/devices$
@@ -11836,6 +11929,99 @@ contains Synapse version information).
"python_version": "3.6.8"
}
+
+This API allows a server administrator to manage Synapse's federation with other homeservers.
+Note: This API is new, experimental and "subject to change".
+
+This API gets the current destination retry timing info for all remote servers.
+The list contains all the servers with which the server federates,
+regardless of whether an error occurred or not.
+If an error occurs, it may take up to 20 minutes for the error to be displayed here,
+as a complete retry must have failed.
+The API is:
+A standard request with no filtering:
+
GET /_synapse/admin/v1/federation/destinations
+
+A response body like the following is returned:
+{
+ "destinations":[
+ {
+ "destination": "matrix.org",
+ "retry_last_ts": 1557332397936,
+ "retry_interval": 3000000,
+ "failure_ts": 1557329397936,
+ "last_successful_stream_ordering": null
+ }
+ ],
+ "total": 1
+}
+
+To paginate, check for next_token and if present, call the endpoint again
+with from set to the value of next_token. This will return a new page.
+If the endpoint does not return a next_token then there are no more destinations
+to paginate through.
+Parameters
+The following query parameters are available:
+
+from - Offset in the returned list. Defaults to 0.limit - Maximum amount of destinations to return. Defaults to 100.order_by - The method in which to sort the returned list of destinations.
+Valid values are:
+
+destination - Destinations are ordered alphabetically by remote server name.
+This is the default.retry_last_ts - Destinations are ordered by time of last retry attempt in ms.retry_interval - Destinations are ordered by how long until next retry in ms.failure_ts - Destinations are ordered by when the server started failing in ms.last_successful_stream_ordering - Destinations are ordered by the stream ordering
+of the most recent successfully-sent PDU.
+dir - Direction of room order. Either f for forwards or b for backwards. Setting
+this value to b will reverse the above sort order. Defaults to f.
+Caution: The database only has an index on the column destination.
+This means that if a different sort order is used,
+this can cause a large load on the database, especially for large environments.
+Response
+The following fields are returned in the JSON response body:
+
+destinations - An array of objects, each containing information about a destination.
+Destination objects contain the following fields:
+
+destination - string - Name of the remote server to federate.retry_last_ts - integer - The last time Synapse tried and failed to reach the
+remote server, in ms. This is 0 if the last attempt to communicate with the
+remote server was successful.retry_interval - integer - How long since the last time Synapse tried to reach
+the remote server before trying again, in ms. This is 0 if no further retrying occuring.failure_ts - nullable integer - The first time Synapse tried and failed to reach the
+remote server, in ms. This is null if communication with the remote server has never failed.last_successful_stream_ordering - nullable integer - The stream ordering of the most
+recent successfully-sent PDU
+to this destination, or null if this information has not been tracked yet.
+next_token: string representing a positive integer - Indication for pagination. See above.total - integer - Total number of destinations.
+
+This API gets the retry timing info for a specific remote server.
+The API is:
+GET /_synapse/admin/v1/federation/destinations/<destination>
+
+A response body like the following is returned:
+{
+ "destination": "matrix.org",
+ "retry_last_ts": 1557332397936,
+ "retry_interval": 3000000,
+ "failure_ts": 1557329397936,
+ "last_successful_stream_ordering": null
+}
+
+Response
+The response fields are the same like in the destinations array in
+List of destinations response.
The "manhole" allows server administrators to access a Python shell on a running
Synapse installation. This is a very powerful mechanism for administration and
@@ -12143,6 +12329,215 @@ renamed.
| python_twisted_reactor_pending_calls | reactor_pending_calls |
| python_twisted_reactor_tick_time | reactor_tick_time |
+
+It is possible to monitor much of the internal state of Synapse using Prometheus
+metrics and Grafana.
+A guide for configuring Synapse to provide metrics is available here
+and information on setting up Grafana is here.
+In this setup, Prometheus will periodically scrape the information Synapse provides and
+store a record of it over time. Grafana is then used as an interface to query and
+present this information through a series of pretty graphs.
+Once you have grafana set up, and assuming you're using our grafana dashboard template, look for the following graphs when debugging a slow/overloaded Synapse:
+
+
+This, along with the CPU and Memory graphs, is a good way to check the general health of your Synapse instance. It represents how long it takes for a user on your homeserver to send a message.
+
+
+
+These graphs show the database transactions that are occurring the most frequently, as well as those are that are taking the most amount of time to execute.
+
+In the first graph, we can see obvious spikes corresponding to lots of get_user_by_id transactions. This would be useful information to figure out which part of the Synapse codebase is potentially creating a heavy load on the system. However, be sure to cross-reference this with Transaction Duration, which states that get_users_by_id is actually a very quick database transaction and isn't causing as much load as others, like persist_events:
+
+Still, it's probably worth investigating why we're getting users from the database that often, and whether it's possible to reduce the amount of queries we make by adjusting our cache factor(s).
+The persist_events transaction is responsible for saving new room events to the Synapse database, so can often show a high transaction duration.
+
+The charts in the "Federation" section show information about incoming and outgoing federation requests. Federation data can be divided into two basic types:
+
+- PDU (Persistent Data Unit) - room events: messages, state events (join/leave), etc. These are permanently stored in the database.
+- EDU (Ephemeral Data Unit) - other data, which need not be stored permanently, such as read receipts, typing notifications.
+
+The "Outgoing EDUs by type" chart shows the EDUs within outgoing federation requests by type: m.device_list_update, m.direct_to_device, m.presence, m.receipt, m.typing.
+If you see a large number of m.presence EDUs and are having trouble with too much CPU load, you can disable presence in the Synapse config. See also #3971.
+
+
+
+This is quite a useful graph. It shows how many times Synapse attempts to retrieve a piece of data from a cache which the cache did not contain, thus resulting in a call to the database. We can see here that the _get_joined_profile_from_event_id cache is being requested a lot, and often the data we're after is not cached.
+Cross-referencing this with the Eviction Rate graph, which shows that entries are being evicted from _get_joined_profile_from_event_id quite often:
+
+we should probably consider raising the size of that cache by raising its cache factor (a multiplier value for the size of an individual cache). Information on doing so is available here (note that the configuration of individual cache factors through the configuration file is available in Synapse v1.14.0+, whereas doing so through environment variables has been supported for a very long time). Note that this will increase Synapse's overall memory usage.
+
+
+Forward extremities are the leaf events at the end of a DAG in a room, aka events that have no children. The more that exist in a room, the more state resolution that Synapse needs to perform (hint: it's an expensive operation). While Synapse has code to prevent too many of these existing at one time in a room, bugs can sometimes make them crop up again.
+If a room has >10 forward extremities, it's worth checking which room is the culprit and potentially removing them using the SQL queries mentioned in #1760.
+
+
+Large spikes in garbage collection times (bigger than shown here, I'm talking in the
+multiple seconds range), can cause lots of problems in Synapse performance. It's more an
+indicator of problems, and a symptom of other problems though, so check other graphs for what might be causing it.
+
+If you're still having performance problems with your Synapse instance and you've
+tried everything you can, it may just be a lack of system resources. Consider adding
+more CPU and RAM, and make use of worker mode
+to make use of multiple CPU cores / multiple machines for your homeserver.
+
+
+SELECT pg_size_pretty( pg_database_size( 'matrix' ) );
+
+pg_size_pretty
+----------------
+ 6420 MB
+(1 row)
+
+
+SELECT r.name, s.room_id, s.current_state_events
+ FROM room_stats_current s
+ LEFT JOIN room_stats_state r USING (room_id)
+ ORDER BY current_state_events DESC
+ LIMIT 20;
+
+and by state_group_events count:
+SELECT rss.name, s.room_id, count(s.room_id) FROM state_groups_state s
+LEFT JOIN room_stats_state rss USING (room_id)
+GROUP BY s.room_id, rss.name
+ORDER BY count(s.room_id) DESC
+LIMIT 20;
+
+plus same, but with join removed for performance reasons:
+SELECT s.room_id, count(s.room_id) FROM state_groups_state s
+GROUP BY s.room_id
+ORDER BY count(s.room_id) DESC
+LIMIT 20;
+
+
+SELECT relname, n_live_tup as rows
+ FROM pg_stat_user_tables
+ ORDER BY n_live_tup DESC
+ LIMIT 20;
+
+This query is quick, but may be very approximate, for exact number of rows use SELECT COUNT(*) FROM <table_name>.
+
+state_groups_state - 161687170
+event_auth - 8584785
+event_edges - 6995633
+event_json - 6585916
+event_reference_hashes - 6580990
+events - 6578879
+received_transactions - 5713989
+event_to_state_groups - 4873377
+stream_ordering_to_exterm - 4136285
+current_state_delta_stream - 3770972
+event_search - 3670521
+state_events - 2845082
+room_memberships - 2785854
+cache_invalidation_stream - 2448218
+state_groups - 1255467
+state_group_edges - 1229849
+current_state_events - 1222905
+users_in_public_rooms - 364059
+device_lists_stream - 326903
+user_directory_search - 316433
+
+
+SELECT e.room_id, r.name, COUNT(e.event_id) cnt FROM events e
+LEFT JOIN room_stats_state r USING (room_id)
+WHERE e.origin_server_ts >= DATE_PART('epoch', NOW() - INTERVAL '1 day') * 1000 GROUP BY e.room_id, r.name ORDER BY cnt DESC LIMIT 20;
+
+
+SELECT user_id, SUM(total_events)
+ FROM user_stats_historical
+ WHERE TO_TIMESTAMP(end_ts/1000) AT TIME ZONE 'UTC' > date_trunc('day', now() - interval '1 month')
+ GROUP BY user_id
+ ORDER BY SUM(total_events) DESC
+ LIMIT 20;
+
+
+SELECT e.room_id, r.name, e.event_id, e.type, e.content, j.json FROM events e
+ LEFT JOIN event_json j USING (room_id)
+ LEFT JOIN room_stats_state r USING (room_id)
+ WHERE sender = '@LOGIN:example.com'
+ AND e.type = 'm.room.message'
+ ORDER BY stream_ordering DESC
+ LIMIT 100;
+
+
+SELECT nspname || '.' || relname AS "relation",
+ pg_size_pretty(pg_total_relation_size(C.oid)) AS "total_size"
+ FROM pg_class C
+ LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
+ WHERE nspname NOT IN ('pg_catalog', 'information_schema')
+ AND C.relkind <> 'i'
+ AND nspname !~ '^pg_toast'
+ ORDER BY pg_total_relation_size(C.oid) DESC
+ LIMIT 20;
+
+
+public.state_groups_state - 27 GB
+public.event_json - 9855 MB
+public.events - 3675 MB
+public.event_edges - 3404 MB
+public.received_transactions - 2745 MB
+public.event_reference_hashes - 1864 MB
+public.event_auth - 1775 MB
+public.stream_ordering_to_exterm - 1663 MB
+public.event_search - 1370 MB
+public.room_memberships - 1050 MB
+public.event_to_state_groups - 948 MB
+public.current_state_delta_stream - 711 MB
+public.state_events - 611 MB
+public.presence_stream - 530 MB
+public.current_state_events - 525 MB
+public.cache_invalidation_stream - 466 MB
+public.receipts_linearized - 279 MB
+public.state_groups - 160 MB
+public.device_lists_remote_cache - 124 MB
+public.state_group_edges - 122 MB
+
+
+echo "select event_json.room_id,room_stats_state.name from event_json,room_stats_state where room_stats_state.room_id=event_json.room_id" | psql synapse | sort | uniq -c | sort -n
+
+ 9459 !FPUfgzXYWTKgIrwKxW:matrix.org | This Week in Matrix
+ 9459 !FPUfgzXYWTKgIrwKxW:matrix.org | This Week in Matrix (TWIM)
+ 17799 !iDIOImbmXxwNngznsa:matrix.org | Linux in Russian
+ 18739 !GnEEPYXUhoaHbkFBNX:matrix.org | Riot Android
+ 23373 !QtykxKocfZaZOUrTwp:matrix.org | Matrix HQ
+ 39504 !gTQfWzbYncrtNrvEkB:matrix.org | ru.[matrix]
+ 43601 !iNmaIQExDMeqdITdHH:matrix.org | Riot
+ 43601 !iNmaIQExDMeqdITdHH:matrix.org | Riot Web/Desktop
+
+
+SELECT rss.room_id, rss.name, rss.canonical_alias, rss.topic, rss.encryption, rsc.joined_members, rsc.local_users_in_room, rss.join_rules
+FROM room_stats_state rss
+LEFT JOIN room_stats_current rsc USING (room_id)
+WHERE room_id IN (WHERE room_id IN (
+ '!OGEhHVWSdvArJzumhm:matrix.org',
+ '!YTvKGNlinIzlkMTVRl:matrix.org'
+)
+
+This blog post by Victor Berger explains how to use many of the tools listed on this page: https://levans.fr/shrink-synapse-database.html
+
+
+The purge remote media API allows server admins to purge old cached remote media.
+
+This API deletes the local media from the disk of your own server.
+
+The purge history API allows server admins to purge historic events from their database, reclaiming disk space.
+
+Tool for compressing (deduplicating) state_groups_state table.
+
+Some easy SQL that reports useful stats about your Synapse database.
+
+As a general rule, I encourage people who want to understand the deepest darkest secrets of the database schema to drop by #synapse-dev:matrix.org and ask questions.
+However, one question that comes up frequently is that of how "state groups" work, and why the state_groups_state table gets so big, so here's an attempt to answer that question.
+We need to be able to relatively quickly calculate the state of a room at any point in that room's history. In other words, we need to know the state of the room at each event in that room. This is done as follows:
+A sequence of events where the state is the same are grouped together into a state_group; the mapping is recorded in event_to_state_groups. (Technically speaking, since a state event usually changes the state in the room, we are recording the state of the room after the given event id: which is to say, to a handwavey simplification, the first event in a state group is normally a state event, and others in the same state group are normally non-state-events.)
+state_groups records, for each state group, the id of the room that we're looking at, and also the id of the first event in that group. (I'm not sure if that event id is used much in practice.)
+Now, if we stored all the room state for each state_group, that would be a huge amount of data. Instead, for each state group, we normally store the difference between the state in that group and some other state group, and only occasionally (every 100 state changes or so) record the full state.
+So, most state groups have an entry in state_group_edges (don't ask me why it's not a column in state_groups) which records the previous state group in the room, and state_groups_state records the differences in state since that previous state group.
+A full state group just records the event id for each piece of state in the room at that point.
+
+There are various reasons that we can end up creating many more state groups than we need: see https://github.com/matrix-org/synapse/issues/3364 for more details.
+
+There is a tool at https://github.com/matrix-org/rust-synapse-compress-state which can compress the state_groups_state on a room by-room basis (essentially, it reduces the number of "full" state groups). This can result in dramatic reductions of the storage used.
HTTP request logs are written by synapse (see site.py for details).
See the following for how to decode the dense data available from the default logging configuration.
@@ -12178,6 +12573,68 @@ the same data, but only the first request will report time/transactions in
KKKK/LLLL/MMMM/NNNN/OOOO - the others will be awaiting the first query to return a
response and will simultaneously return with the first request, but with very
small processing times.
+
+
+If your server already has an admin account you should use the user admin API to promote other accounts to become admins. See User Admin API
+If you don't have any admin accounts yet you won't be able to use the admin API so you'll have to edit the database manually. Manually editing the database is generally not recommended so once you have an admin account, use the admin APIs to make further changes.
+UPDATE users SET admin = 1 WHERE name = '@foo:bar.com';
+
+
+Run this sql query on your db:
+SELECT * FROM destinations;
+
+
+Run this sql query on your db:
+SELECT DISTINCT split_part(state_key, ':', 2)
+ FROM current_state_events AS c
+ INNER JOIN room_memberships AS m USING (room_id, event_id)
+ WHERE room_id = '!cURbafjkfsMDVwdRDQ:matrix.org' AND membership = 'join';
+
+
+SELECT NAME from users;
+
+
+See https://github.com/matrix-org/synapse/blob/master/README.rst#password-reset
+
+Deleting your database is unlikely to make anything better.
+It's easy to make the mistake of thinking that you can start again from a clean slate by dropping your database, but things don't work like that in a federated network: lots of other servers have information about your server.
+For example: other servers might think that you are in a room, your server will think that you are not, and you'll probably be unable to interact with that room in a sensible way ever again.
+In general, there are better solutions to any problem than dropping the database. Come and seek help in https://matrix.to/#/#synapse:matrix.org.
+There are two exceptions when it might be sensible to delete your database and start again:
+
+- You have never joined any rooms which are federated with other servers. For instance, a local deployment which the outside world can't talk to.
+- You are changing the
server_name in the homeserver configuration. In effect this makes your server a completely new one from the point of view of the network, so in this case it makes sense to start with a clean database.
+(In both cases you probably also want to clear out the media_store.)
+
+
+Using the following curl command:
+curl -H 'Authorization: Bearer <access-token>' -X DELETE https://matrix.org/_matrix/client/r0/directory/room/<room-alias>
+
+<access-token> - can be obtained in riot by looking in the riot settings, down the bottom is:
+Access Token:<click to reveal>
+<room-alias> - the room alias, eg. #my_room:matrix.org this possibly needs to be URL encoded also, for example %23my_room%3Amatrix.org
+
+Synapse tags each log line according to the HTTP request it is processing. When it finishes processing each request, it logs a line containing the words Processed request: . For example:
+2019-02-14 22:35:08,196 - synapse.access.http.8008 - 302 - INFO - GET-37 - ::1 - 8008 - {@richvdh:localhost} Processed request: 0.173sec/0.001sec (0.002sec, 0.000sec) (0.027sec/0.026sec/2) 687B 200 "GET /_matrix/client/r0/sync HTTP/1.1" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36" [0 dbevts]"
+
+Here we can see that the request has been tagged with GET-37. (The tag depends on the method of the HTTP request, so might start with GET-, PUT-, POST-, OPTIONS- or DELETE-.) So to find all lines corresponding to this request, we can do:
+grep 'GET-37' homeserver.log
+
+If you want to paste that output into a github issue or matrix room, please remember to surround it with triple-backticks (```) to make it legible (see https://help.github.com/en/articles/basic-writing-and-formatting-syntax#quoting-code).
+
+See Request log format.
+
+SELECT s.canonical_alias, g.room_id, count(*) AS num_rows
+FROM
+ state_groups_state AS g,
+ room_stats_state AS s
+WHERE g.room_id = s.room_id
+GROUP BY s.canonical_alias, g.room_id
+ORDER BY num_rows desc
+LIMIT 10;
+
+You can also use the List Room API
+and order_by state_events.
This document aims to get you started with contributing to Synapse!
@@ -13707,19 +14164,18 @@ representation of the state of the room as others were seeing it at the time.
Most-recent-in-time events in the DAG which are not referenced by any other events' prev_events yet.
The forward extremities of a room are used as the prev_events when the next event is sent.
-
+
The current marker of where we have backfilled up to and will generally be the
-oldest-in-time events we know of in the DAG.
-This is an event where we haven't fetched all of the prev_events for.
-Once we have fetched all of its prev_events, it's unmarked as a backwards
-extremity (although we may have formed new backwards extremities from the prev
-events during the backfilling process).
+prev_events of the oldest-in-time events we have in the DAG. This gives a starting point when
+backfilling history.
+When we persist a non-outlier event, we clear it as a backward extremity and set
+all of its prev_events as the new backward extremities if they aren't already
+persisted in the events table.
We mark an event as an outlier when we haven't figured out the state for the
room at that point in the DAG yet.
We won't necessarily have the prev_events of an outlier in the database,
-but it's entirely possible that we might. The status of whether we have all of
-the prev_events is marked as a backwards extremity.
+but it's entirely possible that we might.
For example, when we fetch the event auth chain or state for a given event, we
mark all of those claimed auth events as outliers because we haven't done the
state calculation ourself.
@@ -13825,25 +14281,67 @@ level).
The media repository is where attachments and avatar photos are stored.
-It stores attachment content and thumbnails for media uploaded by local users.
-It caches attachment content and thumbnails for media uploaded by remote users.
-Metadata such as the MIME type, upload time and length are stored in the
-sqlite3 database indexed by media_id.
-Synapse generates 24 character media IDs for content uploaded by local users.
+These media IDs consist of upper and lowercase letters and are case-sensitive.
+Other homeserver implementations may generate media IDs differently.
+When media from a remote homeserver is requested from Synapse, it is assigned
+a local filesystem_id, with the same format as locally-generated media IDs,
+as described above.
+When generating previews for URLs, Synapse may download and cache various
+resources, including images. These resources are assigned temporary media IDs
+of the form yyyy-mm-dd_aaaaaaaaaaaaaaaa, where yyyy-mm-dd is the current
+date and aaaaaaaaaaaaaaaa is a random sequence of 16 case-sensitive letters.
+Resources for URL previews are deleted after a few days.
+Synapse maintains room and user statistics in various tables. These can be used
for administrative purposes but are also used when generating the public room
@@ -13880,6 +14378,61 @@ long process.
By following the upstream support life cycles Synapse can ensure that its
dependencies continue to get security patches, while not requiring system admins
to constantly update their platform dependencies to the latest versions.
+I've been running my homeserver on a cubietruck at home now for some time and am often replying to statements like "you need loads of ram to join large rooms" with "it works fine for me". I thought it might be useful to curate a summary of the issues you're likely to run into to help as a scaling-down guide, maybe highlight these for development work or end up as documentation. It seems that once you get up to about 4x1.5GHz arm64 4GiB these issues are no longer a problem.
+This is the main reason people have a poor matrix experience on resource constrained homeservers. Element web will frequently be saying the server is offline while the python process will be pegged at 100% cpu. This feature is used to tell when other users are active (have a client app in the foreground) and therefore more likely to respond, but requires a lot of network activity to maintain even when nobody is talking in a room.
+Joining a "large", federated room will initially fail with the below message in Element web, but waiting a while (10-60mins) and trying again will succeed without any issue. What counts as "large" is not message history, user count, connections to homeservers or even a simple count of the state events, it is instead how long the state resolution algorithm takes. However, each of those numbers are reasonable proxies, so we can use them as estimates since user count is one of the few things you see before joining.
+Put the below in a new file at /etc/matrix-synapse/conf.d/sbc.yaml to override the defaults in homeserver.yaml.
+