Replace the precise metrics flag with a dedicated backend (#97749)

This reverts all the changes related to the `precise` flag, and having
two different metrics backends.

Instead, it adds a new `PreciseDogStatsd` backend. The difference to the
normal `DogStatsd` backend is that it constructs a instance-local
`DogStatsd` client, instead of messing with the global `statsd`
singleton. And of course, it emits distributions and timings as the
proper datadog `distribution` type.

Author: Swatinem

src/sentry/conf/server.py

@@ -2206,8 +2206,6 @@ def custom_parameter_sort(parameter: dict) -> tuple[str, int]:
 # Internal metrics
 SENTRY_METRICS_BACKEND = "sentry.metrics.dummy.DummyMetricsBackend"
 SENTRY_METRICS_OPTIONS: dict[str, Any] = {}
-SENTRY_METRICS_PRECISE_BACKEND: str | None = None
-SENTRY_METRICS_PRECISE_OPTIONS: dict[str, Any] = {}
 SENTRY_METRICS_SAMPLE_RATE = 1.0
 SENTRY_METRICS_PREFIX = "sentry."
 SENTRY_METRICS_SKIP_INTERNAL_PREFIXES: list[str] = []  # Order this by most frequent prefixes.

src/sentry/metrics/base.py

@@ -76,7 +76,6 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
         raise NotImplementedError
 

src/sentry/metrics/datadog.py

@@ -108,23 +108,9 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
-        if not precise:
-            # We keep the same implementation for Datadog.
-            return self.timing(key, value, instance, tags, sample_rate)
-
-        tags = dict(tags or ())
-
-        if self.tags:
-            tags.update(self.tags)
-        if instance:
-            tags["instance"] = instance
-
-        tags_list = [f"{k}:{v}" for k, v in tags.items()]
-        self.stats.distribution(
-            self._get_key(key), value, sample_rate=sample_rate, tags=tags_list, host=self.host
-        )
+        # We keep the same implementation for Datadog.
+        return self.timing(key, value, instance, tags, sample_rate)
 
     def event(
         self,

src/sentry/metrics/dogstatsd.py

@@ -110,21 +110,9 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
-        if not precise:
-            # We keep the same implementation for Datadog.
-            return self.timing(key, value, instance, tags, sample_rate)
-
-        tags = dict(tags or ())
-
-        if self.tags:
-            tags.update(self.tags)
-        if instance:
-            tags["instance"] = instance
-
-        tags_list = [f"{k}:{v}" for k, v in tags.items()]
-        statsd.distribution(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)
+        # We keep the same implementation for Datadog.
+        return self.timing(key, value, instance, tags, sample_rate)
 
     def event(
         self,

src/sentry/metrics/dummy.py

@@ -48,7 +48,6 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
         pass
 

src/sentry/metrics/logging.py

@@ -52,7 +52,6 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
         logger.debug("%r: %+g", key, value, extra={"instance": instance, "tags": tags or {}})
 

src/sentry/metrics/middleware.py

@@ -180,15 +180,14 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
         current_tags = get_current_global_tags()
         if tags is not None:
             current_tags.update(tags)
         current_tags = _filter_tags(key, current_tags)
 
         return self.inner.distribution(
-            key, value, instance, current_tags, sample_rate, unit, stacklevel + 1, precise
+            key, value, instance, current_tags, sample_rate, unit, stacklevel + 1
         )
 
     def event(

src/sentry/metrics/precise_dogstatsd.py

@@ -0,0 +1,149 @@
+import atexit
+from typing import Any
+
+from datadog.dogstatsd.base import DogStatsd
+
+from .base import MetricsBackend, Tags
+
+__all__ = ["PreciseDogStatsdMetricsBackend"]
+
+
+class PreciseDogStatsdMetricsBackend(MetricsBackend):
+    def __init__(self, prefix: str | None = None, **kwargs: Any) -> None:
+        self.tags = kwargs.pop("tags", None)
+
+        instance_kwargs: dict[str, Any] = {
+            "disable_telemetry": True,
+            "disable_buffering": False,
+            # When enabled, a background thread will be used to send metric payloads to the Agent.
+            "disable_background_sender": False,
+        }
+        if socket_path := kwargs.get("statsd_socket_path"):
+            instance_kwargs["socket_path"] = socket_path
+        else:
+            if host := kwargs.get("statsd_host"):
+                instance_kwargs["host"] = host
+            if port := kwargs.get("statsd_port"):
+                instance_kwargs["port"] = int(port)
+
+        self.statsd = DogStatsd(**instance_kwargs)
+
+        # Origin detection is enabled after 0.45 by default.
+        # Disable it since it silently fails.
+        # Ref: https://github.com/DataDog/datadogpy/issues/764
+        self.statsd._container_id = None
+
+        # Applications should call wait_for_pending() before exiting to make sure all pending payloads are sent.
+        atexit.register(self.statsd.wait_for_pending)
+
+        super().__init__(prefix=prefix)
+
+    def incr(
+        self,
+        key: str,
+        instance: str | None = None,
+        tags: Tags | None = None,
+        amount: float | int = 1,
+        sample_rate: float = 1,
+        unit: str | None = None,
+        stacklevel: int = 0,
+    ) -> None:
+        tags = dict(tags or ())
+
+        if self.tags:
+            tags.update(self.tags)
+        if instance:
+            tags["instance"] = instance
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        self.statsd.increment(self._get_key(key), amount, sample_rate=sample_rate, tags=tags_list)
+
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: str | None = None,
+        tags: Tags | None = None,
+        sample_rate: float = 1,
+        stacklevel: int = 0,
+    ) -> None:
+        tags = dict(tags or ())
+
+        if self.tags:
+            tags.update(self.tags)
+        if instance:
+            tags["instance"] = instance
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        self.statsd.distribution(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)
+
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: str | None = None,
+        tags: Tags | None = None,
+        sample_rate: float = 1,
+        unit: str | None = None,
+        stacklevel: int = 0,
+    ) -> None:
+        tags = dict(tags or ())
+
+        if self.tags:
+            tags.update(self.tags)
+        if instance:
+            tags["instance"] = instance
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        self.statsd.gauge(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)
+
+    def distribution(
+        self,
+        key: str,
+        value: float,
+        instance: str | None = None,
+        tags: Tags | None = None,
+        sample_rate: float = 1,
+        unit: str | None = None,
+        stacklevel: int = 0,
+    ) -> None:
+        tags = dict(tags or ())
+
+        if self.tags:
+            tags.update(self.tags)
+        if instance:
+            tags["instance"] = instance
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        self.statsd.distribution(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)
+
+    def event(
+        self,
+        title: str,
+        message: str,
+        alert_type: str | None = None,
+        aggregation_key: str | None = None,
+        source_type_name: str | None = None,
+        priority: str | None = None,
+        instance: str | None = None,
+        tags: Tags | None = None,
+        stacklevel: int = 0,
+    ) -> None:
+        tags = dict(tags or ())
+
+        if self.tags:
+            tags.update(self.tags)
+        if instance:
+            tags["instance"] = instance
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        self.statsd.event(
+            title=title,
+            message=message,
+            alert_type=alert_type,
+            aggregation_key=aggregation_key,
+            source_type_name=source_type_name,
+            priority=priority,
+            tags=tags_list,
+            hostname=self.host,
+        )

src/sentry/metrics/statsd.py

@@ -61,7 +61,6 @@ def distribution(
         sample_rate: float = 1,
         unit: str | None = None,
         stacklevel: int = 0,
-        precise: bool = False,
     ) -> None:
         # NOTE: the statsd client does not have a `distribution` method
         self.timing(key, value, instance, tags, sample_rate)

src/sentry/models/debugfile.py

@@ -323,7 +323,6 @@ def create_dif_from_id(
         file.size,
         tags={"usecase": "debug-files", "compression": "none"},
         unit="byte",
-        precise=True,
     )
 
     dif = ProjectDebugFile.objects.create(