feat(api): Add enable_integration

Author: sentrivana

sentry_sdk/__init__.py

@@ -24,6 +24,7 @@
     "capture_message",
     "configure_scope",
     "continue_trace",
+    "enable_integration",
     "flush",
     "get_baggage",
     "get_client",

sentry_sdk/api.py

@@ -4,6 +4,7 @@
 
 from sentry_sdk import tracing_utils, Client
 from sentry_sdk._init_implementation import init
+from sentry_sdk.integrations import Integration, _enable_integration
 from sentry_sdk.consts import INSTRUMENTER
 from sentry_sdk.scope import Scope, _ScopeManager, new_scope, isolation_scope
 from sentry_sdk.tracing import NoOpSpan, Transaction, trace
@@ -57,6 +58,7 @@ def overload(x: "T") -> "T":
     "capture_message",
     "configure_scope",
     "continue_trace",
+    "enable_integration",
     "flush",
     "get_baggage",
     "get_client",
@@ -523,3 +525,28 @@ def update_current_span(
 
     if attributes is not None:
         current_span.update_data(attributes)
+
+
+def enable_integration(integration: Integration) -> None:
+    """
+    Enable an additional integration after sentry_sdk.init() has been called.
+
+    This should be used sparingly, only in situations where, for whatever reason,
+    it's not feasible to enable an integration during init().
+
+    Most integrations rely on being enabled before any actual user code is
+    executed, and this function doesn't change that. enable_integration should
+    still be called as early as possible.
+
+    One usecase for enable_integration is setting up the AsyncioIntegration only
+    once the event loop is running, but without having to set up the whole SDK
+    anew.
+
+    :param integration: The integration instance or class to enable.
+    :type integration: sentry_sdk.integrations.Integration
+    """
+    client = get_client()
+    integration = _enable_integration(integration)
+    if integration is None:
+        return
+    client.integrations[integration.identifier] = integration

sentry_sdk/integrations/__init__.py

@@ -2,6 +2,7 @@
 from threading import Lock
 from typing import TYPE_CHECKING
 
+import sentry_sdk
 from sentry_sdk.utils import logger
 
 if TYPE_CHECKING:
@@ -279,6 +280,27 @@ def setup_integrations(
     return integrations
 
 
+def _enable_integration(integration: "Integration") -> None:
+    if integration.identifier in _installed_integrations:
+        return
+
+    client = sentry_sdk.get_client()
+
+    with _installer_lock:
+        logger.debug(
+            "Setting up previously not enabled integration %s", integration.identifier
+        )
+        _processed_integrations.add(integration.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", integration.identifier, e)
+        else:
+            _installed_integrations.add(integration.identifier)
+            return integration
+
+
 def _check_minimum_version(
     integration: "type[Integration]",
     version: "Optional[tuple[int, ...]]",

tests/test_basics.py

@@ -985,6 +985,20 @@ def test_multiple_setup_integrations_calls():
     assert second_call_return == {NoOpIntegration.identifier: NoOpIntegration()}
 
 
+def test_enable_integration(sentry_init):
+    sentry_init()
+
+    client = get_client()
+    assert "asyncio" not in client.integrations
+
+    from sentry_sdk.integrations import AsyncioIntegration
+
+    sentry_sdk.enable_integration(AsyncioIntegration())
+
+    client = get_client()
+    assert "asyncio" in client.integrations
+
+
 class TracingTestClass:
     @staticmethod
     def static(arg):