Initial commit

Author: cmanallen

sentry_sdk/flag_utils.py

@@ -0,0 +1,68 @@
+import itertools
+
+
+class FlagManager:
+    """
+    Right now this is just an interface for the buffer but it might contain
+    thread-local state handling in the future.
+    """
+
+    def __init__(self, capacity):
+        # type: (int) -> None
+        self.buffer = FlagBuffer(capacity)
+
+    def get_flags(self):
+        # type: () -> list[dict]
+        return self.buffer.serialize()
+
+    def set_flag(self, flag, result):
+        # type: (str, bool) -> None
+        self.buffer.insert(flag, result)
+
+
+class FlagBuffer:
+
+    def __init__(self, capacity):
+        # type: (int) -> None
+        self.buffer = []  # type: list[Flag]
+        self.capacity = capacity
+        self.ip = 0
+
+    @property
+    def index(self):
+        return self.ip % self.capacity
+
+    def insert(self, flag, result):
+        # type: (str, bool) -> None
+        flag_ = Flag(flag, result)
+
+        if self.ip >= self.capacity:
+            self.buffer[self.index] = flag_
+        else:
+            self.buffer.append(flag_)
+
+        self.ip += 1
+
+    def serialize(self):
+        # type: () -> list[dict]
+        if self.ip >= self.capacity:
+            iterator = itertools.chain(
+                range(self.index, self.capacity), range(0, self.index)
+            )
+            return [self.buffer[i].asdict for i in iterator]
+        else:
+            return [flag.asdict for flag in self.buffer]
+
+
+class Flag:
+    __slots__ = ("flag", "result")
+
+    def __init__(self, flag, result):
+        # type: (str, bool) -> None
+        self.flag = flag
+        self.result = result
+
+    @property
+    def asdict(self):
+        # type: () -> dict
+        return {"flag": self.flag, "result": self.result}

sentry_sdk/integrations/openfeature.py

@@ -0,0 +1,62 @@
+from typing import TYPE_CHECKING
+import sentry_sdk
+
+from sentry_sdk.flag_utils import FlagManager
+from sentry_sdk.integrations import DidNotEnable, Integration
+
+try:
+    from openfeature import api
+    from openfeature.hook import Hook
+
+    if TYPE_CHECKING:
+        from openfeature.flag_evaluation import FlagEvaluationDetails
+        from openfeature.hook import HookContext, HookHints
+except ImportError:
+    raise DidNotEnable("Starlette is not installed")
+
+
+class OpenFeatureIntegration(Integration):
+    """
+    Bridges the sentry and openfeature sdks. Thread-local data is expected to
+    flow from openfeature to the integration before the sentry-sdk requests the
+    thread-local state to be serialized and sent off in the error payload.
+    """
+
+    def __init__(self, capacity):
+        # type: (int) -> None
+        self.flag_manager = FlagManager(capacity=capacity)
+
+        # Get or create a new isolation scope and register the integration's
+        # error processing hook on it.
+        scope = sentry_sdk.get_isolation_scope()
+        scope.add_error_processor(self.error_processor)
+
+        # This is a globally registered hook (its a list singleton). FlagManager
+        # expects itself to be in a THREAD-LOCAL context. Whatever hooks are
+        # triggered will not be THREAD-LOCAL unless we seed the open feature hook
+        # class with thread-local context.
+        api.add_hooks(hooks=[OpenFeatureHook(self.flag_manager)])
+
+    def error_processor(self, event, exc_info):
+        """
+        On error Sentry will call this hook. This needs to serialize the flags
+        from the THREAD-LOCAL context and put the result into the error event.
+        """
+        event["contexts"]["flags"] = {"values": self.flag_manager.get_flags()}
+        return event
+
+
+class OpenFeatureHook(Hook):
+    """
+    OpenFeature will call the `after` method after each flag evaluation. We need to
+    accept the method call and push the result into our THREAD-LOCAL buffer.
+    """
+
+    def __init__(self, flag_manager):
+        # type: (FlagManager) -> None
+        self.flag_manager = flag_manager
+
+    def after(self, hook_context, details, hints) -> None:
+        # type: (HookContext, FlagEvaluationDetails, HookHints) -> None
+        if isinstance(details.value, bool):
+            self.flag_manager.set_flag(details.flag_key, details.value)

tests/test_flag_utils.py

@@ -0,0 +1,88 @@
+# import asyncio
+# import pytest
+# import concurrent.futures as cf
+
+from sentry_sdk.flag_utils import get_flags, set_flag
+
+
+def test_flag_tracking():
+    """Assert the ring buffer works."""
+    set_flag("a", True)
+    flags = get_flags()
+    assert len(flags) == 1
+    assert flags == [{"flag": "a", "result": True}]
+
+    set_flag("b", True)
+    flags = get_flags()
+    assert len(flags) == 2
+    assert flags == [{"flag": "a", "result": True}, {"flag": "b", "result": True}]
+
+    set_flag("c", True)
+    flags = get_flags()
+    assert len(flags) == 3
+    assert flags == [
+        {"flag": "a", "result": True},
+        {"flag": "b", "result": True},
+        {"flag": "c", "result": True},
+    ]
+
+    set_flag("d", False)
+    flags = get_flags()
+    assert len(flags) == 3
+    assert flags == [
+        {"flag": "b", "result": True},
+        {"flag": "c", "result": True},
+        {"flag": "d", "result": False},
+    ]
+
+    set_flag("e", False)
+    set_flag("f", False)
+    flags = get_flags()
+    assert len(flags) == 3
+    assert flags == [
+        {"flag": "d", "result": False},
+        {"flag": "e", "result": False},
+        {"flag": "f", "result": False},
+    ]
+
+
+# Not applicable right now. Thread-specific testing might be moved to another
+# module depending on who eventually managees it.
+
+
+# def test_flag_manager_asyncio_isolation(i):
+#     """Assert concurrently evaluated flags do not pollute one another."""
+
+#     async def task(chars: str):
+#         for char in chars:
+#             set_flag(char, True)
+#         return [f["flag"] for f in get_flags()]
+
+#     async def runner():
+#         return asyncio.gather(
+#             task("abc"),
+#             task("de"),
+#             task("fghijk"),
+#         )
+
+#     results = asyncio.run(runner()).result()
+
+#     assert results[0] == ["a", "b", "c"]
+#     assert results[1] == ["d", "e"]
+#     assert results[2] == ["i", "j", "k"]
+
+
+# def test_flag_manager_thread_isolation(i):
+#     """Assert concurrently evaluated flags do not pollute one another."""
+
+#     def task(chars: str):
+#         for char in chars:
+#             set_flag(char, True)
+#         return [f["flag"] for f in get_flags()]
+
+#     with cf.ThreadPoolExecutor(max_workers=3) as pool:
+#         results = list(pool.map(task, ["abc", "de", "fghijk"]))
+
+#     assert results[0] == ["a", "b", "c"]
+#     assert results[1] == ["d", "e"]
+#     assert results[2] == ["i", "j", "k"]