feat: add support for otel metrics (method 3)

pyproject.toml

@@ -238,6 +238,7 @@ pydantic = [
     { version = "~=2.8", python = "<3.14" },
     { version = "~=2.12", python = ">=3.14" },
 ]
+opentelemetry-exporter-prometheus = "0.55b1"
 
 # This is for building the rust components during "poetry install", which
 # currently ignores the `build-system.requires` directive (c.f.

synapse/api/auth/__init__.py

@@ -20,13 +20,11 @@
 #
 from typing import TYPE_CHECKING, Optional, Protocol
 
-from prometheus_client import Histogram
-
 from twisted.web.server import Request
 
 from synapse.appservice import ApplicationService
 from synapse.http.site import SynapseRequest
-from synapse.metrics import SERVER_NAME_LABEL
+from synapse.metrics import meter
 from synapse.types import Requester
 
 if TYPE_CHECKING:
@@ -36,10 +34,9 @@
 GUEST_DEVICE_ID = "guest_device"
 
 
-introspection_response_timer = Histogram(
+introspection_response_timer = meter.create_histogram(
     "synapse_api_auth_delegated_introspection_response",
-    "Time taken to get a response for an introspection request",
-    labelnames=["code", SERVER_NAME_LABEL],
+    description="Time taken to get a response for an introspection request",
 )
 
 

synapse/api/auth/mas.py

@@ -236,23 +236,25 @@ async def _introspect_token(
                 )
         except HttpResponseException as e:
             end_time = self._clock.time()
-            introspection_response_timer.labels(
-                code=e.code, **{SERVER_NAME_LABEL: self.server_name}
-            ).observe(end_time - start_time)
+            introspection_response_timer.record(
+                end_time - start_time,
+                {"code": e.code, SERVER_NAME_LABEL: self.server_name},
+            )
             raise
         except Exception:
             end_time = self._clock.time()
-            introspection_response_timer.labels(
-                code="ERR", **{SERVER_NAME_LABEL: self.server_name}
-            ).observe(end_time - start_time)
+            introspection_response_timer.record(
+                end_time - start_time,
+                {"code": "ERR", SERVER_NAME_LABEL: self.server_name},
+            )
             raise
 
         logger.debug("Fetched token from MAS")
 
         end_time = self._clock.time()
-        introspection_response_timer.labels(
-            code=200, **{SERVER_NAME_LABEL: self.server_name}
-        ).observe(end_time - start_time)
+        introspection_response_timer.record(
+            end_time - start_time, {"code": 200, SERVER_NAME_LABEL: self.server_name}
+        )
 
         raw_response = json_decoder.decode(resp_body.decode("utf-8"))
         try:

synapse/api/auth/msc3861_delegated.py

@@ -334,23 +334,25 @@ async def _introspect_token(
                 )
         except HttpResponseException as e:
             end_time = self._clock.time()
-            introspection_response_timer.labels(
-                code=e.code, **{SERVER_NAME_LABEL: self.server_name}
-            ).observe(end_time - start_time)
+            introspection_response_timer.record(
+                end_time - start_time,
+                {"code": e.code, SERVER_NAME_LABEL: self.server_name},
+            )
             raise
         except Exception:
             end_time = self._clock.time()
-            introspection_response_timer.labels(
-                code="ERR", **{SERVER_NAME_LABEL: self.server_name}
-            ).observe(end_time - start_time)
+            introspection_response_timer.record(
+                end_time - start_time,
+                {"code": "ERR", SERVER_NAME_LABEL: self.server_name},
+            )
             raise
 
         logger.debug("Fetched token from MAS")
 
         end_time = self._clock.time()
-        introspection_response_timer.labels(
-            code=200, **{SERVER_NAME_LABEL: self.server_name}
-        ).observe(end_time - start_time)
+        introspection_response_timer.record(
+            end_time - start_time, {"code": 200, SERVER_NAME_LABEL: self.server_name}
+        )
 
         resp = json_decoder.decode(resp_body.decode("utf-8"))
 

synapse/app/_base.py

@@ -676,13 +676,16 @@ async def start(hs: "HomeServer", *, freeze: bool = True) -> None:
             module
         )
         # Set module info metrics for prometheus
