refactor: cache constant tags

Author: KowalskiThomas

datadog/__init__.py

@@ -13,7 +13,10 @@
 # stdlib
 import logging
 import os
-from typing import Any, List, Optional  # noqa: F401
+import sys
+
+if sys.version_info[0] >= 3:
+    from typing import Any, List, Optional  # noqa: F401
 
 # datadog
 from datadog import api

datadog/api/__init__.py

@@ -3,7 +3,11 @@
 # Copyright 2015-Present Datadog, Inc
 # flake8: noqa
 
-from typing import Optional
+import sys
+
+
+if sys.version_info[0] >= 3:
+    from typing import Optional  # noqa: F401
 
 # API settings
 _api_key = None  # type: Optional[str]

datadog/api/http_client.py

@@ -12,16 +12,19 @@
 import copy
 import logging
 import platform
+import sys
 import urllib
-from typing import TYPE_CHECKING
+
 from threading import Lock
 
 # datadog
 from datadog.api.exceptions import ProxyError, ClientError, HTTPError, HttpTimeout
 
-if TYPE_CHECKING:
-    import types  # noqa: F401
-    from typing import Optional  # noqa: F401
+if sys.version_info[:2] >= (3, 5):
+    from typing import TYPE_CHECKING
+    if TYPE_CHECKING:
+        import types  # noqa: F401
+        from typing import Optional  # noqa: F401
 
 
 # 3p

datadog/dogstatsd/aggregator.py

@@ -1,5 +1,8 @@
 import threading
