Skip to content
Draft
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions sentry_sdk/consts.py
Original file line number Diff line number Diff line change
Expand Up @@ -91,6 +91,7 @@ class CompressionAlgo(Enum):
],
"suppress_asgi_chained_exceptions": Optional[bool],
"data_collection": Optional[DataCollectionUserOptions],
"deferred_auto_enabling_integrations": Optional[bool],
},
total=False,
)
Expand Down
179 changes: 172 additions & 7 deletions sentry_sdk/integrations/__init__.py
Original file line number Diff line number Diff line change
@@ -1,14 +1,37 @@
import importlib.util
import sys
from abc import ABC, abstractmethod
from importlib import import_module
from importlib.abc import Loader, MetaPathFinder
from itertools import zip_longest
from threading import Lock
from threading import Lock, local
from typing import TYPE_CHECKING

from sentry_sdk.utils import logger
import sentry_sdk
from sentry_sdk.utils import capture_internal_exceptions, logger

if TYPE_CHECKING:
from collections.abc import Sequence
from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Type, Union
from collections.abc import Container, Sequence
from importlib.machinery import ModuleSpec
from types import ModuleType
from typing import (
Any,
Dict,
Iterator,
List,
Optional,
Protocol,
Set,
Type,
Union,
)

class _DefaultIntegrationsIterator(Protocol):
def __call__(
self,
with_auto_enabling_integrations: bool,
exclude: "Container[str]" = (),
) -> "Iterator[Type[Integration]]": ...


_DEFAULT_FAILED_REQUEST_STATUS_CODES = frozenset(range(500, 600))
Expand All @@ -22,13 +45,20 @@
# Set of all integration identifiers we have actually installed
_installed_integrations: "Set[str]" = set()

# Trigger module -> import string of the deferred integration waiting for the
# application to import the trigger module
_pending_deferred_integrations: "Dict[str, str]" = {}

_deferred_setup_finder_guard = local()


def _generate_default_integrations_iterator(
integrations: "List[str]",
auto_enabling_integrations: "List[str]",
) -> "Callable[[bool], Iterator[Type[Integration]]]":
) -> "_DefaultIntegrationsIterator":
def iter_default_integrations(
with_auto_enabling_integrations: bool,
exclude: "Container[str]" = (),
) -> "Iterator[Type[Integration]]":
"""Returns an iterator of the default integration classes:"""
if with_auto_enabling_integrations:
Expand All @@ -37,6 +67,8 @@ def iter_default_integrations(
all_import_strings = integrations

for import_string in all_import_strings:
if import_string in exclude:
continue
try:
module, cls = import_string.rsplit(".", 1)
yield getattr(import_module(module), cls)
Expand Down Expand Up @@ -108,6 +140,13 @@ def iter_default_integrations(
"sentry_sdk.integrations.tornado.TornadoIntegration",
]

# With the `deferred_auto_enabling_integrations` experiment on, these auto-enabling
# integrations are only set up once the application imports the trigger module.
# This can't live on the integration class, since loading the class imports the library.
_DEFERRED_INTEGRATION_TRIGGERS = {
"sentry_sdk.integrations.openai.OpenAIIntegration": "openai",
}

iter_default_integrations = _generate_default_integrations_iterator(
integrations=_DEFAULT_INTEGRATIONS,
auto_enabling_integrations=_AUTO_ENABLING_INTEGRATIONS,
Expand Down Expand Up @@ -210,6 +249,29 @@ def setup_integrations(

logger.debug("Setting up integrations (with default = %s)", with_defaults)

# Identifier -> import string of deferred integrations whose library is installed
deferred: "Dict[str, str]" = {}
# Deferred integrations, plus those whose library isn't installed
excluded: "Set[str]" = set()
if (
with_defaults
and with_auto_enabling_integrations
and options is not None
and options["_experiments"].get("deferred_auto_enabling_integrations")
):
for import_string, trigger in _DEFERRED_INTEGRATION_TRIGGERS.items():
if trigger in sys.modules:
continue
try:
spec = importlib.util.find_spec(trigger)
except Exception:
spec = None
if spec is None:
excluded.add(import_string)
elif hasattr(spec.loader, "exec_module"):
excluded.add(import_string)
deferred[import_string.rsplit(".", 2)[1]] = import_string

user_provided_integrations = set(integrations.keys())

# Integrations that will not be enabled
Expand All @@ -223,7 +285,7 @@ def setup_integrations(

if with_defaults:
for integration_cls in iter_default_integrations(
with_auto_enabling_integrations
with_auto_enabling_integrations, exclude=excluded
):
if integration_cls.identifier not in integrations:
instance = integration_cls()
Expand All @@ -233,6 +295,7 @@ def setup_integrations(
disabled_integration_identifiers = {
integration.identifier for integration in disabled_integrations
}
deactivated_identifiers = set()

for integration, targets_to_deactivate in _INTEGRATION_DEACTIVATES.items():
if (
Expand All @@ -241,7 +304,8 @@ def setup_integrations(
):
for target in targets_to_deactivate:
if target not in user_provided_integrations:
for cls in iter_default_integrations(True):
deactivated_identifiers.add(target)
for cls in iter_default_integrations(True, exclude=excluded):
if cls.identifier == target:
if cls not in disabled_integrations:
disabled_integrations.append(cls)
Expand Down Expand Up @@ -275,6 +339,28 @@ def setup_integrations(

_processed_integrations.add(identifier)

for identifier, import_string in deferred.items():
if (
identifier in disabled_integration_identifiers
or identifier in deactivated_identifiers
):
continue

trigger = _DEFERRED_INTEGRATION_TRIGGERS[import_string]
with _installer_lock:
if identifier in _processed_integrations:
continue
_processed_integrations.add(identifier)
_pending_deferred_integrations[trigger] = import_string
if _deferred_setup_finder not in sys.meta_path:
sys.meta_path.insert(0, _deferred_setup_finder)

logger.debug(
"Deferring setup of integration %s until %s is imported",
identifier,
trigger,
)

integrations = {
identifier: integration
for identifier, integration in integrations.items()
Expand All @@ -287,6 +373,85 @@ def setup_integrations(
return integrations


def _set_up_deferred_integration(trigger: str) -> None:
import_string = _pending_deferred_integrations.pop(trigger, None)
if import_string is None:
return

with capture_internal_exceptions():
client = sentry_sdk.get_client()
module, cls = import_string.rsplit(".", 1)
try:
integration = getattr(import_module(module), cls)()
type(integration).setup_once()
integration.setup_once_with_options(client.options)
except DidNotEnable as e:
logger.debug("Did not enable default integration %s: %s", import_string, e)
return

_installed_integrations.add(integration.identifier)
client.integrations[integration.identifier] = integration
logger.debug("Enabling integration %s", integration.identifier)


class _DeferredSetupLoader(Loader):
def __init__(self, loader: "Any", trigger: str) -> None:
self._loader = loader
self._trigger = trigger

def create_module(self, spec: "ModuleSpec") -> "Optional[ModuleType]":
return self._loader.create_module(spec)

def exec_module(self, module: "ModuleType") -> None:
self._loader.exec_module(module)
module.__loader__ = self._loader
if module.__spec__ is not None:
module.__spec__.loader = self._loader
_set_up_deferred_integration(self._trigger)

def __getattr__(self, name: str) -> "Any":
return getattr(self._loader, name)


class _DeferredSetupFinder(MetaPathFinder):
def find_spec(
self,
fullname: str,
path: "Optional[Sequence[str]]" = None,
target: "Optional[ModuleType]" = None,
) -> "Optional[ModuleSpec]":
if fullname not in _pending_deferred_integrations or getattr(
_deferred_setup_finder_guard, "active", False
):
return None

_deferred_setup_finder_guard.active = True
try:
for finder in sys.meta_path:
if finder is self or not hasattr(finder, "find_spec"):
continue
spec = finder.find_spec(fullname, path, target)
if spec is not None:
break
else:
return None
finally:
_deferred_setup_finder_guard.active = False

if hasattr(spec.loader, "exec_module"):
spec.loader = _DeferredSetupLoader(spec.loader, fullname)
else:
_pending_deferred_integrations.pop(fullname, None)
logger.debug(
"Not setting up deferred integration for %s: its loader has no exec_module",
fullname,
)
return spec


_deferred_setup_finder = _DeferredSetupFinder()


def _check_minimum_version(
integration: "type[Integration]",
version: "Optional[tuple[int, ...]]",
Expand Down
59 changes: 59 additions & 0 deletions tests/integrations/openai/test_openai.py
Original file line number Diff line number Diff line change
@@ -1,4 +1,8 @@
import json
import os
import subprocess
import sys
from textwrap import dedent

import pytest

Expand Down Expand Up @@ -8271,3 +8275,58 @@ async def test_streaming_responses_api_ttft_async(

assert isinstance(ttft, float)
assert ttft > 0


def test_deferred_setup_on_import(tmp_path):
app = tmp_path / "app.py"
app.write_text(
dedent(
"""
import json
import sys

import sentry_sdk

events = []

def before_send(event, hint):
events.append(event)
return None

sentry_sdk.init(
before_send=before_send,
_experiments={"deferred_auto_enabling_integrations": True},
)
imported_during_init = "openai" in sys.modules

from openai.resources.chat.completions import Completions

sentry_sdk.capture_message("hi")

print(json.dumps({
"imported_during_init": imported_during_init,
"integration_enabled": sentry_sdk.get_client().get_integration("openai") is not None,
"patched_by": Completions.create.__code__.co_filename,
"sdk_integrations": events[0]["sdk"]["integrations"],
}))
"""
)
)

output = subprocess.check_output([sys.executable, str(app)])
result = json.loads(output)

assert result["imported_during_init"] is False
assert result["integration_enabled"] is True
assert result["patched_by"].endswith(
os.path.join("sentry_sdk", "integrations", "openai.py")
)
assert "openai" in result["sdk_integrations"]


def test_deferred_setup_when_already_imported(sentry_init):
sentry_init(_experiments={"deferred_auto_enabling_integrations": True})

assert isinstance(
sentry_sdk.get_client().get_integration(OpenAIIntegration), OpenAIIntegration
)
10 changes: 10 additions & 0 deletions tests/test_basics.py
Original file line number Diff line number Diff line change
Expand Up @@ -112,6 +112,16 @@ def test_auto_enabling_integrations_catches_import_error(sentry_init, caplog):
), "Problem with checking auto enabling {}".format(import_string)


def test_deferred_auto_enabling_integrations_library_not_installed(sentry_init):
if importlib.util.find_spec("openai") is not None:
pytest.skip("openai is installed")

meta_path = list(sys.meta_path)
sentry_init(_experiments={"deferred_auto_enabling_integrations": True})

assert sys.meta_path == meta_path


def test_generic_mechanism(sentry_init, capture_events):
sentry_init()
events = capture_events()
Expand Down
Loading