Add metric to count number of non-deactivated users.

changelog.d/19848.feature

@@ -0,0 +1 @@
+Add new metric `synapse_admin_user_count` which tracks how many users are registered to the homeserver.

synapse/app/phone_stats_home.py

@@ -73,6 +73,11 @@
     "Registered users with reserved threepids",
     labelnames=[SERVER_NAME_LABEL],
 )
+user_count_gauge = Gauge(
+    "synapse_admin_user_count",
+    "Total user count within the Synapse database",
+    labelnames=["app_service", SERVER_NAME_LABEL],
+)
 
 
 def phone_stats_home(
@@ -261,6 +266,25 @@ async def _generate_monthly_active_users() -> None:
             _generate_monthly_active_users,
         )
 
+    def generate_total_users() -> "defer.Deferred[None]":
+        async def _generate_total_users() -> None:
+            store = hs.get_datastores().main
+
+            result = await store.get_user_count_by_service()
+
+            for app_service, count in result:
+                user_count_gauge.labels(
+                    app_service=app_service, **{SERVER_NAME_LABEL: server_name}
+                ).set(float(count))
+
+        return hs.run_as_background_process(
+            "generate_total_users",
+            _generate_total_users,
+        )
+
+    generate_total_users()
+    clock.looping_call(generate_total_users, Duration(minutes=5))
+
     if hs.config.server.limit_usage_by_mau or hs.config.server.mau_stats_only:
         generate_monthly_active_users()
         clock.looping_call(generate_monthly_active_users, Duration(minutes=5))

synapse/storage/databases/main/registration.py

@@ -1133,6 +1133,32 @@ def _count_users(txn: LoggingTransaction) -> int:
 
         return await self.db_pool.runInteraction("count_real_users", _count_users)
 
+    async def get_user_count_by_service(self) -> list[tuple[str, int]]:
+        """Counts users grouped by their appservice.
+
+        Returns:
+            A list of tuples (appservice_id, count). "native" is emitted as the
+            appservice for users that don't come from appservices (i.e. native Matrix
+            users).
+
+        """
+
+        def _get_user_count_by_service(
+            txn: LoggingTransaction,
+        ) -> list[tuple[str, int]]:
+            sql = """
+                    SELECT COALESCE(appservice_id, 'native'), COUNT(name)
+                    FROM users WHERE deactivated = 0
+                    GROUP BY appservice_id;
+                """
+
+            txn.execute(sql)
+            return cast(list[tuple[str, int]], txn.fetchall())
+
+        return await self.db_pool.runInteraction(
+            "get_user_count_by_service", _get_user_count_by_service
+        )
+
     async def generate_user_id(self) -> str:
         """Generate a suitable localpart for a guest user
 

tests/metrics/test_phone_home_stats.py

@@ -19,11 +19,13 @@
 from synapse.app.phone_stats_home import (
     PHONE_HOME_INTERVAL,
     start_phone_stats_home,
+    user_count_gauge,
 )
 from synapse.rest import admin, login, register, room
 from synapse.server import HomeServer
 from synapse.types import JsonDict
 from synapse.util.clock import Clock
+from synapse.util.duration import Duration
 
 from tests import unittest
 from tests.server import ThreadedMemoryReactorClock
@@ -261,3 +263,31 @@ def test_phone_home_stats(self) -> None:
         synapse_logger = logging.getLogger("synapse")
         log_level = synapse_logger.getEffectiveLevel()
         self.assertEqual(phone_home_stats["log_level"], logging.getLevelName(log_level))
+
+    def test_generate_total_users_gauge(self) -> None:
+        """
+        Test that generate_total_users() populates user_count_gauge correctly,
+        counting only active (non-deactivated) users split by app_service.
+        """
+        server_name = self.hs.config.server.server_name
+
+        # Register two native users and deactivate one to confirm it is excluded.
+        self.register_user("gauge_user_1", "password")
+        user_2 = self.register_user("gauge_user_2", "password")
+        self.get_success(
+            self.store.set_user_deactivated_status(user_id=user_2, deactivated=True)
+        )
+
+        # Advance past the 5-minute looping interval so generate_total_users fires again.
+        self.reactor.advance(Duration(minutes=5).as_secs() + 1)
+
+        # Collect gauge samples for our server_name.
+        samples = {
+            sample.labels["app_service"]: sample.value
+            for metric_family in user_count_gauge.collect()
+            for sample in metric_family.samples
+            if sample.labels.get("server_name") == server_name
+        }
+
+        # Only the one active native user should be counted.
+        self.assertEqual(samples.get("native"), 1.0)