Merge branch 'master' into ivana/toxgen/move-arq

Author: sentrivana

scripts/populate_tox/config.py

@@ -188,6 +188,7 @@
         "package": "openai-agents",
         "deps": {
             "*": ["pytest-asyncio"],
+            "<=0.2.10": ["openai<1.103.0"],
         },
         "python": ">=3.10",
     },

scripts/populate_tox/populate_tox.py

@@ -73,8 +73,6 @@
     "chalice",
     "gcp",
     "httpx",
-    "langchain",
-    "langchain_notiktoken",
     "pure_eval",
     "quart",
     "ray",

scripts/split_tox_gh_actions/split_tox_gh_actions.py

@@ -17,6 +17,7 @@
 
 import configparser
 import hashlib
+import re
 import sys
 from collections import defaultdict
 from functools import reduce
@@ -25,6 +26,18 @@
 
 from jinja2 import Environment, FileSystemLoader
 
+TOXENV_REGEX = re.compile(
+    r"""
+    {?(?P<py_versions>(py\d+\.\d+,?)+)}?
+    -(?P<framework>[a-z](?:[a-z_]|-(?!v{?\d|latest))*[a-z0-9])
+    (?:-(
+        (v{?(?P<framework_versions>[0-9.]+[0-9a-z,.]*}?))
+        |
+        (?P<framework_versions_latest>latest)
+    ))?
+""",
+    re.VERBOSE,
+)
 
 OUT_DIR = Path(__file__).resolve().parent.parent.parent / ".github" / "workflows"
 TOX_FILE = Path(__file__).resolve().parent.parent.parent / "tox.ini"
@@ -202,29 +215,37 @@ def parse_tox():
     py_versions_pinned = defaultdict(set)
     py_versions_latest = defaultdict(set)
 
+    parsed_correctly = True
+
     for line in lines:
         # normalize lines
         line = line.strip().lower()
 
         try:
             # parse tox environment definition
-            try:
-                (raw_python_versions, framework, framework_versions) = line.split("-")
-            except ValueError:
-                (raw_python_versions, framework) = line.split("-")
-                framework_versions = []
+            parsed = TOXENV_REGEX.match(line)
+            if not parsed:
+                print(f"ERROR reading line {line}")
+                raise ValueError("Failed to parse tox environment definition")
+
+            groups = parsed.groupdict()
+            raw_python_versions = groups["py_versions"]
+            framework = groups["framework"]
+            framework_versions_latest = groups.get("framework_versions_latest") or False
 
             # collect python versions to test the framework in
-            raw_python_versions = set(
-                raw_python_versions.replace("{", "").replace("}", "").split(",")
-            )
-            if "latest" in framework_versions:
+            raw_python_versions = set(raw_python_versions.split(","))
+            if framework_versions_latest:
                 py_versions_latest[framework] |= raw_python_versions
             else:
                 py_versions_pinned[framework] |= raw_python_versions
 
-        except ValueError:
+        except Exception:
             print(f"ERROR reading line {line}")
+            parsed_correctly = False
+
+    if not parsed_correctly:
+        raise RuntimeError("Failed to parse tox.ini")
 
     py_versions_pinned = _normalize_py_versions(py_versions_pinned)
     py_versions_latest = _normalize_py_versions(py_versions_latest)

sentry_sdk/ai/monitoring.py

@@ -10,7 +10,9 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Optional, Callable, Any
+    from typing import Optional, Callable, Awaitable, Any, Union, TypeVar
+
+    F = TypeVar("F", bound=Union[Callable[..., Any], Callable[..., Awaitable[Any]]])
 
 _ai_pipeline_name = ContextVar("ai_pipeline_name", default=None)
 
@@ -26,9 +28,9 @@ def get_ai_pipeline_name():
 
 
 def ai_track(description, **span_kwargs):
-    # type: (str, Any) -> Callable[..., Any]
+    # type: (str, Any) -> Callable[[F], F]
     def decorator(f):
-        # type: (Callable[..., Any]) -> Callable[..., Any]
+        # type: (F) -> F
         def sync_wrapped(*args, **kwargs):
             # type: (Any, Any) -> Any
             curr_pipeline = _ai_pipeline_name.get()
@@ -88,9 +90,9 @@ async def async_wrapped(*args, **kwargs):
                     return res
 
         if inspect.iscoroutinefunction(f):
-            return wraps(f)(async_wrapped)
+            return wraps(f)(async_wrapped)  # type: ignore
         else:
-            return wraps(f)(sync_wrapped)
+            return wraps(f)(sync_wrapped)  # type: ignore
 
     return decorator
 

sentry_sdk/integrations/unraisablehook.py

