lint

Author: dubloom

ddtrace/_trace/processor/__init__.py

@@ -13,17 +13,17 @@
 from ddtrace._trace.span import _get_64_highest_order_bits_as_hex
 from ddtrace.constants import _APM_ENABLED_METRIC_KEY as MK_APM_ENABLED
 from ddtrace.constants import _SINGLE_SPAN_SAMPLING_MECHANISM
-from ddtrace.internal.constants import PROCESS_TAGS
 from ddtrace.internal import gitmetadata
 from ddtrace.internal import telemetry
-from ddtrace.internal.process_tags import process_tags
 from ddtrace.internal.constants import COMPONENT
 from ddtrace.internal.constants import HIGHER_ORDER_TRACE_ID_BITS
 from ddtrace.internal.constants import LAST_DD_PARENT_ID_KEY
 from ddtrace.internal.constants import MAX_UINT_64BITS
+from ddtrace.internal.constants import PROCESS_TAGS
 from ddtrace.internal.constants import SAMPLING_DECISION_TRACE_TAG_KEY
 from ddtrace.internal.constants import SamplingMechanism
 from ddtrace.internal.logger import get_logger
+from ddtrace.internal.process_tags import process_tags
 from ddtrace.internal.rate_limiter import RateLimiter
 from ddtrace.internal.sampling import SpanSamplingRule
 from ddtrace.internal.sampling import get_span_sampling_rules

ddtrace/internal/process_tags/__init__.py

@@ -19,21 +19,23 @@
 
 log = get_logger(__name__)
 
+
 # outside of ProcessTags class for test purpose
 def normalize_tag(value: str) -> str:
     return re.sub(r"[^a-z0-9/._-]", "_", value.lower())
-class ProcessTags:
-    process_tags: Dict[str, str] = {}
 
+
+class ProcessTags:
     def __init__(self) -> None:
         self._lock = Lock()
         self._serialized: Optional[str] = None
         self._enabled = config._process_tags_enabled
+        self._process_tags: Dict[str, str] = {}
         self.reload()
 
     def _serialize_process_tags(self) -> Optional[str]:
-        if self.process_tags and not self._serialized:
-            serialized_tags = ",".join(f"{key}:{value}" for key, value in self.process_tags.items())
+        if self._process_tags and not self._serialized:
+            serialized_tags = ",".join(f"{key}:{value}" for key, value in self._process_tags.items())
             return serialized_tags
         return None
 
@@ -58,19 +60,20 @@ def add_process_tag(self, key: str, value: Optional[str] = None, compute: Option
 
         if value:
             with self._lock:
-                self.process_tags[key] = normalize_tag(value)
+                self._process_tags[key] = normalize_tag(value)
                 self._serialized = None
 
     def reload(self):
         if not self._enabled:
             return
 
         with self._lock:
-            self.process_tags = {}
+            self._process_tags = {}
 
         self.add_process_tag(ENTRYPOINT_WORKDIR_TAG, compute=lambda: os.path.basename(os.getcwd()))
         self.add_process_tag(ENTRYPOINT_BASEDIR_TAG, compute=lambda: Path(sys.argv[0]).resolve().parent.name)
         self.add_process_tag(ENTRYPOINT_NAME_TAG, compute=lambda: os.path.splitext(os.path.basename(sys.argv[0]))[0])
         self.add_process_tag(ENTRYPOINT_TYPE_TAG, value=ENTRYPOINT_TYPE_SCRIPT)
 
-process_tags = ProcessTags()
+
+process_tags = ProcessTags()

riotfile.py

@@ -498,11 +498,7 @@ def select_pys(min_version: str = MIN_PYTHON_VERSION, max_version: str = MAX_PYT
             command="pytest --no-cov {cmdargs} tests/coverage -s",
             pys=select_pys(max_version="3.12"),
         ),
-        Venv(
-            name="process_tags",
-            command="pytest -v {cmdargs} tests/process_tags/",
-            pys=select_pys(min_version="3.9")
-        ),
+        Venv(name="process_tags", command="pytest -v {cmdargs} tests/process_tags/", pys=select_pys(min_version="3.9")),
         Venv(
             name="internal",
             env={

tests/process_tags/test_process_tags.py

@@ -1,12 +1,18 @@
+import os
+from pathlib import Path
+import sys
+
+from ddtrace.internal.constants import PROCESS_TAGS
 from ddtrace.internal.process_tags import normalize_tag
 from ddtrace.internal.process_tags import process_tags
-from ddtrace.internal.constants import PROCESS_TAGS
-from ddtrace.internal.process_tags.constants import ENTRYPOINT_BASEDIR_TAG, ENTRYPOINT_NAME_TAG, ENTRYPOINT_TYPE_SCRIPT, ENTRYPOINT_TYPE_TAG, ENTRYPOINT_WORKDIR_TAG
+from ddtrace.internal.process_tags.constants import ENTRYPOINT_BASEDIR_TAG
+from ddtrace.internal.process_tags.constants import ENTRYPOINT_NAME_TAG
+from ddtrace.internal.process_tags.constants import ENTRYPOINT_TYPE_SCRIPT
+from ddtrace.internal.process_tags.constants import ENTRYPOINT_TYPE_TAG
+from ddtrace.internal.process_tags.constants import ENTRYPOINT_WORKDIR_TAG
 from tests.utils import TracerTestCase
 from tests.utils import override_env
-import sys
-import os
-from pathlib import Path
+
 
 def test_normalize_tag():
     assert normalize_tag("HelloWorld") == "helloworld"
@@ -21,8 +27,8 @@ def test_normalize_tag():
     assert normalize_tag("123_abc.DEF-ghi/jkl") == "123_abc.def-ghi/jkl"
     assert normalize_tag("Env:Prod-Server#1") == "env_prod-server_1"
 
-class TestProcessTags(TracerTestCase):
 
+class TestProcessTags(TracerTestCase):
     def test_process_tags_deactivated(self):
         with self.tracer.trace("test"):
             pass
@@ -98,11 +104,11 @@ def failing_compute():
 
             process_tags.add_process_tag("test.tag", compute=failing_compute)
 
-            assert "test.tag" not in process_tags.process_tags
+            assert "test.tag" not in process_tags._process_tags
 
             process_tags.add_process_tag("test.working", value="value")
-            assert "test.working" in process_tags.process_tags
-            assert process_tags.process_tags["test.working"] == "value"
+            assert "test.working" in process_tags._process_tags
+            assert process_tags._process_tags["test.working"] == "value"
 
             process_tags._enabled = False
 
@@ -112,7 +118,7 @@ def test_serialization_caching(self):
             process_tags._enabled = True
             process_tags.reload()
 
-            result1 = process_tags.get_serialized_process_tags()
+            process_tags.get_serialized_process_tags()
             assert process_tags._serialized is not None
 
             process_tags.add_process_tag("custom.tag", value="test")
@@ -121,4 +127,4 @@ def test_serialization_caching(self):
             result3 = process_tags.get_serialized_process_tags()
             assert "custom.tag:test" in result3
 
-            process_tags._enabled = False
+            process_tags._enabled = False