Check if event loop is unpatched

Author: sentrivana

sentry_sdk/integrations/__init__.py

@@ -280,36 +280,6 @@ def setup_integrations(
     return integrations
 
 
-def _enable_integration(integration: "Integration") -> None:
-    identifier = integration.identifier
-
-    with _installer_lock:
-        client = sentry_sdk.get_client()
-        if not client.is_active():
-            return
-
-        if identifier in client.integrations:
-            logger.debug("Integration already enabled: %s", identifier)
-            return
-
-        if identifier not in _installed_integrations or identifier == "asyncio":
-            # Asyncio is special because it patches the currently running event
-            # loop. _installed_integrations, on the other hand, prevents
-            # re-patching on the process level.
-            logger.debug("Setting up integration %s", identifier)
-            _processed_integrations.add(identifier)
-            try:
-                type(integration).setup_once()
-                integration.setup_once_with_options(client.options)
-            except DidNotEnable as e:
-                logger.debug("Did not enable integration %s: %s", identifier, e)
-                return
-
-            _installed_integrations.add(identifier)
-
-        client.integrations[integration.identifier] = integration
-
-
 def _check_minimum_version(
     integration: "type[Integration]",
     version: "Optional[tuple[int, ...]]",

sentry_sdk/integrations/asyncio.py

@@ -3,7 +3,7 @@
 
 import sentry_sdk
 from sentry_sdk.consts import OP
-from sentry_sdk.integrations import Integration, DidNotEnable, _enable_integration
+from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.utils import event_from_exception, logger, reraise
 
 try:
@@ -47,6 +47,10 @@ def patch_asyncio() -> None:
         loop = asyncio.get_running_loop()
         orig_task_factory = loop.get_task_factory()
 
+        # Check if already patched
+        if getattr(orig_task_factory, "_is_sentry_task_factory", False):
+            return
+
         def _sentry_task_factory(
             loop: "asyncio.AbstractEventLoop",
             coro: "Coroutine[Any, Any, Any]",
@@ -102,6 +106,7 @@ async def _task_with_sentry_span_creation() -> "Any":
 
             return task
 
+        _sentry_task_factory._is_sentry_task_factory = True  # type: ignore
         loop.set_task_factory(_sentry_task_factory)  # type: ignore
 
     except RuntimeError:
@@ -167,4 +172,11 @@ async def async_entrypoint():
     sentry_sdk.init(disabled_integrations=[...]), this function will ignore that
     and the integration will be enabled.
     """
-    _enable_integration(AsyncioIntegration(*args, **kwargs))
+    client = sentry_sdk.get_client()
+    if not client.is_active():
+        return
+
+    logger.debug("Setting up integration asyncio")
+    integration = AsyncioIntegration(*args, **kwargs)
+    integration.setup_once()
+    client.integrations["asyncio"] = integration

tests/integrations/asyncio/test_asyncio.py

@@ -233,6 +233,7 @@ def test_patch_asyncio(mock_get_running_loop):
     Test that the patch_asyncio function will patch the task factory.
     """
     mock_loop = mock_get_running_loop.return_value
+    mock_loop.get_task_factory.return_value._is_sentry_task_factory = False
 
     patch_asyncio()
 
@@ -282,6 +283,7 @@ def test_sentry_task_factory_with_factory(mock_get_running_loop):
 
     # The original task factory will be mocked out here, let's retrieve the value for later
     orig_task_factory = mock_loop.get_task_factory.return_value
+    orig_task_factory._is_sentry_task_factory = False
 
     # Retieve sentry task factory (since it is an inner function within patch_asyncio)
     sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
@@ -344,6 +346,7 @@ def test_sentry_task_factory_context_with_factory(mock_get_running_loop):
 
     # The original task factory will be mocked out here, let's retrieve the value for later
     orig_task_factory = mock_loop.get_task_factory.return_value
+    orig_task_factory._is_sentry_task_factory = False
 
     # Retieve sentry task factory (since it is an inner function within patch_asyncio)
     sentry_task_factory = get_sentry_task_factory(mock_get_running_loop)
@@ -448,18 +451,27 @@ async def test_delayed_enable_integration_with_options(sentry_init, capture_even
 
 @minimum_python_38
 @pytest.mark.asyncio
-async def test_delayed_enable_enabled_integration(sentry_init):
+async def test_delayed_enable_enabled_integration(sentry_init, uninstall_integration):
+    # Ensure asyncio integration is not already installed from previous tests
+    uninstall_integration("asyncio")
+
     integration = AsyncioIntegration()
     sentry_init(integrations=[integration], traces_sample_rate=1.0)
 
     assert "asyncio" in sentry_sdk.get_client().integrations
 
+    # Get the task factory after initial setup - it should be Sentry's
+    loop = asyncio.get_running_loop()
+    task_factory_before = loop.get_task_factory()
+    assert getattr(task_factory_before, "_is_sentry_task_factory", False) is True
+
     enable_asyncio_integration()
 
     assert "asyncio" in sentry_sdk.get_client().integrations
 
-    # The new asyncio integration should not override the old one
-    assert sentry_sdk.get_client().integrations["asyncio"] == integration
+    # The task factory should be the same (loop not re-patched)
+    task_factory_after = loop.get_task_factory()
+    assert task_factory_before is task_factory_after
 
 
 @minimum_python_38