@@ -0,0 +1,53 @@
+import sys
+
+import sentry_sdk
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    event_from_exception,
+)
+from sentry_sdk.integrations import Integration
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Callable
+    from typing import Any
+
+
+class UnraisablehookIntegration(Integration):
+    identifier = "unraisablehook"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        sys.unraisablehook = _make_unraisable(sys.unraisablehook)
+
+
+def _make_unraisable(old_unraisablehook):
+    # type: (Callable[[sys.UnraisableHookArgs], Any]) -> Callable[[sys.UnraisableHookArgs], Any]
+    def sentry_sdk_unraisablehook(unraisable):
+        # type: (sys.UnraisableHookArgs) -> None
+        integration = sentry_sdk.get_client().get_integration(UnraisablehookIntegration)
+
+        # Note: If  we replace this with ensure_integration_enabled then
+        # we break the exceptiongroup backport;
+        # See: https://github.com/getsentry/sentry-python/issues/3097
+        if integration is None:
+            return old_unraisablehook(unraisable)
+
+        if unraisable.exc_value and unraisable.exc_traceback:
+            with capture_internal_exceptions():
+                event, hint = event_from_exception(
+                    (
+                        unraisable.exc_type,
+                        unraisable.exc_value,
+                        unraisable.exc_traceback,
+                    ),
+                    client_options=sentry_sdk.get_client().options,
+                    mechanism={"type": "unraisablehook", "handled": False},
+                )
+                sentry_sdk.capture_event(event, hint=hint)
+
+        return old_unraisablehook(unraisable)
+
+    return sentry_sdk_unraisablehook

sentry_sdk/profiler/transaction_profiler.py

@@ -45,6 +45,7 @@
 )
 from sentry_sdk.utils import (
     capture_internal_exception,
+    capture_internal_exceptions,
     get_current_thread_meta,
     is_gevent,
     is_valid_sample_rate,
@@ -369,12 +370,13 @@ def __enter__(self):
 
     def __exit__(self, ty, value, tb):
         # type: (Optional[Any], Optional[Any], Optional[Any]) -> None
-        self.stop()
+        with capture_internal_exceptions():
+            self.stop()
 
-        scope, old_profile = self._context_manager_state
-        del self._context_manager_state
+            scope, old_profile = self._context_manager_state
+            del self._context_manager_state
 
-        scope.profile = old_profile
+            scope.profile = old_profile
 
     def write(self, ts, sample):
         # type: (int, ExtractedSample) -> None

sentry_sdk/tracing.py

@@ -8,6 +8,7 @@
 from sentry_sdk.consts import INSTRUMENTER, SPANSTATUS, SPANDATA, SPANTEMPLATE
 from sentry_sdk.profiler.continuous_profiler import get_profiler_id
 from sentry_sdk.utils import (
+    capture_internal_exceptions,
     get_current_thread_meta,
     is_valid_sample_rate,
     logger,
@@ -418,10 +419,11 @@ def __exit__(self, ty, value, tb):
         if value is not None and should_be_treated_as_error(ty, value):
             self.set_status(SPANSTATUS.INTERNAL_ERROR)
 
-        scope, old_span = self._context_manager_state
-        del self._context_manager_state
-        self.finish(scope)
-        scope.span = old_span
+        with capture_internal_exceptions():
+            scope, old_span = self._context_manager_state
+            del self._context_manager_state
+            self.finish(scope)
+            scope.span = old_span
 
     @property
     def containing_transaction(self):

tests/integrations/unraisablehook/test_unraisablehook.py

@@ -0,0 +1,56 @@
+import pytest
+import sys
+import subprocess
+
+from textwrap import dedent
+
+
+TEST_PARAMETERS = [
+    ("", "HttpTransport"),
+    ('_experiments={"transport_http2": True}', "Http2Transport"),
+]
+
+minimum_python_38 = pytest.mark.skipif(
+    sys.version_info < (3, 8),
+    reason="The unraisable exception hook is only available in Python 3.8 and above.",
+)
+
+
+@minimum_python_38
+@pytest.mark.parametrize("options, transport", TEST_PARAMETERS)
+def test_unraisablehook(tmpdir, options, transport):
+    app = tmpdir.join("app.py")
+    app.write(
+        dedent(
+            """
+    from sentry_sdk import init, transport
+    from sentry_sdk.integrations.unraisablehook import UnraisablehookIntegration
+
+    class Undeletable:
+        def __del__(self):
+            1 / 0
+
+    def capture_envelope(self, envelope):
+        print("capture_envelope was called")
+        event = envelope.get_event()
+        if event is not None:
+            print(event)
+
+    transport.{transport}.capture_envelope = capture_envelope
+
+    init("http://foobar@localhost/123", integrations=[UnraisablehookIntegration()], {options})
+
+    undeletable = Undeletable()
+    del undeletable
+    """.format(
+                transport=transport, options=options
+            )
+        )
+    )
+
+    output = subprocess.check_output(
+        [sys.executable, str(app)], stderr=subprocess.STDOUT
+    )
+
+    assert b"ZeroDivisionError" in output
+    assert b"capture_envelope was called" in output

tests/test_basics.py

@@ -870,6 +870,7 @@ def foo(event, hint):
         (["celery"], "sentry.python"),
         (["dedupe"], "sentry.python"),
         (["excepthook"], "sentry.python"),
+        (["unraisablehook"], "sentry.python"),
         (["executing"], "sentry.python"),
         (["modules"], "sentry.python"),
         (["pure_eval"], "sentry.python"),