sentry-sdk 2.35.1__tar.gz → 2.36.0__tar.gz

{sentry_sdk-2.35.1/sentry_sdk.egg-info → sentry_sdk-2.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.35.1
+Version: 2.36.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/ai/monitoring.py

@@ -10,7 +10,9 @@ from sentry_sdk.utils import ContextVar
 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 @@ def ai_track(description, **span_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-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/consts.py

@@ -1329,4 +1329,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.35.1"
+VERSION = "2.36.0"

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/integrations/__init__.py

@@ -141,7 +141,7 @@ _MIN_VERSIONS = {
     "graphene": (3, 3),
     "grpc": (1, 32, 0),  # grpcio
     "huggingface_hub": (0, 22),
-    "langchain": (0, 0, 210),
+    "langchain": (0, 1, 0),
     "launchdarkly": (9, 8, 0),
     "loguru": (0, 7, 0),
     "openai": (1, 0, 0),

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/integrations/logging.py

@@ -356,12 +356,14 @@ class SentryLogsHandler(_BaseHandler):
             record.levelno, SEVERITY_TO_OTEL_SEVERITY
         )
         project_root = client.options["project_root"]
+
         attrs = self._extra_from_record(record)  # type: Any
         attrs["sentry.origin"] = "auto.logger.log"
-        if isinstance(record.msg, str):
-            attrs["sentry.message.template"] = record.msg
+
+        parameters_set = False
         if record.args is not None:
             if isinstance(record.args, tuple):
+                parameters_set = bool(record.args)
                 for i, arg in enumerate(record.args):
                     attrs[f"sentry.message.parameter.{i}"] = (
                         arg
@@ -369,19 +371,28 @@ class SentryLogsHandler(_BaseHandler):
                         else safe_repr(arg)
                     )
             elif isinstance(record.args, dict):
+                parameters_set = bool(record.args)
                 for key, value in record.args.items():
                     attrs[f"sentry.message.parameter.{key}"] = (
                         value
                         if isinstance(value, (str, float, int, bool))
                         else safe_repr(value)
                     )
+
+        if parameters_set and isinstance(record.msg, str):
+            # only include template if there is at least one
+            # sentry.message.parameter.X set
+            attrs["sentry.message.template"] = record.msg
+
         if record.lineno:
             attrs["code.line.number"] = record.lineno
+
         if record.pathname:
             if project_root is not None and record.pathname.startswith(project_root):
                 attrs["code.file.path"] = record.pathname[len(project_root) + 1 :]
             else:
                 attrs["code.file.path"] = record.pathname
+
         if record.funcName:
             attrs["code.function.name"] = record.funcName
 

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/integrations/openai.py

@@ -78,12 +78,12 @@ class OpenAIIntegration(Integration):
         return 0
 
 
-def _capture_exception(exc):
-    # type: (Any) -> None
+def _capture_exception(exc, manual_span_cleanup=True):
+    # type: (Any, bool) -> None
     # Close an eventually open span
     # We need to do this by hand because we are not using the start_span context manager
     current_span = sentry_sdk.get_current_span()
-    if current_span is not None:
+    if manual_span_cleanup and current_span is not None:
         current_span.__exit__(None, None, None)
 
     event, hint = event_from_exception(
@@ -516,7 +516,7 @@ def _wrap_embeddings_create(f):
             try:
                 result = f(*args, **kwargs)
             except Exception as e:
-                _capture_exception(e)
+                _capture_exception(e, manual_span_cleanup=False)
                 raise e from None
 
             return gen.send(result)
@@ -550,7 +550,7 @@ def _wrap_async_embeddings_create(f):
             try:
                 result = await f(*args, **kwargs)
             except Exception as e:
-                _capture_exception(e)
+                _capture_exception(e, manual_span_cleanup=False)
                 raise e from None
 
             return gen.send(result)

sentry_sdk-2.36.0/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-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/logger.py

@@ -22,13 +22,14 @@ def _capture_log(severity_text, severity_number, template, **kwargs):
     # type: (str, int, str, **Any) -> None
     client = get_client()
 
-    attrs = {
-        "sentry.message.template": template,
-    }  # type: dict[str, str | bool | float | int]
+    attrs = {}  # type: dict[str, str | bool | float | int]
     if "attributes" in kwargs:
         attrs.update(kwargs.pop("attributes"))
     for k, v in kwargs.items():
         attrs[f"sentry.message.parameter.{k}"] = v
+    if kwargs:
+        # only attach template if there are parameters
+        attrs["sentry.message.template"] = template
 
     attrs = {
         k: (

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/profiler/transaction_profiler.py

@@ -45,6 +45,7 @@ from sentry_sdk.profiler.utils import (
 )
 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 @@ class Profile:
 
     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-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk/tracing.py

@@ -8,6 +8,7 @@ import sentry_sdk
 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 @@ class Span:
         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):

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0/sentry_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.35.1
+Version: 2.36.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/sentry_sdk.egg-info/SOURCES.txt

@@ -113,6 +113,7 @@ sentry_sdk/integrations/tornado.py
 sentry_sdk/integrations/trytond.py
 sentry_sdk/integrations/typer.py
 sentry_sdk/integrations/unleash.py
+sentry_sdk/integrations/unraisablehook.py
 sentry_sdk/integrations/wsgi.py
 sentry_sdk/integrations/celery/__init__.py
 sentry_sdk/integrations/celery/beat.py

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/setup.py

@@ -21,7 +21,7 @@ def get_file_text(file_name):
 
 setup(
     name="sentry-sdk",
-    version="2.35.1",
+    version="2.36.0",
     author="Sentry Team and Contributors",
     author_email="hello@sentry.io",
     url="https://github.com/getsentry/sentry-python",

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/tests/test_basics.py

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

{sentry_sdk-2.35.1 → sentry_sdk-2.36.0}/tests/test_logs.py

@@ -254,30 +254,54 @@ def test_logs_message_params(sentry_init, capture_envelopes):
     sentry_sdk.logger.error(
         "The recorded error was '{error}'", error=Exception("some error")
     )
+    sentry_sdk.logger.warning("The recorded value was hardcoded.")
 
     get_client().flush()
     logs = envelopes_to_logs(envelopes)
 
     assert logs[0]["body"] == "The recorded value was '1'"
     assert logs[0]["attributes"]["sentry.message.parameter.int_var"] == 1
+    assert (
+        logs[0]["attributes"]["sentry.message.template"]
+        == "The recorded value was '{int_var}'"
+    )
 
     assert logs[1]["body"] == "The recorded value was '2.0'"
     assert logs[1]["attributes"]["sentry.message.parameter.float_var"] == 2.0
+    assert (
+        logs[1]["attributes"]["sentry.message.template"]
+        == "The recorded value was '{float_var}'"
+    )
 
     assert logs[2]["body"] == "The recorded value was 'False'"
     assert logs[2]["attributes"]["sentry.message.parameter.bool_var"] is False
+    assert (
+        logs[2]["attributes"]["sentry.message.template"]
+        == "The recorded value was '{bool_var}'"
+    )
 
     assert logs[3]["body"] == "The recorded value was 'some string value'"
     assert (
         logs[3]["attributes"]["sentry.message.parameter.string_var"]
         == "some string value"
     )
+    assert (
+        logs[3]["attributes"]["sentry.message.template"]
+        == "The recorded value was '{string_var}'"
+    )
 
     assert logs[4]["body"] == "The recorded error was 'some error'"
     assert (
         logs[4]["attributes"]["sentry.message.parameter.error"]
         == "Exception('some error')"
     )
+    assert (
+        logs[4]["attributes"]["sentry.message.template"]
+        == "The recorded error was '{error}'"
+    )
+
+    assert logs[5]["body"] == "The recorded value was hardcoded."
+    assert "sentry.message.template" not in logs[5]["attributes"]
 
 
 @minimum_python_37