-        module_instances_info.labels(
-            package_name=package_name,
-            # what is given in the config
-            module_name=module_name,
-            module_version=module_version,
-            **{SERVER_NAME_LABEL: hs.hostname},
-        ).set(1)
+        module_instances_info.set(
+            1,
+            {
+                "package_name": package_name,
+                # what is given in the config
+                "module_name": module_name,
+                "module_version": module_version,
+                SERVER_NAME_LABEL: hs.hostname,
+            },
+        )
         logger.info("Loaded module %s", m)
 
     if hs.config.auto_accept_invites.enabled:

synapse/app/phone_stats_home.py

@@ -24,11 +24,9 @@
 import sys
 from typing import TYPE_CHECKING, Mapping, Sized
 
-from prometheus_client import Gauge
-
 from twisted.internet import defer
 
-from synapse.metrics import SERVER_NAME_LABEL
+from synapse.metrics import SERVER_NAME_LABEL, meter
 from synapse.types import JsonDict
 from synapse.util.constants import (
     MILLISECONDS_PER_SECOND,
@@ -57,25 +55,21 @@
 _stats_process: list[tuple[int, "resource.struct_rusage"]] = []
 
 # Gauges to expose monthly active user control metrics
-current_mau_gauge = Gauge(
+current_mau_gauge = meter.create_gauge(
     "synapse_admin_mau_current",
-    "Current MAU",
-    labelnames=[SERVER_NAME_LABEL],
+    description="Current MAU",
 )
-current_mau_by_service_gauge = Gauge(
+current_mau_by_service_gauge = meter.create_gauge(
     "synapse_admin_mau_current_mau_by_service",
-    "Current MAU by service",
-    labelnames=["app_service", SERVER_NAME_LABEL],
+    description="Current MAU by service",
 )
-max_mau_gauge = Gauge(
+max_mau_gauge = meter.create_gauge(
     "synapse_admin_mau_max",
-    "MAU Limit",
-    labelnames=[SERVER_NAME_LABEL],
+    description="MAU Limit",
 )
-registered_reserved_users_mau_gauge = Gauge(
+registered_reserved_users_mau_gauge = meter.create_gauge(
     "synapse_admin_mau_registered_reserved_users",
-    "Registered users with reserved threepids",
-    labelnames=[SERVER_NAME_LABEL],
+    description="Registered users with reserved threepids",
 )
 
 
@@ -244,20 +238,21 @@ async def _generate_monthly_active_users() -> None:
                     await store.get_monthly_active_count_by_service()
                 )
                 reserved_users = await store.get_registered_reserved_users()
-            current_mau_gauge.labels(**{SERVER_NAME_LABEL: server_name}).set(
-                float(current_mau_count)
+            current_mau_gauge.set(
+                float(current_mau_count), {SERVER_NAME_LABEL: server_name}
             )
 
             for app_service, count in current_mau_count_by_service.items():
-                current_mau_by_service_gauge.labels(
-                    app_service=app_service, **{SERVER_NAME_LABEL: server_name}
-                ).set(float(count))
-
-            registered_reserved_users_mau_gauge.labels(
-                **{SERVER_NAME_LABEL: server_name}
-            ).set(float(len(reserved_users)))
-            max_mau_gauge.labels(**{SERVER_NAME_LABEL: server_name}).set(
-                float(hs.config.server.max_mau_value)
+                current_mau_by_service_gauge.set(
+                    float(count),
+                    {"app_service": app_service, SERVER_NAME_LABEL: server_name},
+                )
+
+            registered_reserved_users_mau_gauge.set(
+                float(len(reserved_users)), {SERVER_NAME_LABEL: server_name}
+            )
+            max_mau_gauge.set(
+                float(hs.config.server.max_mau_value), {SERVER_NAME_LABEL: server_name}
             )
 
         return hs.run_as_background_process(

synapse/appservice/api.py

@@ -31,7 +31,6 @@
     Union,
 )
 
-from prometheus_client import Counter
 from typing_extensions import ParamSpec, TypeGuard
 
 from synapse.api.constants import EventTypes, Membership, ThirdPartyEntityKind
@@ -45,7 +44,7 @@
 from synapse.events.utils import SerializeEventConfig, serialize_event
 from synapse.http.client import SimpleHttpClient, is_unknown_endpoint
 from synapse.logging import opentracing
-from synapse.metrics import SERVER_NAME_LABEL
+from synapse.metrics import SERVER_NAME_LABEL, meter
 from synapse.types import DeviceListUpdates, JsonDict, JsonMapping, ThirdPartyInstanceID
 from synapse.util.caches.response_cache import ResponseCache
 
@@ -54,34 +53,29 @@
 
 logger = logging.getLogger(__name__)
 
-sent_transactions_counter = Counter(
+sent_transactions_counter = meter.create_counter(
     "synapse_appservice_api_sent_transactions",
-    "Number of /transactions/ requests sent",
-    labelnames=["service", SERVER_NAME_LABEL],
+    description="Number of /transactions/ requests sent",
 )
 
-failed_transactions_counter = Counter(
+failed_transactions_counter = meter.create_counter(
     "synapse_appservice_api_failed_transactions",
-    "Number of /transactions/ requests that failed to send",
-    labelnames=["service", SERVER_NAME_LABEL],
+    description="Number of /transactions/ requests that failed to send",
 )
 
-sent_events_counter = Counter(
+sent_events_counter = meter.create_counter(
     "synapse_appservice_api_sent_events",
-    "Number of events sent to the AS",
-    labelnames=["service", SERVER_NAME_LABEL],
+    description="Number of events sent to the AS",
 )
 
-sent_ephemeral_counter = Counter(
+sent_ephemeral_counter = meter.create_counter(
     "synapse_appservice_api_sent_ephemeral",
-    "Number of ephemeral events sent to the AS",
-    labelnames=["service", SERVER_NAME_LABEL],
+    description="Number of ephemeral events sent to the AS",
 )
 
-sent_todevice_counter = Counter(
+sent_todevice_counter = meter.create_counter(
     "synapse_appservice_api_sent_todevice",
-    "Number of todevice messages sent to the AS",
-    labelnames=["service", SERVER_NAME_LABEL],
+    description="Number of todevice messages sent to the AS",
 )
 
 HOUR_IN_MS = 60 * 60 * 1000
@@ -400,10 +394,10 @@ async def push_bulk(
                     service.url,
                     [event.get("event_id") for event in events],
                 )
-            sent_transactions_counter.labels(**labels).inc()
-            sent_events_counter.labels(**labels).inc(len(serialized_events))
-            sent_ephemeral_counter.labels(**labels).inc(len(ephemeral))
-            sent_todevice_counter.labels(**labels).inc(len(to_device_messages))
+            sent_transactions_counter.add(1, labels)
+            sent_events_counter.add(len(serialized_events), labels)
+            sent_ephemeral_counter.add(len(ephemeral), labels)
+            sent_todevice_counter.add(len(to_device_messages), labels)
             return True
         except CodeMessageException as e:
             logger.warning(
@@ -422,7 +416,7 @@ async def push_bulk(
                 ex.args,
                 exc_info=logger.isEnabledFor(logging.DEBUG),
             )
-        failed_transactions_counter.labels(**labels).inc()
+        failed_transactions_counter.add(1, labels)
         return False
 
     async def claim_client_keys(