-from typing import Any, Dict, List, Optional
+import sys
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import Any, Dict, List, Optional  # noqa: F401
 
 from datadog.dogstatsd.metrics import (
     CountMetric,

datadog/dogstatsd/base.py

@@ -19,7 +19,9 @@
 import time
 from threading import Lock, RLock
 import weakref
-from typing import TYPE_CHECKING
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import TYPE_CHECKING  # noqa: F401
 
 try:
     import queue
@@ -29,7 +31,13 @@
 
 
 # pylint: disable=unused-import
-from typing import Any, Optional, List, Text, Type, Union
+if sys.version_info[:2] >= (3, 5):
+    from typing import Any, Optional, List, Text, Type, Union, Iterable, Callable, overload  # noqa: F401
+
+try:
+    from typing import SupportsIndex
+except ImportError:
+    SupportsIndex = int  # type: ignore[assignment,misc]
 # pylint: enable=unused-import
 
 # Datadog libraries
@@ -45,8 +53,102 @@
 from datadog.util.format import normalize_tags, validate_cardinality
 from datadog.version import __version__
 
-if TYPE_CHECKING:
-    from socket import socket as _Socket
+
+if sys.version_info[:2] >= (3, 5):
+    if TYPE_CHECKING:
+        from socket import socket as _Socket
+
+    BaseListClass = List[str]
+else:
+    BaseListClass = list
+
+class TagList(BaseListClass):
+    """A list subclass that calls on_change() after any mutation."""
+
+    def __init__(self, iterable = (), on_change = None):
+        # type: (Iterable[str], Optional[Callable[[], None]]) -> None
+        super(TagList, self).__init__(iterable)
+        self._on_change = on_change
+
+    def _notify(self):
+        # type: () -> None
+        if self._on_change is not None:
+            self._on_change()
+
+    if sys.version_info[:2] >= (3, 5):
+        @overload
+        def __setitem__(self, index, value):  # noqa: F811
+            # type: (SupportsIndex, str) -> None
+            pass
+
+        @overload
+        def __setitem__(self, index, value):  # noqa: F811
+            # type: (slice, Iterable[str]) -> None
+            pass
+
+    def __setitem__(self, index, value):  # noqa: F811
+        # type: (Union[SupportsIndex, slice], Union[str, Iterable[str]]) -> None
+        super(TagList, self).__setitem__(index, value)  # type: ignore
+        self._notify()
+
+    def __delitem__(self, index):  # noqa: F811
+        # type: (Union[SupportsIndex, slice]) -> None
+        super(TagList, self).__delitem__(index)
+        self._notify()
+
+    def __iadd__(self, other):  # type: ignore[misc,override]  # noqa: F811 
+        # type: (Iterable[str]) -> "TagList"
+        super(TagList, self).__iadd__(other)
+        self._notify()
+        return self
+
+    def __imul__(self, n):  # noqa: F811
+        # type: (SupportsIndex) -> "TagList"
+        super(TagList, self).__imul__(n)
+        self._notify()
+        return self
+
+    def append(self, value):  # noqa: F811
+        # type: (str) -> None
+        super(TagList, self).append(value)
+        self._notify()
+
+    def extend(self, iterable):  # noqa: F811
+        # type: (Iterable[str]) -> None
+        super(TagList, self).extend(iterable)
+        self._notify()
+
+    def insert(self, index, value):  # noqa: F811
+        # type: (SupportsIndex, str) -> None
+        super(TagList, self).insert(index, value)
+        self._notify()
+
+    def remove(self, value):  # noqa: F811
+        # type: (str) -> None
+        super(TagList, self).remove(value)
+        self._notify()
+
+    def pop(self, index = -1):  # noqa: F811
+        # type: (SupportsIndex) -> str
+        value = super(TagList, self).pop(index)
+        self._notify()
+        return value
+
+    def clear(self):  # noqa: F811
+        # type: () -> None
+        super(TagList, self).__delitem__(slice(None))
+        self._notify()
+
+    def sort(self, *args, **kwargs):
+        # type: (*Any, **Any) -> None
+        super(TagList, self).sort(*args, **kwargs)
+        self._notify()
+
+    def reverse(self):
+        # type: () -> None
+        super(TagList, self).reverse()
+        self._notify()
+
 
 # Logging
 log = logging.getLogger("datadog.dogstatsd")
@@ -442,9 +544,18 @@ def __init__(
             value = os.environ.get(var, "")
             if value:
                 env_tags.append("{name}:{value}".format(name=tag_name, value=value))
+
+        # This lock is used for all cases where client configuration is being changed: buffering,
+        # aggregation, sender mode.
+        self._config_lock = RLock()
+
         if constant_tags is None:
             constant_tags = []
-        self.constant_tags = constant_tags + env_tags
+
+        self._constant_tags_str = ""
+        self._constant_tags = TagList()
+        self.constant_tags = TagList(constant_tags + env_tags)
+
         if namespace is not None:
             namespace = text(namespace)
         self.namespace = namespace
@@ -476,10 +587,6 @@ def __init__(
 
         self._reset_buffer()
 
-        # This lock is used for all cases where client configuration is being changed: buffering,
-        # aggregation, sender mode.
-        self._config_lock = RLock()
-
         self._disable_buffering = disable_buffering
         self._disable_aggregation = disable_aggregation
 
@@ -1267,9 +1374,18 @@ def _serialize_metric(
             parts.append("|@")
             parts.append(text(sample_rate))
 
-        if tags:
+        with self._config_lock:
+            constant_tags_str = self._constant_tags_str
+
+        if tags or constant_tags_str:
             parts.append("|#")
-            parts.append(",".join(normalize_tags(tags)))
+            if tags:
+                parts.append(",".join(normalize_tags(tags)))
+                if constant_tags_str:
+                    parts.append(",")
+                    parts.append(constant_tags_str)
+            else:
+                parts.append(constant_tags_str)
 
         if self._container_id:
             parts.append("|c:")
@@ -1323,8 +1439,6 @@ def _report(self, metric, metric_type, value, tags, sample_rate, timestamp=0, sa
 
         validate_cardinality(cardinality)
 
-        # Resolve the full tag list
-        tags = self._add_constant_tags(tags)
         payload = self._serialize_metric(
             metric, metric_type, value, tags, sample_rate, timestamp, cardinality
         )
@@ -1642,13 +1756,40 @@ def service_check(
 
         self._send(string)
 
+    @staticmethod
+    def _normalize_and_join_tags(tags):
+        # type: (List[str]) -> str
+        """Normalize a tag list and join into a comma-separated string."""
+        if tags:
+            return ",".join(normalize_tags(tags))
+
+        return ""
+
+    def _rebuild_constant_tags_str(self):
+        # type: () -> None
+        with self._config_lock:
+            self._constant_tags_str = self._normalize_and_join_tags(self._constant_tags)
+
+    @property
+    def constant_tags(self):
+        # type: () -> TagList
+        return self._constant_tags
+
+    @constant_tags.setter
+    def constant_tags(self, value):
+        # type: (Union[TagList, List[str]]) -> None
+        with self._config_lock:
+            self._constant_tags = TagList(value or [], on_change=self._rebuild_constant_tags_str)
+            self._rebuild_constant_tags_str()
+
     def _add_constant_tags(self, tags):
         # type: (Optional[List[str]]) -> Optional[List[str]]
-        if self.constant_tags:
-            if tags:
-                return tags + self.constant_tags
+        with self._config_lock:
+            if self._constant_tags:
+                if tags:
+                    return tags + self._constant_tags
 
-            return self.constant_tags
+                return list(self._constant_tags)
         return tags
 
     def _is_origin_detection_enabled(self, container_id, origin_detection_enabled):

datadog/dogstatsd/container.py

@@ -6,7 +6,10 @@
 import errno
 import os
 import re
-from typing import Optional
+import sys
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import Optional  # noqa: F401
 
 
 class UnresolvableContainerID(Exception):

datadog/dogstatsd/context.py

@@ -3,7 +3,9 @@
 # Copyright 2015-Present Datadog, Inc
 # stdlib
 from functools import wraps
-from typing import Any, Callable, List, Optional, Text, TYPE_CHECKING, Union
+import sys
+
+
 
 try:
     from time import monotonic  # type: ignore[attr-defined]
@@ -14,8 +16,12 @@
 from datadog.dogstatsd.context_async import _get_wrapped_co
 from datadog.util.compat import iscoroutinefunction
 
-if TYPE_CHECKING:
-    from datadog.dogstatsd.base import DogStatsd
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import Any, Callable, List, Optional, Text, TYPE_CHECKING, Union  # noqa: F401
+
+    if TYPE_CHECKING:
+        from datadog.dogstatsd.base import DogStatsd  # noqa: F401
 
 
 class TimedContextManagerDecorator(object):

datadog/dogstatsd/context_async.py

@@ -8,7 +8,9 @@
 """
 # stdlib
 import sys
-from typing import Any, Callable
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import Any, Callable  # noqa: F401
 
 
 # Wrap the Python 3.5+ function in a docstring to avoid syntax errors when

datadog/dogstatsd/max_sample_metric.py

@@ -1,5 +1,9 @@
 import random
-from typing import List, Optional, cast
+import sys
+
+if sys.version_info[:2] >= (3, 5):
+    from typing import List, Optional, cast  # noqa: F401
+
 
 from datadog.dogstatsd.metric_types import MetricType
 from datadog.dogstatsd.metrics import MetricAggregator

datadog/dogstatsd/max_sample_metric_context.py

@@ -1,10 +1,13 @@
 from threading import Lock
 import random
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+import sys
 
-if TYPE_CHECKING:
-    from datadog.dogstatsd.max_sample_metric import MaxSampleMetric
-    from datadog.dogstatsd.metrics import MetricAggregator
+if sys.version_info[:2] >= (3, 5):
+    from typing import Any, Dict, List, Optional, TYPE_CHECKING  # noqa: F401
+
+    if TYPE_CHECKING:
+        from datadog.dogstatsd.max_sample_metric import MaxSampleMetric
+        from datadog.dogstatsd.metrics import MetricAggregator
 
 
 class MaxSampleMetricContexts: