ref: Add typing to sentry.utils.metrics, fix bug where metric tags we…

…re lost (#48512)

mypy.ini

@@ -91,6 +91,7 @@ files = fixtures/mypy-stubs,
         src/sentry/killswitches.py,
         src/sentry/lang/native/appconnect.py,
         src/sentry/mail/notifications.py,
+        src/sentry/metrics/,
         src/sentry/models/debugfile.py,
         src/sentry/models/groupsubscription.py,
         src/sentry/models/options/,
@@ -163,6 +164,7 @@ files = fixtures/mypy-stubs,
         src/sentry/utils/audit.py,
         src/sentry/utils/auth.py,
         src/sentry/utils/avatar.py,
+        src/sentry/utils/cache.py,
         src/sentry/utils/codecs.py,
         src/sentry/utils/committers.py,
         src/sentry/utils/cursors.py,
@@ -259,6 +261,10 @@ ignore_missing_imports = True
 ignore_missing_imports = True
 [mypy-rapidjson]
 ignore_missing_imports = True
+[mypy-statsd]
+ignore_missing_imports = True
+[mypy-datadog.*]
+ignore_missing_imports = True
 
 # TODO: these cause type errors when followed
 [mypy-snuba_sdk.*]

src/sentry/auth/system.py

@@ -64,7 +64,7 @@ def __hash__(self) -> int:
     def is_expired(self) -> bool:
         return False
 
-    @memoize  # type: ignore[misc]
+    @memoize
     def user(self) -> AnonymousUser:
         user = AnonymousUser()
         user.is_active = True

src/sentry/integrations/slack/requests/action.py

@@ -24,7 +24,7 @@ class SlackActionRequest(SlackRequest):
     def type(self) -> str:
         return str(self.data.get("type"))
 
-    @memoize  # type: ignore
+    @memoize
     def callback_data(self) -> JSONData:
         """
         We store certain data in ``callback_id`` as JSON. It's a bit hacky, but

src/sentry/metrics/base.py

@@ -2,29 +2,53 @@
 
 from random import random
 from threading import local
+from typing import Any, Mapping, Optional, Union
 
 from django.conf import settings
 
+Tags = Mapping[str, Any]
+
 
 class MetricsBackend(local):
-    def __init__(self, prefix=None):
+    def __init__(self, prefix: Optional[str] = None) -> None:
         if prefix is None:
             prefix = settings.SENTRY_METRICS_PREFIX
         self.prefix = prefix
 
-    def _get_key(self, key):
+    def _get_key(self, key: str) -> str:
         if self.prefix:
             return f"{self.prefix}{key}"
         return key
 
-    def _should_sample(self, sample_rate):
+    def _should_sample(self, sample_rate: float) -> bool:
         return sample_rate >= 1 or random() >= 1 - sample_rate
 
-    def incr(self, key, instance=None, tags=None, amount=1, sample_rate=1):
+    def incr(
+        self,
+        key: str,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        amount: Union[float, int] = 1,
+        sample_rate: float = 1,
+    ) -> None:
         raise NotImplementedError
 
-    def timing(self, key, value, instance=None, tags=None, sample_rate=1):
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         raise NotImplementedError
 
-    def gauge(self, key, value, instance=None, tags=None, sample_rate=1):
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         raise NotImplementedError

src/sentry/metrics/datadog.py

@@ -1,15 +1,17 @@
 __all__ = ["DatadogMetricsBackend"]
 
+from typing import Any, Optional, Union
+
 from datadog import ThreadStats, initialize
 from datadog.util.hostname import get_hostname
 
 from sentry.utils.cache import memoize
 
-from .base import MetricsBackend
+from .base import MetricsBackend, Tags
 
 
 class DatadogMetricsBackend(MetricsBackend):
-    def __init__(self, prefix=None, **kwargs):
+    def __init__(self, prefix: Optional[str] = None, **kwargs: Any) -> None:
         # TODO(dcramer): it'd be nice if the initialize call wasn't a global
         self.tags = kwargs.pop("tags", None)
         if "host" in kwargs:
@@ -19,54 +21,75 @@ def __init__(self, prefix=None, **kwargs):
         initialize(**kwargs)
         super().__init__(prefix=prefix)
 
-    def __del__(self):
+    def __del__(self) -> None:
         try:
             self.stats.stop()
         except TypeError:
             # TypeError: 'NoneType' object is not callable
             pass
 
     @memoize
-    def stats(self):
+    def stats(self) -> ThreadStats:
         instance = ThreadStats()
         instance.start()
         return instance
 
-    def incr(self, key, instance=None, tags=None, amount=1, sample_rate=1):
-        if tags is None:
-            tags = {}
+    def incr(
+        self,
+        key: str,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        amount: Union[float, int] = 1,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
         self.stats.increment(
-            self._get_key(key), amount, sample_rate=sample_rate, tags=tags, host=self.host
+            self._get_key(key), amount, sample_rate=sample_rate, tags=tags_list, host=self.host
         )
 
-    def timing(self, key, value, instance=None, tags=None, sample_rate=1):
-        if tags is None:
-            tags = {}
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
         self.stats.timing(
-            self._get_key(key), value, sample_rate=sample_rate, tags=tags, host=self.host
+            self._get_key(key), value, sample_rate=sample_rate, tags=tags_list, host=self.host
         )
 
-    def gauge(self, key, value, instance=None, tags=None, sample_rate=1):
-        if tags is None:
-            tags = {}
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
         self.stats.gauge(
-            self._get_key(key), value, sample_rate=sample_rate, tags=tags, host=self.host
+            self._get_key(key), value, sample_rate=sample_rate, tags=tags_list, host=self.host
         )

src/sentry/metrics/dogstatsd.py

@@ -1,46 +1,69 @@
-__all__ = ["DogStatsdMetricsBackend"]
+from typing import Any, Optional, Union
 
 from datadog import initialize, statsd
 
-from .base import MetricsBackend
+from .base import MetricsBackend, Tags
+
+__all__ = ["DogStatsdMetricsBackend"]
 
 
 class DogStatsdMetricsBackend(MetricsBackend):
-    def __init__(self, prefix=None, **kwargs):
+    def __init__(self, prefix: Optional[str] = None, **kwargs: Any) -> None:
         # TODO(dcramer): it'd be nice if the initialize call wasn't a global
         self.tags = kwargs.pop("tags", None)
         initialize(**kwargs)
         super().__init__(prefix=prefix)
 
-    def incr(self, key, instance=None, tags=None, amount=1, sample_rate=1):
-        if tags is None:
-            tags = {}
+    def incr(
+        self,
+        key: str,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        amount: Union[float, int] = 1,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
-        statsd.increment(self._get_key(key), amount, sample_rate=sample_rate, tags=tags)
 
-    def timing(self, key, value, instance=None, tags=None, sample_rate=1):
-        if tags is None:
-            tags = {}
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        statsd.increment(self._get_key(key), amount, sample_rate=sample_rate, tags=tags_list)
+
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
-        statsd.timing(self._get_key(key), value, sample_rate=sample_rate, tags=tags)
 
-    def gauge(self, key, value, instance=None, tags=None, sample_rate=1):
-        if tags is None:
-            tags = {}
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        statsd.timing(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)
+
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
+        tags = dict(tags or ())
+
         if self.tags:
             tags.update(self.tags)
         if instance:
             tags["instance"] = instance
-        if tags:
-            tags = [f"{k}:{v}" for k, v in tags.items()]
-        statsd.gauge(self._get_key(key), value, sample_rate=sample_rate, tags=tags)
+
+        tags_list = [f"{k}:{v}" for k, v in tags.items()]
+        statsd.gauge(self._get_key(key), value, sample_rate=sample_rate, tags=tags_list)

src/sentry/metrics/dummy.py

@@ -1,14 +1,37 @@
-__all__ = ["DummyMetricsBackend"]
+from typing import Optional, Union
+
+from .base import MetricsBackend, Tags
 
-from .base import MetricsBackend
+__all__ = ["DummyMetricsBackend"]
 
 
 class DummyMetricsBackend(MetricsBackend):
-    def incr(self, key, instance=None, tags=None, amount=1, sample_rate=1):
+    def incr(
+        self,
+        key: str,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        amount: Union[float, int] = 1,
+        sample_rate: float = 1,
+    ) -> None:
         pass
 
-    def timing(self, key, value, instance=None, tags=None, sample_rate=1):
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         pass
 
-    def gauge(self, key, value, instance=None, tags=None, sample_rate=1):
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         pass

src/sentry/metrics/logging.py

@@ -1,18 +1,40 @@
 import logging
+from typing import Optional, Union
 
-from .base import MetricsBackend
+from .base import MetricsBackend, Tags
 
 logger = logging.getLogger("sentry.metrics")
 
 
 class LoggingBackend(MetricsBackend):
-    def incr(self, key, instance=None, tags=None, amount=1, sample_rate=1):
+    def incr(
+        self,
+        key: str,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        amount: Union[float, int] = 1,
+        sample_rate: float = 1,
+    ) -> None:
         logger.debug("%r: %+g", key, amount, extra={"instance": instance, "tags": tags or {}})
 
-    def timing(self, key, value, instance=None, tags=None, sample_rate=1):
+    def timing(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         logger.debug(
             "%r: %g ms", key, value * 1000, extra={"instance": instance, "tags": tags or {}}
         )
 
-    def gauge(self, key, value, instance=None, tags=None, sample_rate=1):
+    def gauge(
+        self,
+        key: str,
+        value: float,
+        instance: Optional[str] = None,
+        tags: Optional[Tags] = None,
+        sample_rate: float = 1,
+    ) -> None:
         logger.debug("%r: %+g", key, value, extra={"instance": instance, "tags": tags or {}})