Fix typing and extract error_processor to common module

Author: cmanallen

sentry_sdk/flag_utils.py

@@ -1,10 +1,12 @@
 from copy import copy
 from typing import TYPE_CHECKING
 
+import sentry_sdk
 from sentry_sdk._lru_cache import LRUCache
 
 if TYPE_CHECKING:
-    from typing import TypedDict
+    from typing import TypedDict, Optional
+    from sentry_sdk._types import Event, ExcInfo
 
     FlagData = TypedDict("FlagData", {"flag": str, "result": bool})
 
@@ -36,3 +38,10 @@ def get(self):
     def set(self, flag, result):
         # type: (str, bool) -> None
         self.buffer.set(flag, result)
+
+
+def flag_error_processor(event, exc_info):
+    # type: (Event, ExcInfo) -> Optional[Event]
+    scope = sentry_sdk.get_current_scope()
+    event["contexts"]["flags"] = {"values": scope.flags.get()}
+    return event

sentry_sdk/integrations/launchdarkly.py

@@ -2,6 +2,7 @@
 import sentry_sdk
 
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.flag_utils import flag_error_processor
 
 try:
     import ldclient
@@ -12,48 +13,39 @@
         from ldclient.hook import EvaluationSeriesContext
         from ldclient.evaluation import EvaluationDetail
 
-        from sentry_sdk._types import Event, ExcInfo
-        from typing import Any, Optional
+        from typing import Any
 except ImportError:
     raise DidNotEnable("LaunchDarkly is not installed")
 
 
 class LaunchDarklyIntegration(Integration):
     identifier = "launchdarkly"
 
-    def __init__(self, client=None):
+    def __init__(self, ld_client=None):
         # type: (LDClient | None) -> None
         """
         :param client: An initialized LDClient instance. If a client is not provided, this
             integration will attempt to use the shared global instance.
         """
-        if client is None:
-            try:
-                client = ldclient.get()  # global singleton.
-            except Exception as exc:
-                raise DidNotEnable("Error getting LaunchDarkly client. " + repr(exc))
+        try:
+            client = ld_client or ldclient.get()
+        except Exception as exc:
+            raise DidNotEnable("Error getting LaunchDarkly client. " + repr(exc))
 
         if not client.is_initialized():
             raise DidNotEnable("LaunchDarkly client is not initialized.")
-        self.ld_client = client
+
+        self.client = client
 
     @staticmethod
     def setup_once():
         # type: () -> None
-        def error_processor(event, _exc_info):
-            # type: (Event, ExcInfo) -> Optional[Event]
-            scope = sentry_sdk.get_current_scope()
-            event["contexts"]["flags"] = {"values": scope.flags.get()}
-            return event
-
         scope = sentry_sdk.get_current_scope()
-        scope.add_error_processor(error_processor)
+        scope.add_error_processor(flag_error_processor)
 
         # Register the flag collection hook with the LD client.
-        ld_client = (
-            sentry_sdk.get_client().get_integration(LaunchDarklyIntegration).ld_client
-        )
-        ld_client.add_hook(LaunchDarklyHook())
+        client = sentry_sdk.get_client().get_integration(LaunchDarklyIntegration).client
+        client.add_hook(LaunchDarklyHook())
 
 
 class LaunchDarklyHook(Hook):
@@ -70,6 +62,6 @@ def after_evaluation(self, series_context, data, detail):
             flags.set(series_context.key, detail.value)
         return data
 
-    def before_evaluation(self, _series_context, data):
+    def before_evaluation(self, series_context, data):
         # type: (EvaluationSeriesContext, dict[Any, Any]) -> dict[Any, Any]
         return data  # No-op.

sentry_sdk/integrations/openfeature.py

@@ -2,6 +2,7 @@
 import sentry_sdk
 
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.flag_utils import flag_error_processor
 
 try:
     from openfeature import api
@@ -10,8 +11,6 @@
     if TYPE_CHECKING:
         from openfeature.flag_evaluation import FlagEvaluationDetails
         from openfeature.hook import HookContext, HookHints
-        from sentry_sdk._types import Event, ExcInfo
-        from typing import Optional
 except ImportError:
     raise DidNotEnable("OpenFeature is not installed")
 
@@ -22,14 +21,8 @@ class OpenFeatureIntegration(Integration):
     @staticmethod
     def setup_once():
         # type: () -> None
-        def error_processor(event, exc_info):
-            # type: (Event, ExcInfo) -> Optional[Event]
-            scope = sentry_sdk.get_current_scope()
-            event["contexts"]["flags"] = {"values": scope.flags.get()}
-            return event
-
         scope = sentry_sdk.get_current_scope()
-        scope.add_error_processor(error_processor)
+        scope.add_error_processor(flag_error_processor)
 
         # Register the hook within the global openfeature hooks list.
         api.add_hooks(hooks=[OpenFeatureHook()])