Blacklist fn accepts custop functions

Author: kompotkot

python/humbug/blacklist.py

@@ -0,0 +1,44 @@
+"""
+Various implementations of the blacklist functionality.
+"""
+from typing import Any, Dict, List, Optional
+
+
+def filter_parameters_by_key(
+    blacklist_keys: List[str],
+    parameters: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Applies blacklist filter to provided parameters and to 2nd layer of
+    inner dictionary parameter if exists.
+    """
+    whitelisted_parameters: Dict[str, Any] = {}
+
+    for key in parameters.keys():
+        if key.lower() in blacklist_keys:
+            continue
+
+        key_as_dict: Optional[Dict[str, Any]] = None
+        for d in dir(parameters[key]):
+            if d == "keys":
+                key_as_dict = parameters[key]
+                break
+            elif d == "dict":  # Pydantic models support
+                key_as_dict = parameters[key].dict()
+                break
+
+        if key_as_dict is not None:
+            try:
+                inner_dict: Dict[str, str] = {}
+                for inner_key in key_as_dict.keys():
+                    if inner_key.lower() in blacklist_keys:
+                        continue
+                    inner_dict[inner_key] = str(key_as_dict[inner_key])
+                whitelisted_parameters[key] = inner_dict
+                continue
+            except Exception:
+                pass
+
+        whitelisted_parameters[key] = str(parameters[key])
+
+    return whitelisted_parameters

python/humbug/report.py

@@ -60,7 +60,10 @@ def __init__(
         mode: Modes = Modes.DEFAULT,
         url: Optional[str] = None,
         tags: Optional[List[str]] = None,
-        blacklisted_keys: Optional[List[str]] = None,
+        blacklist_keys: List[str] = [],
+        blacklist_fn: Optional[
+            Callable[[List[str], Dict[str, Any]], Dict[str, Any]]
+        ] = None,
     ):
         if url is None:
             url = DEFAULT_URL
@@ -94,9 +97,8 @@ def __init__(
         if tags is not None:
             self.tags = tags
 
-        self.blacklisted_keys: List[str] = []
-        if blacklisted_keys is not None:
-            self.blacklisted_keys = blacklisted_keys
+        self.blacklist_keys = blacklist_keys
+        self.blacklist_fn = blacklist_fn
 
     def wait(self) -> None:
         concurrent.futures.wait(
@@ -124,44 +126,6 @@ def system_tags(self) -> List[str]:
 
         return tags
 
-    def _apply_blacklist_to_parameters(
-        self, parameters: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        Applies blacklist filter to provided parameters and to 2nd layer of
-        inner dictionary parameter if exists.
-        """
-        whitelisted_parameters: Dict[str, Any] = {}
-
-        for key in parameters.keys():
-            if key in self.blacklisted_keys:
-                continue
-
-            key_as_dict: Optional[Dict[str, Any]] = None
-            for d in dir(parameters[key]):
-                if d == "keys":
-                    key_as_dict = parameters[key]
-                    break
-                elif d == "dict":  # Pydantic models support
-                    key_as_dict = parameters[key].dict()
-                    break
-
-            if key_as_dict is not None:
-                try:
-                    inner_dict: Dict[str, str] = {}
-                    for inner_key in key_as_dict.keys():
-                        if inner_key in self.blacklisted_keys:
-                            continue
-                        inner_dict[inner_key] = str(key_as_dict[inner_key])
-                    whitelisted_parameters[key] = inner_dict
-                    continue
-                except Exception:
-                    pass
-
-            whitelisted_parameters[key] = str(parameters[key])
-
-        return whitelisted_parameters
-
     def _post_body(self, report: Report) -> Dict[str, Any]:
         return {
             "title": report.title,
@@ -429,12 +393,12 @@ def feature_report(
         tags: Optional[List[str]] = None,
         publish: bool = True,
         wait: bool = False,
-        blacklist_apply: bool = True,
+        apply_blacklist: bool = True,
     ) -> Report:
         title = "Feature used: {name}".format(name=feature_name)
 
-        if blacklist_apply:
-            parameters = self._apply_blacklist_to_parameters(parameters)
+        if apply_blacklist and self.blacklist_fn is not None:
+            parameters = self.blacklist_fn(self.blacklist_keys, parameters)
 
         parameters_content = "\n".join(
             [

python/humbug/test_report.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import MagicMock
 
-from . import consent, report
+from . import consent, report, blacklist
 
 
 class TestReporter(unittest.TestCase):
@@ -11,7 +11,8 @@ def setUp(self):
             name="TestReporter",
             consent=self.consent,
             tags=["humbug-unit-test"],
-            blacklisted_keys=["private"],
+            blacklist_keys=["private"],
+            blacklist_fn=blacklist.filter_parameters_by_key,
         )
         self.reporter.publish = MagicMock()
 
@@ -92,6 +93,21 @@ def test_feature_report(self):
         )
         self.assertTrue("parameter:{}={{}}".format("inner") in report.tags)
 
+    def test_feature_report_not_apply_blacklist(self):
+        report = self.reporter.feature_report(
+            "test_feature_not_apply_blacklist",
+            {
+                "private": "confidential",
+                "inner": {"private": "confidential"},
+            },
+            publish=False,
+            apply_blacklist=False,
+        )
+        self.assertTrue(
+            "parameter:{}={}".format("private", "confidential") in report.tags
+        )
+        self.assertTrue("parameter:{}={{}}".format("inner") not in report.tags)
+
     def test_record_call(self):
         @self.reporter.record_call
         def the_answer(life, universe=None, everything=None):