feat: add the ignore user_agent ability

Author: Kl0ven

sentry_dynamic_sampling_lib/__init__.py

@@ -49,7 +49,7 @@ def init_wrapper():
         app_key = build_app_key(client.options)
         controller_endpoint = urljoin(CONTROLLER_HOST, CONTROLLER_PATH)
         metric_endpoint = urljoin(CONTROLLER_HOST, METRIC_PATH)
-        print(f"Sentry Wrapper: Injecting TracesSampler. App Key : {app_key}")
+        LOGGER.warning("Sentry Wrapper: Injecting TracesSampler. App Key : %s", app_key)
         client.options["traces_sampler"] = TraceSampler(
             poll_interval=POLL_INTERVAL,
             metric_interval=METRIC_INTERVAL,

sentry_dynamic_sampling_lib/sampler.py

@@ -93,7 +93,7 @@ def update_metrics(self):
             data = {
                 "app": self.app_key,
                 "type": metric_type.value,
-                "data": dict(data.most_common(10)),
+                "data": dict(data),
             }
             try:
                 self.session.post(
@@ -154,9 +154,11 @@ def __call__(self, sampling_context):
         if sampling_context:
             if "wsgi_environ" in sampling_context:
                 path = sampling_context["wsgi_environ"].get("PATH_INFO", "")
-                if path in self.app_config.ignored_paths:
+                user_agent = sampling_context["wsgi_environ"].get("HTTP_USER_AGENT", "")
+                if path in self.app_config.ignored_paths or user_agent.startswith(self.app_config.ignored_user_agents):
                     return 0
                 self.metrics.count_path(path)
+                self.metrics.count_user_agent(user_agent)
             if "celery_job" in sampling_context:
                 task = sampling_context["celery_job"].get("task", "")
                 if task in self.app_config.ignored_tasks:

sentry_dynamic_sampling_lib/settings.py

@@ -3,6 +3,7 @@
 # default value overridden by controller
 DEFAULT_IGNORED_PATH = {"/health", "/healthz", "/health/", "/healthz/"}
 DEFAULT_IGNORED_TASK = set()
+DEFAULT_IGNORED_USER_AGENT = set()
 DEFAULT_SAMPLE_RATE = 0.0
 
 # controller variables

sentry_dynamic_sampling_lib/shared.py

@@ -6,6 +6,7 @@
 from sentry_dynamic_sampling_lib.settings import (
     DEFAULT_IGNORED_PATH,
     DEFAULT_IGNORED_TASK,
+    DEFAULT_IGNORED_USER_AGENT,
     DEFAULT_SAMPLE_RATE,
 )
 from sentry_dynamic_sampling_lib.utils import synchronized
@@ -18,6 +19,7 @@ def __init__(self) -> None:
         self._lock = RLock()
         self._sample_rate = DEFAULT_SAMPLE_RATE
         self._ignored_paths = DEFAULT_IGNORED_PATH
+        self._ignored_user_agents = tuple(DEFAULT_IGNORED_USER_AGENT)
         self._ignored_tasks = DEFAULT_IGNORED_TASK
 
     @property
@@ -40,6 +42,16 @@ def ignored_paths(self):
     def ignored_paths(self, new_ignored_paths):
         self._ignored_paths = set(new_ignored_paths)
 
+    @property
+    @synchronized
+    def ignored_user_agents(self):
+        return self._ignored_user_agents
+
+    @ignored_user_agents.setter
+    @synchronized
+    def ignored_user_agents(self, new_ignored_user_agents):
+        self._ignored_user_agents = set(new_ignored_user_agents)
+
     @property
     @synchronized
     def ignored_tasks(self):
@@ -55,6 +67,7 @@ def update(self, data):
         self._sample_rate = data["active_sample_rate"]
         self._ignored_paths = set(data["wsgi_ignore_path"])
         self._ignored_tasks = set(data["celery_ignore_task"])
+        self._ignored_user_agents = tuple(data.get("wsgi_ignore_user_agent", []))
 
 
 class MetricType(Enum):
@@ -66,8 +79,8 @@ class Metric:
     def __init__(self) -> None:
         self._lock = RLock()
         self._metrics = {
-            MetricType.WSGI: {"activated": False, "data": Counter()},
-            MetricType.CELERY: {"activated": False, "data": Counter()},
+            MetricType.WSGI: {"activated": False, "data": {"path": Counter(), "user_agent": Counter()}},
+            MetricType.CELERY: {"activated": False, "data": {"task": Counter()}},
         }
 
     def set_mode(self, _type, mode):
@@ -80,13 +93,19 @@ def get_mode(self, _type):
     def count_path(self, path):
         metric = self._metrics[MetricType.WSGI]
         if metric["activated"]:
-            metric["data"][path] += 1
+            metric["data"]["path"][path] += 1
+
+    @synchronized
+    def count_user_agent(self, user_agent):
+        metric = self._metrics[MetricType.WSGI]
+        if metric["activated"]:
+            metric["data"]["user_agent"][user_agent] += 1
 
     @synchronized
     def count_task(self, path):
         metric = self._metrics[MetricType.CELERY]
         if metric["activated"]:
-            metric["data"][path] += 1
+            metric["data"]["task"][path] += 1
 
     def __iter__(self):
         """
@@ -101,12 +120,16 @@ def __iter__(self):
                 LOGGER.debug("Metric %s disabled", metric_type.value)
                 continue
             with self._lock:
-                # check im metric is empty
-                if len(metric["data"]) == 0:
-                    LOGGER.debug("Metric %s is empty", metric_type.value)
+                data = {}
+                for name, counter in metric["data"].items():
+                    # check if metric is empty
+                    if len(counter) == 0:
+                        LOGGER.debug("Metric %s:%s is empty", metric_type.value, name)
+                        continue
+                    data[name] = dict(counter.most_common(10))
+                    metric["data"][name] = Counter()
+                if not data:
                     continue
-                data = metric["data"]
-                metric["data"] = Counter()
 
             # yield outside of the lock to not block write while callee execute
             yield metric_type, data