sentry-sdk 2.68.0__tar.gz → 2.69.0__tar.gz

{sentry_sdk-2.68.0/sentry_sdk.egg-info → sentry_sdk-2.69.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.68.0
+Version: 2.69.0
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/pyproject.toml

@@ -74,6 +74,12 @@ typing = [
     "pydantic-ai-slim>=2.23.0",
     "langchain-core>=1.5.3",
     "huggingface-hub>=1.26.1",
+    "anthropic>=1.2.0",
+    "google-genai>=2.21.0",
+    "openai>=3.7.0",
+    "tiktoken>=0.14.0",
+    "aiohttp>=3.14.3",
+    "openai-agents>=0.22.0",
 ]
 test = [
     "dataclasses ; python_full_version < '3.7'",

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/_batcher.py

@@ -6,7 +6,7 @@ from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Generic, TypeVar
 
 from sentry_sdk.envelope import Envelope, Item, PayloadRef
-from sentry_sdk.utils import format_timestamp
+from sentry_sdk.utils import capture_internal_exceptions, format_timestamp
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Optional
@@ -100,7 +100,13 @@ class Batcher(Generic[T]):
         while self._running:
             self._flush_event.wait(self.FLUSH_WAIT_TIME + random.random())
             self._flush_event.clear()
-            self._flush()
+            # A failure to serialize or send one batch must not kill the
+            # flusher thread. If it did, the buffer would keep filling with
+            # nothing draining it, and every later log or metric would be
+            # dropped for the rest of the process lifetime. Swallow and log
+            # the error instead so the loop keeps running.
+            with capture_internal_exceptions():
+                self._flush()
 
     def add(self, item: "T") -> None:
         # Bail out if the current thread is already executing batcher code.

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/_span_batcher.py

@@ -9,7 +9,11 @@ from typing import TYPE_CHECKING
 
 from sentry_sdk._batcher import Batcher
 from sentry_sdk.envelope import Envelope, Item, PayloadRef
-from sentry_sdk.utils import format_timestamp, serialize_attribute
+from sentry_sdk.utils import (
+    capture_internal_exceptions,
+    format_timestamp,
+    serialize_attribute,
+)
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Optional
@@ -91,14 +95,19 @@ class SpanBatcher(Batcher["SpanJSON"]):
             self._flush_event.wait(timeout=self.FLUSH_WAIT_TIME + jitter)
             self._flush_event.clear()
 
-            self._flush(only_pending=True)
+            # A failure in one flush must not kill the flusher thread, or the
+            # span buffer would keep filling with nothing draining it and every
+            # later span would be dropped for the rest of the process lifetime.
+            # Swallow and log the error instead so the loop keeps running.
+            with capture_internal_exceptions():
+                self._flush(only_pending=True)
 
-            if (
-                time.monotonic() - self._last_full_flush
-                >= self.FLUSH_WAIT_TIME + jitter
-            ):
-                self._flush()
-                self._last_full_flush = time.monotonic()
+                if (
+                    time.monotonic() - self._last_full_flush
+                    >= self.FLUSH_WAIT_TIME + jitter
+                ):
+                    self._flush()
+                    self._last_full_flush = time.monotonic()
 
     def add(self, span: "SpanJSON") -> None:
         # Bail out if the current thread is already executing batcher code.

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/_types.py

@@ -188,7 +188,7 @@ if TYPE_CHECKING:
         gen_ai: "GenAICollectionUserOptions"
         database_query_data: bool
         queues: bool
-        stack_frame_variables: bool
+        stack_frame_variables: "Union[bool, KeyValueCollectionBehaviour]"
         frame_context_lines: int
 
     class DataCollection(TypedDict):
@@ -202,7 +202,7 @@ if TYPE_CHECKING:
         gen_ai: "GenAICollectionBehaviour"
         database_query_data: bool
         queues: bool
-        stack_frame_variables: bool
+        stack_frame_variables: "Union[bool, KeyValueCollectionBehaviour]"
         frame_context_lines: int
 
     # "critical" is an alias of "fatal" recognized by Relay

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/ai/_openai_completions_api.py

@@ -1,11 +1,13 @@
 from collections.abc import Iterable
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
-    from typing import Union
+    from typing import TypeGuard, Union
 
     from openai.types.chat import (
         ChatCompletionContentPartParam,
+        ChatCompletionContentPartRefusalParam,
+        ChatCompletionContentPartTextParam,
         ChatCompletionMessageParam,
         ChatCompletionSystemMessageParam,
         ChatCompletionToolUnionParam,
@@ -14,13 +16,15 @@ if TYPE_CHECKING:
     from sentry_sdk._types import TextPart, ToolDefinition
 
 
-def _is_system_instruction(message: "ChatCompletionMessageParam") -> bool:
+def _is_system_instruction(
+    message: "ChatCompletionMessageParam",
+) -> "TypeGuard[ChatCompletionSystemMessageParam]":
     return isinstance(message, dict) and message.get("role") == "system"
 
 
 def _get_system_instructions(
     messages: "Iterable[ChatCompletionMessageParam]",
-) -> "list[ChatCompletionMessageParam]":
+) -> "list[ChatCompletionSystemMessageParam]":
     if not isinstance(messages, Iterable):
         return []
 
@@ -28,7 +32,7 @@ def _get_system_instructions(
 
 
 def _get_text_items(
-    content: "Union[str, Iterable[ChatCompletionContentPartParam]]",
+    content: "Union[str, Iterable[Union[ChatCompletionContentPartParam, ChatCompletionContentPartTextParam, ChatCompletionContentPartRefusalParam]]]",
 ) -> "list[str]":
     if isinstance(content, str):
         return [content]
@@ -36,10 +40,10 @@ def _get_text_items(
     if not isinstance(content, Iterable):
         return []
 
-    text_items = []
+    text_items: "list[str]" = []
     for part in content:
         if isinstance(part, dict) and part.get("type") == "text":
-            text = part.get("text", None)
+            text = cast("ChatCompletionContentPartTextParam", part).get("text", None)
             if text is not None:
                 text_items.append(text)
 

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/ai/_openai_responses_api.py

@@ -1,18 +1,23 @@
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING, Iterable, cast
 
 if TYPE_CHECKING:
-    from typing import Iterable, Union
+    from typing import Iterable, TypeGuard, Union
 
     from openai.types.responses import (
         ResponseInputItemParam,
         ResponseInputParam,
+        ResponseInputTextParam,
         ToolParam,
     )
+    from openai.types.responses.easy_input_message_param import EasyInputMessageParam
+    from openai.types.responses.response_input_item_param import Message
 
-    from sentry_sdk._types import ToolDefinition
+    from sentry_sdk._types import TextPart, ToolDefinition
 
 
-def _is_system_instruction(message: "ResponseInputItemParam") -> bool:
+def _is_system_instruction(
+    message: "ResponseInputItemParam",
+) -> "TypeGuard[Union[EasyInputMessageParam, Message]]":
     if not isinstance(message, dict) or not message.get("role") == "system":
         return False
 
@@ -21,13 +26,44 @@ def _is_system_instruction(message: "ResponseInputItemParam") -> bool:
 
 def _get_system_instructions(
     messages: "Union[str, ResponseInputParam]",
-) -> "list[ResponseInputItemParam]":
+) -> "list[Union[EasyInputMessageParam, Message]]":
     if not isinstance(messages, list):
         return []
 
     return [message for message in messages if _is_system_instruction(message)]
 
 
+def _transform_system_instructions(
+    system_instructions: "list[Union[EasyInputMessageParam, Message]]",
+) -> "list[TextPart]":
+    instruction_text_parts: "list[TextPart]" = []
+
+    for instruction in system_instructions:
+        if not isinstance(instruction, dict):
+            continue
+
+        content = instruction.get("content")
+        if content is None:
+            continue
+
+        if isinstance(content, str):
+            instruction_text_parts.append({"type": "text", "content": content})
+            continue
+
+        if not isinstance(content, Iterable):
+            continue
+
+        for part in content:
+            if not isinstance(part, dict) or part.get("type") != "input_text":
+                continue
+
+            text = cast("ResponseInputTextParam", part).get("text", None)
+            if text is not None:
+                instruction_text_parts.append({"type": "text", "content": text})
+
+    return instruction_text_parts
+
+
 def _transform_tool_definitions(tools: "Iterable[ToolParam]") -> "list[ToolDefinition]":
     """
     Transform tool definitions to the schema used by the "gen_ai.tool.definitions" attribute.

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/client.py

@@ -648,13 +648,6 @@ class _Client(BaseClient):
 
             self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
 
-            if self.options.get("enable_logs", False) or self.options[
-                "_experiments"
-            ].get("enable_logs", False):
-                logger.warning(
-                    "The enable_logs option has no effect and will be removed in the next major."
-                )
-
             self.log_batcher = LogBatcher(
                 capture_func=_capture_envelope,
                 record_lost_func=_record_lost_event,

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/consts.py

@@ -878,6 +878,12 @@ class SPANDATA:
     Example: GET
     """
 
+    HTTP_ROUTE = "http.route"
+    """
+    The matched route, that is, the path template used to match the request.
+    Example: /users/{id}
+    """
+
     HTTP_QUERY = "http.query"
     """
     The Query string present in the URL.
@@ -1840,4 +1846,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "2.68.0"
+VERSION = "2.69.0"

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/data_collection.py

@@ -23,14 +23,12 @@ Resolution precedence (see :func:`_resolve_data_collection`):
 """
 
 import warnings
-from typing import TYPE_CHECKING, List, Mapping, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Union, cast
 from urllib.parse import parse_qs, urlencode
 
 from sentry_sdk._types import SENSITIVE_DATA_SUBSTITUTE
 
 if TYPE_CHECKING:
-    from typing import Any, Dict
-
     from sentry_sdk._types import (
         DataCollection,
         GenAICollectionBehaviour,
@@ -41,11 +39,12 @@ if TYPE_CHECKING:
 
 # ``http_bodies`` defaults to this (collect everything the
 # platform supports); an empty list is the explicit opt-out.
-# response bodyies are not included here because we don't
-# currently capture them (as of Jul 7 2026)
+# ``incoming_response`` is not included here because we don't
+# currently capture incoming response bodies.
 _ALL_HTTP_BODY_TYPES = [
     "incoming_request",
     "outgoing_request",
+    "outgoing_response",
 ]
 
 # Default number of source lines captured above and below a stack frame.
@@ -190,29 +189,31 @@ def _map_from_send_default_pii(
 
 def _resolve_explicit(
     d: "dict[str, Any]",
-    include_local_variables: bool,
-    include_source_context: bool,
 ) -> "DataCollection":
     """
     Build a fully-resolved ``DataCollection`` from a user-supplied
     ``data_collection`` dict, filling in spec defaults for any omitted or
-    partially-specified field. Frame fields fall back to the legacy
-    ``include_local_variables`` / ``include_source_context`` options when unset.
+    partially-specified field.
     """
-    # frame_context_lines accepts an integer or a boolean fallback (spec: True
-    # -> platform default of 5, False -> 0). bool is a subclass of int, so
-    # coerce explicitly before treating it as a line count.
     frame_context_lines = d.get("frame_context_lines")
     if frame_context_lines is None:
-        frame_context_lines = (
-            _DEFAULT_FRAME_CONTEXT_LINES if include_source_context else 0
-        )
+        frame_context_lines = _DEFAULT_FRAME_CONTEXT_LINES
     elif isinstance(frame_context_lines, bool):
         frame_context_lines = _DEFAULT_FRAME_CONTEXT_LINES if frame_context_lines else 0
+    else:
+        if not isinstance(frame_context_lines, int) or frame_context_lines < 0:
+            raise ValueError(
+                "Invalid `frame_context_lines` value: Must be 0 or greater."
+            )
 
-    stack_frame_variables = d.get("stack_frame_variables")
-    if stack_frame_variables is None:
-        stack_frame_variables = include_local_variables
+    raw_stack_frame_variables = d.get("stack_frame_variables", True)
+    stack_frame_variables: "Union[bool, KeyValueCollectionBehaviour]"
+
+    stack_frame_variables = (
+        _kvcb_from_value(raw_stack_frame_variables)
+        if isinstance(raw_stack_frame_variables, dict)
+        else bool(raw_stack_frame_variables)
+    )
 
     # http_bodies: omitted means "all valid types"; [] is the explicit opt-out.
     http_bodies = d.get("http_bodies")
@@ -323,8 +324,6 @@ def _resolve_data_collection(options: "Dict[str, Any]") -> "DataCollection":
             )
         return _resolve_explicit(
             user_dc,
-            include_local_variables,
-            include_source_context,
         )
 
     return _map_from_send_default_pii(

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/integrations/__init__.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from itertools import zip_longest
 from threading import Lock
 from typing import TYPE_CHECKING
 
@@ -299,10 +300,17 @@ def _check_minimum_version(
     if min_version is None:
         return
 
-    if version < min_version:
-        raise DidNotEnable(
-            f"Integration only supports {package} {'.'.join(map(str, min_version))} or newer."
-        )
+    # We can't use normal tuple comparison here because the version tuples might
+    # not have the same length, in which case they wouldn't compare as expected.
+    for v, min in zip_longest(version, min_version, fillvalue=0):
+        if v == min:
+            continue
+        elif v < min:
+            raise DidNotEnable(
+                f"Integration only supports {package} {'.'.join(map(str, min_version))} or newer."
+            )
+        elif v > min:
+            return
 
 
 class DidNotEnable(Exception):  # noqa: N818

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/integrations/_wsgi_common.py

@@ -89,6 +89,10 @@ class RequestExtractor:
         content_length = self.content_length()
         request_info = event.get("request", {})
 
+        # Prior to data collection being implemented we unconditionally attached
+        # the request body, which is why we default to True here.
+        attach_request_body = True
+
         if has_data_collection_enabled(client.options):
             cookies = _apply_key_value_collection_filtering(
                 items=dict(self.cookies()),
@@ -96,31 +100,36 @@ class RequestExtractor:
             )
             if cookies:
                 request_info["cookies"] = cookies
+
+            attach_request_body = (
+                "incoming_request" in client.options["data_collection"]["http_bodies"]
+            )
         elif should_send_default_pii():
             request_info["cookies"] = dict(self.cookies())
 
-        if not request_body_within_bounds(client, content_length):
-            data = AnnotatedValue.removed_because_over_size_limit()
-        else:
-            # First read the raw body data
-            # It is important to read this first because if it is Django
-            # it will cache the body and then we can read the cached version
-            # again in parsed_body() (or json() or wherever).
-            raw_data = None
-            try:
-                raw_data = self.raw_data()
-            except _RAW_DATA_EXCEPTIONS:
-                # If DjangoRestFramework is used it already read the body for us
-                # so reading it here will fail. We can ignore this.
-                pass
-
-            parsed_body = self.parsed_body()
-            if parsed_body is not None:
-                data = parsed_body
-            elif raw_data:
-                data = AnnotatedValue.removed_because_raw_data()
+        if attach_request_body:
+            if not request_body_within_bounds(client, content_length):
+                data = AnnotatedValue.removed_because_over_size_limit()
             else:
-                data = None
+                # First read the raw body data
+                # It is important to read this first because if it is Django
+                # it will cache the body and then we can read the cached version
+                # again in parsed_body() (or json() or wherever).
+                raw_data = None
+                try:
+                    raw_data = self.raw_data()
+                except _RAW_DATA_EXCEPTIONS:
+                    # If DjangoRestFramework is used it already read the body for us
+                    # so reading it here will fail. We can ignore this.
+                    pass
+
+                parsed_body = self.parsed_body()
+                if parsed_body is not None:
+                    data = parsed_body
+                elif raw_data:
+                    data = AnnotatedValue.removed_because_raw_data()
+                else:
+                    data = None
 
         if data is not None:
             request_info["data"] = data

{sentry_sdk-2.68.0 → sentry_sdk-2.69.0}/sentry_sdk/integrations/aiohttp.py

@@ -21,9 +21,6 @@ from sentry_sdk.integrations._wsgi_common import (
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.scope import Scope, should_send_default_pii
 from sentry_sdk.sessions import track_session
-from sentry_sdk.traces import (
-    SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE,
-)
 from sentry_sdk.traces import (
     NoOpStreamedSpan,
     SegmentNameSource,
@@ -236,6 +233,7 @@ class AioHttpIntegration(Integration):
                             },
                             parent_span=None,
                         )
+                        scope.get_current_scope()._server_segment_span = span_ctx
                     else:
                         transaction = continue_trace(
                             headers,
@@ -312,7 +310,7 @@ class AioHttpIntegration(Integration):
 
                         return response
 
-        Application._handle = sentry_app_handle
+        Application._handle = sentry_app_handle  # type: ignore[method-assign]
 
         old_urldispatcher_resolve = UrlDispatcher.resolve
 
@@ -326,38 +324,33 @@ class AioHttpIntegration(Integration):
             if integration is None:
                 return rv
 
+            route_info = rv.get_info()
+            pattern = route_info.get("path") or route_info.get("formatter")
+
+            server_span = sentry_sdk.get_current_scope()._server_segment_span
+            if server_span is not None and pattern is not None:
+                server_span.set_attribute(SPANDATA.HTTP_ROUTE, pattern)
+
             name = None
 
             try:
                 if integration.transaction_style == "handler_name":
                     name = transaction_from_function(rv.handler)
                 elif integration.transaction_style == "method_and_path_pattern":
-                    route_info = rv.get_info()
-                    pattern = route_info.get("path") or route_info.get("formatter")
                     name = "{} {}".format(request.method, pattern)
             except Exception:
                 pass
 
             if name is not None:
-                current_span = sentry_sdk.get_current_span()
-                if isinstance(current_span, StreamedSpan) and not isinstance(
-                    current_span, NoOpStreamedSpan
-                ):
-                    current_span._segment.name = name
-                    current_span._segment.set_attribute(
-                        "sentry.segment.name.source",
-                        SEGMENT_SOURCE_FOR_STYLE[integration.transaction_style].value,
-                    )
-                else:
-                    current_scope = sentry_sdk.get_current_scope()
-                    current_scope.set_transaction_name(
-                        name,
-                        source=SOURCE_FOR_STYLE[integration.transaction_style],
-                    )
+                current_scope = sentry_sdk.get_current_scope()
+                current_scope.set_transaction_name(
+                    name,
+                    source=SOURCE_FOR_STYLE[integration.transaction_style],
+                )
 
             return rv
 
-        UrlDispatcher.resolve = sentry_urldispatcher_resolve
+        UrlDispatcher.resolve = sentry_urldispatcher_resolve  # type: ignore[method-assign]
 
         old_client_session_init = ClientSession.__init__
 
@@ -370,7 +363,7 @@ class AioHttpIntegration(Integration):
             kwargs["trace_configs"] = client_trace_configs
             return old_client_session_init(*args, **kwargs)
 
-        ClientSession.__init__ = init
+        ClientSession.__init__ = init  # type: ignore[method-assign]
 
 
 def create_trace_config() -> "TraceConfig":
@@ -554,6 +547,7 @@ def _make_request_processor(
         if request is None:
             return event
 
+        client_options = sentry_sdk.get_client().options
         with capture_internal_exceptions():
             request_info = event.setdefault("request", {})
 
@@ -563,15 +557,45 @@ def _make_request_processor(
                 request.path,
             )
 
-            request_info["query_string"] = request.query_string
+            if has_data_collection_enabled(client_options):
+                if request.query_string:
+                    filtered_query_string = (
+                        _apply_data_collection_filtering_to_query_string(
+                            query_string=request.query_string,
+                            behaviour=client_options["data_collection"][
+                                "url_query_params"
+                            ],
+                        )
+                    )
+                    if filtered_query_string:
+                        request_info["query_string"] = filtered_query_string
+            else:
+                request_info["query_string"] = request.query_string
+
             request_info["method"] = request.method
-            request_info["env"] = {"REMOTE_ADDR": request.remote}
+
+            # REMOTE_ADDR was unconditionally set pre-data collection, so it
+            # continues to be set when data collection is not enabled.
+            if (
+                not has_data_collection_enabled(client_options)
+                or client_options["data_collection"]["user_info"]
+            ):
+                request_info["env"] = {"REMOTE_ADDR": request.remote}
             request_info["headers"] = _filter_headers(dict(request.headers))
 
             # Just attach raw data here if it is within bounds, if available.
             # Unfortunately there's no way to get structured data from aiohttp
             # without awaiting on some coroutine.
-            request_info["data"] = get_aiohttp_request_data(request)
+            if has_data_collection_enabled(client_options):
+                if (
+                    "incoming_request"
+                    in client_options["data_collection"]["http_bodies"]
+                ):
+                    request_info["data"] = get_aiohttp_request_data(request)
+            else:
+                # We never gated this prior to data collection, so it should be attached
+                # when data collection is not enabled.
+                request_info["data"] = get_aiohttp_request_data(request)
 
         return event