sentry-sdk 2.41.0__py2.py3-none-any.whl → 2.42.1__py2.py3-none-any.whl

sentry_sdk/integrations/langchain.py

@@ -9,6 +9,7 @@ from sentry_sdk.ai.utils import (
     normalize_message_roles,
     set_data_normalized,
     get_start_span_function,
+    truncate_and_annotate_messages,
 )
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
@@ -221,12 +222,17 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
                     }
                     for prompt in prompts
                 ]
-                set_data_normalized(
-                    span,
-                    SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                    normalized_messages,
-                    unpack=False,
+                scope = sentry_sdk.get_current_scope()
+                messages_data = truncate_and_annotate_messages(
+                    normalized_messages, span, scope
                 )
+                if messages_data is not None:
+                    set_data_normalized(
+                        span,
+                        SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                        messages_data,
+                        unpack=False,
+                    )
 
     def on_chat_model_start(self, serialized, messages, *, run_id, **kwargs):
         # type: (SentryLangchainCallback, Dict[str, Any], List[List[BaseMessage]], UUID, Any) -> Any
@@ -278,13 +284,17 @@ class SentryLangchainCallback(BaseCallbackHandler):  # type: ignore[misc]
                             self._normalize_langchain_message(message)
                         )
                 normalized_messages = normalize_message_roles(normalized_messages)
-
-                set_data_normalized(
-                    span,
-                    SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                    normalized_messages,
-                    unpack=False,
+                scope = sentry_sdk.get_current_scope()
+                messages_data = truncate_and_annotate_messages(
+                    normalized_messages, span, scope
                 )
+                if messages_data is not None:
+                    set_data_normalized(
+                        span,
+                        SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                        messages_data,
+                        unpack=False,
+                    )
 
     def on_chat_model_end(self, response, *, run_id, **kwargs):
         # type: (SentryLangchainCallback, LLMResult, UUID, Any) -> Any
@@ -758,12 +768,17 @@ def _wrap_agent_executor_invoke(f):
                 and integration.include_prompts
             ):
                 normalized_messages = normalize_message_roles([input])
-                set_data_normalized(
-                    span,
-                    SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                    normalized_messages,
-                    unpack=False,
+                scope = sentry_sdk.get_current_scope()
+                messages_data = truncate_and_annotate_messages(
+                    normalized_messages, span, scope
                 )
+                if messages_data is not None:
+                    set_data_normalized(
+                        span,
+                        SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                        messages_data,
+                        unpack=False,
+                    )
 
             output = result.get("output")
             if (
@@ -813,12 +828,17 @@ def _wrap_agent_executor_stream(f):
             and integration.include_prompts
         ):
             normalized_messages = normalize_message_roles([input])
-            set_data_normalized(
-                span,
-                SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                normalized_messages,
-                unpack=False,
+            scope = sentry_sdk.get_current_scope()
+            messages_data = truncate_and_annotate_messages(
+                normalized_messages, span, scope
             )
+            if messages_data is not None:
+                set_data_normalized(
+                    span,
+                    SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                    messages_data,
+                    unpack=False,
+                )
 
         # Run the agent
         result = f(self, *args, **kwargs)

sentry_sdk/integrations/langgraph.py

@@ -2,7 +2,11 @@ from functools import wraps
 from typing import Any, Callable, List, Optional
 
 import sentry_sdk
-from sentry_sdk.ai.utils import set_data_normalized, normalize_message_roles
+from sentry_sdk.ai.utils import (
+    set_data_normalized,
+    normalize_message_roles,
+    truncate_and_annotate_messages,
+)
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
@@ -181,12 +185,17 @@ def _wrap_pregel_invoke(f):
                 input_messages = _parse_langgraph_messages(args[0])
                 if input_messages:
                     normalized_input_messages = normalize_message_roles(input_messages)
-                    set_data_normalized(
-                        span,
-                        SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                        normalized_input_messages,
-                        unpack=False,
+                    scope = sentry_sdk.get_current_scope()
+                    messages_data = truncate_and_annotate_messages(
+                        normalized_input_messages, span, scope
                     )
+                    if messages_data is not None:
+                        set_data_normalized(
+                            span,
+                            SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                            messages_data,
+                            unpack=False,
+                        )
 
             result = f(self, *args, **kwargs)
 
@@ -232,12 +241,17 @@ def _wrap_pregel_ainvoke(f):
                 input_messages = _parse_langgraph_messages(args[0])
                 if input_messages:
                     normalized_input_messages = normalize_message_roles(input_messages)
-                    set_data_normalized(
-                        span,
-                        SPANDATA.GEN_AI_REQUEST_MESSAGES,
-                        normalized_input_messages,
-                        unpack=False,
+                    scope = sentry_sdk.get_current_scope()
+                    messages_data = truncate_and_annotate_messages(
+                        normalized_input_messages, span, scope
                     )
+                    if messages_data is not None:
+                        set_data_normalized(
+                            span,
+                            SPANDATA.GEN_AI_REQUEST_MESSAGES,
+                            messages_data,
+                            unpack=False,
+                        )
 
             result = await f(self, *args, **kwargs)
 

sentry_sdk/integrations/litellm.py

@@ -48,8 +48,11 @@ def _input_callback(kwargs):
         model = full_model
         provider = "unknown"
 
-    messages = kwargs.get("messages", [])
-    operation = "chat" if messages else "embeddings"
+    call_type = kwargs.get("call_type", None)
+    if call_type == "embedding":
+        operation = "embeddings"
+    else:
+        operation = "chat"
 
     # Start a new span/transaction
     span = get_start_span_function()(
@@ -71,6 +74,7 @@ def _input_callback(kwargs):
     set_data_normalized(span, SPANDATA.GEN_AI_OPERATION_NAME, operation)
 
     # Record messages if allowed
+    messages = kwargs.get("messages", [])
     if messages and should_send_default_pii() and integration.include_prompts:
         set_data_normalized(
             span, SPANDATA.GEN_AI_REQUEST_MESSAGES, messages, unpack=False

sentry_sdk/integrations/openai.py

@@ -3,7 +3,11 @@ from functools import wraps
 import sentry_sdk
 from sentry_sdk import consts
 from sentry_sdk.ai.monitoring import record_token_usage
-from sentry_sdk.ai.utils import set_data_normalized, normalize_message_roles
+from sentry_sdk.ai.utils import (
+    set_data_normalized,
+    normalize_message_roles,
+    truncate_and_annotate_messages,
+)
 from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
@@ -22,9 +26,14 @@ if TYPE_CHECKING:
 
 try:
     try:
-        from openai import NOT_GIVEN
+        from openai import NotGiven
     except ImportError:
-        NOT_GIVEN = None
+        NotGiven = None
+
+    try:
+        from openai import Omit
+    except ImportError:
+        Omit = None
 
     from openai.resources.chat.completions import Completions, AsyncCompletions
     from openai.resources import Embeddings, AsyncEmbeddings
@@ -183,9 +192,12 @@ def _set_input_data(span, kwargs, operation, integration):
         and integration.include_prompts
     ):
         normalized_messages = normalize_message_roles(messages)
-        set_data_normalized(
-            span, SPANDATA.GEN_AI_REQUEST_MESSAGES, normalized_messages, unpack=False
-        )
+        scope = sentry_sdk.get_current_scope()
+        messages_data = truncate_and_annotate_messages(normalized_messages, span, scope)
+        if messages_data is not None:
+            set_data_normalized(
+                span, SPANDATA.GEN_AI_REQUEST_MESSAGES, messages_data, unpack=False
+            )
 
     # Input attributes: Common
     set_data_normalized(span, SPANDATA.GEN_AI_SYSTEM, "openai")
@@ -204,12 +216,12 @@ def _set_input_data(span, kwargs, operation, integration):
     for key, attribute in kwargs_keys_to_attributes.items():
         value = kwargs.get(key)
 
-        if value is not NOT_GIVEN and value is not None:
+        if value is not None and _is_given(value):
             set_data_normalized(span, attribute, value)
 
     # Input attributes: Tools
     tools = kwargs.get("tools")
-    if tools is not NOT_GIVEN and tools is not None and len(tools) > 0:
+    if tools is not None and _is_given(tools) and len(tools) > 0:
         set_data_normalized(
             span, SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS, safe_serialize(tools)
         )
@@ -231,7 +243,7 @@ def _set_output_data(span, response, kwargs, integration, finish_span=True):
 
     if hasattr(response, "choices"):
         if should_send_default_pii() and integration.include_prompts:
-            response_text = [choice.message.dict() for choice in response.choices]
+            response_text = [choice.message.model_dump() for choice in response.choices]
             if len(response_text) > 0:
                 set_data_normalized(span, SPANDATA.GEN_AI_RESPONSE_TEXT, response_text)
 
@@ -689,3 +701,15 @@ def _wrap_async_responses_create(f):
         return await _execute_async(f, *args, **kwargs)
 
     return _sentry_patched_responses_async
+
+
+def _is_given(obj):
+    # type: (Any) -> bool
+    """
+    Check for givenness safely across different openai versions.
+    """
+    if NotGiven is not None and isinstance(obj, NotGiven):
+        return False
+    if Omit is not None and isinstance(obj, Omit):
+        return False
+    return True

sentry_sdk/integrations/ray.py

@@ -1,4 +1,5 @@
 import inspect
+import functools
 import sys
 
 import sentry_sdk
@@ -17,7 +18,6 @@ try:
     import ray  # type: ignore[import-not-found]
 except ImportError:
     raise DidNotEnable("Ray not installed.")
-import functools
 
 from typing import TYPE_CHECKING
 
@@ -54,12 +54,13 @@ def _patch_ray_remote():
 
         def wrapper(user_f):
             # type: (Callable[..., Any]) -> Any
-            def new_func(*f_args, _tracing=None, **f_kwargs):
+            @functools.wraps(user_f)
+            def new_func(*f_args, _sentry_tracing=None, **f_kwargs):
                 # type: (Any, Optional[dict[str, Any]], Any) -> Any
                 _check_sentry_initialized()
 
                 transaction = sentry_sdk.continue_trace(
-                    _tracing or {},
+                    _sentry_tracing or {},
                     op=OP.QUEUE_TASK_RAY,
                     name=qualname_from_function(user_f),
                     origin=RayIntegration.origin,
@@ -78,6 +79,19 @@ def _patch_ray_remote():
 
                     return result
 
+            # Patching new_func signature to add the _sentry_tracing parameter to it
+            # Ray later inspects the signature and finds the unexpected parameter otherwise
+            signature = inspect.signature(new_func)
+            params = list(signature.parameters.values())
+            params.append(
+                inspect.Parameter(
+                    "_sentry_tracing",
+                    kind=inspect.Parameter.KEYWORD_ONLY,
+                    default=None,
+                )
+            )
+            new_func.__signature__ = signature.replace(parameters=params)  # type: ignore[attr-defined]
+
             if f:
                 rv = old_remote(new_func)
             else:
@@ -99,7 +113,9 @@ def _patch_ray_remote():
                         for k, v in sentry_sdk.get_current_scope().iter_trace_propagation_headers()
                     }
                     try:
-                        result = old_remote_method(*args, **kwargs, _tracing=tracing)
+                        result = old_remote_method(
+                            *args, **kwargs, _sentry_tracing=tracing
+                        )
                         span.set_status(SPANSTATUS.OK)
                     except Exception:
                         span.set_status(SPANSTATUS.INTERNAL_ERROR)

sentry_sdk/integrations/redis/utils.py

@@ -20,12 +20,13 @@ def _get_safe_command(name, args):
     # type: (str, Sequence[Any]) -> str
     command_parts = [name]
 
+    name_low = name.lower()
+    send_default_pii = should_send_default_pii()
+
     for i, arg in enumerate(args):
         if i > _MAX_NUM_ARGS:
             break
 
-        name_low = name.lower()
-
         if name_low in _COMMANDS_INCLUDING_SENSITIVE_DATA:
             command_parts.append(SENSITIVE_DATA_SUBSTITUTE)
             continue
@@ -33,9 +34,8 @@ def _get_safe_command(name, args):
         arg_is_the_key = i == 0
         if arg_is_the_key:
             command_parts.append(repr(arg))
-
         else:
-            if should_send_default_pii():
+            if send_default_pii:
                 command_parts.append(repr(arg))
             else:
                 command_parts.append(SENSITIVE_DATA_SUBSTITUTE)

sentry_sdk/integrations/stdlib.py

@@ -8,7 +8,11 @@ import sentry_sdk
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import add_global_event_processor
-from sentry_sdk.tracing_utils import EnvironHeaders, should_propagate_trace
+from sentry_sdk.tracing_utils import (
+    EnvironHeaders,
+    should_propagate_trace,
+    add_http_request_source,
+)
 from sentry_sdk.utils import (
     SENSITIVE_DATA_SUBSTITUTE,
     capture_internal_exceptions,
@@ -135,6 +139,9 @@ def _install_httplib():
         finally:
             span.finish()
 
+            with capture_internal_exceptions():
+                add_http_request_source(span)
+
         return rv
 
     HTTPConnection.putrequest = putrequest  # type: ignore[method-assign]

sentry_sdk/scope.py

@@ -188,6 +188,7 @@ class Scope:
         "_extras",
         "_breadcrumbs",
         "_n_breadcrumbs_truncated",
+        "_gen_ai_original_message_count",
         "_event_processors",
         "_error_processors",
         "_should_capture",
@@ -213,6 +214,7 @@ class Scope:
         self._name = None  # type: Optional[str]
         self._propagation_context = None  # type: Optional[PropagationContext]
         self._n_breadcrumbs_truncated = 0  # type: int
+        self._gen_ai_original_message_count = {}  # type: Dict[str, int]
 
         self.client = NonRecordingClient()  # type: sentry_sdk.client.BaseClient
 
@@ -247,6 +249,7 @@ class Scope:
 
         rv._breadcrumbs = copy(self._breadcrumbs)
         rv._n_breadcrumbs_truncated = self._n_breadcrumbs_truncated
+        rv._gen_ai_original_message_count = self._gen_ai_original_message_count.copy()
         rv._event_processors = self._event_processors.copy()
         rv._error_processors = self._error_processors.copy()
         rv._propagation_context = self._propagation_context
@@ -1583,6 +1586,10 @@ class Scope:
             self._n_breadcrumbs_truncated = (
                 self._n_breadcrumbs_truncated + scope._n_breadcrumbs_truncated
             )
+        if scope._gen_ai_original_message_count:
+            self._gen_ai_original_message_count.update(
+                scope._gen_ai_original_message_count
+            )
         if scope._span:
             self._span = scope._span
         if scope._attachments:
@@ -1679,7 +1686,7 @@ def new_scope():
         try:
             # restore original scope
             _current_scope.reset(token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
 
@@ -1717,7 +1724,7 @@ def use_scope(scope):
         try:
             # restore original scope
             _current_scope.reset(token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
 
@@ -1761,12 +1768,12 @@ def isolation_scope():
         # restore original scopes
         try:
             _current_scope.reset(current_token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
         try:
             _isolation_scope.reset(isolation_token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
 
@@ -1808,12 +1815,12 @@ def use_isolation_scope(isolation_scope):
         # restore original scopes
         try:
             _current_scope.reset(current_token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
         try:
             _isolation_scope.reset(isolation_token)
-        except LookupError:
+        except (LookupError, ValueError):
             capture_internal_exception(sys.exc_info())
 
 

sentry_sdk/tracing_utils.py

@@ -218,33 +218,11 @@ def _should_be_included(
     )
 
 
-def add_query_source(span):
-    # type: (sentry_sdk.tracing.Span) -> None
+def add_source(span, project_root, in_app_include, in_app_exclude):
+    # type: (sentry_sdk.tracing.Span, Optional[str], Optional[list[str]], Optional[list[str]]) -> None
     """
     Adds OTel compatible source code information to the span
     """
-    client = sentry_sdk.get_client()
-    if not client.is_active():
-        return
-
-    if span.timestamp is None or span.start_timestamp is None:
-        return
-
-    should_add_query_source = client.options.get("enable_db_query_source", True)
-    if not should_add_query_source:
-        return
-
-    duration = span.timestamp - span.start_timestamp
-    threshold = client.options.get("db_query_source_threshold_ms", 0)
-    slow_query = duration / timedelta(milliseconds=1) > threshold
-
-    if not slow_query:
-        return
-
-    project_root = client.options["project_root"]
-    in_app_include = client.options.get("in_app_include")
-    in_app_exclude = client.options.get("in_app_exclude")
-
     # Find the correct frame
     frame = sys._getframe()  # type: Union[FrameType, None]
     while frame is not None:
@@ -309,6 +287,68 @@ def add_query_source(span):
             span.set_data(SPANDATA.CODE_FUNCTION, frame.f_code.co_name)
 
 
+def add_query_source(span):
+    # type: (sentry_sdk.tracing.Span) -> None
+    """
+    Adds OTel compatible source code information to a database query span
+    """
+    client = sentry_sdk.get_client()
+    if not client.is_active():
+        return
+
+    if span.timestamp is None or span.start_timestamp is None:
+        return
+
+    should_add_query_source = client.options.get("enable_db_query_source", True)
+    if not should_add_query_source:
+        return
+
+    duration = span.timestamp - span.start_timestamp
+    threshold = client.options.get("db_query_source_threshold_ms", 0)
+    slow_query = duration / timedelta(milliseconds=1) > threshold
+
+    if not slow_query:
+        return
+
+    add_source(
+        span=span,
+        project_root=client.options["project_root"],
+        in_app_include=client.options.get("in_app_include"),
+        in_app_exclude=client.options.get("in_app_exclude"),
+    )
+
+
+def add_http_request_source(span):
+    # type: (sentry_sdk.tracing.Span) -> None
+    """
+    Adds OTel compatible source code information to a span for an outgoing HTTP request
+    """
+    client = sentry_sdk.get_client()
+    if not client.is_active():
+        return
+
+    if span.timestamp is None or span.start_timestamp is None:
+        return
+
+    should_add_request_source = client.options.get("enable_http_request_source", False)
+    if not should_add_request_source:
+        return
+
+    duration = span.timestamp - span.start_timestamp
+    threshold = client.options.get("http_request_source_threshold_ms", 0)
+    slow_query = duration / timedelta(milliseconds=1) > threshold
+
+    if not slow_query:
+        return
+
+    add_source(
+        span=span,
+        project_root=client.options["project_root"],
+        in_app_include=client.options.get("in_app_include"),
+        in_app_exclude=client.options.get("in_app_exclude"),
+    )
+
+
 def extract_sentrytrace_data(header):
     # type: (Optional[str]) -> Optional[Dict[str, Union[str, bool, None]]]
     """

sentry_sdk/utils.py

@@ -1484,17 +1484,37 @@ class TimeoutThread(threading.Thread):
     waiting_time and raises a custom ServerlessTimeout exception.
     """
 
-    def __init__(self, waiting_time, configured_timeout):
-        # type: (float, int) -> None
+    def __init__(
+        self, waiting_time, configured_timeout, isolation_scope=None, current_scope=None
+    ):
+        # type: (float, int, Optional[sentry_sdk.Scope], Optional[sentry_sdk.Scope]) -> None
         threading.Thread.__init__(self)
         self.waiting_time = waiting_time
         self.configured_timeout = configured_timeout
+
+        self.isolation_scope = isolation_scope
+        self.current_scope = current_scope
+
         self._stop_event = threading.Event()
 
     def stop(self):
         # type: () -> None
         self._stop_event.set()
 
+    def _capture_exception(self):
+        # type: () -> ExcInfo
+        exc_info = sys.exc_info()
+
+        client = sentry_sdk.get_client()
+        event, hint = event_from_exception(
+            exc_info,
+            client_options=client.options,
+            mechanism={"type": "threading", "handled": False},
+        )
+        sentry_sdk.capture_event(event, hint=hint)
+
+        return exc_info
+
     def run(self):
         # type: () -> None
 
@@ -1510,6 +1530,18 @@ class TimeoutThread(threading.Thread):
             integer_configured_timeout = integer_configured_timeout + 1
 
         # Raising Exception after timeout duration is reached
+        if self.isolation_scope is not None and self.current_scope is not None:
+            with sentry_sdk.scope.use_isolation_scope(self.isolation_scope):
+                with sentry_sdk.scope.use_scope(self.current_scope):
+                    try:
+                        raise ServerlessTimeoutWarning(
+                            "WARNING : Function is expected to get timed out. Configured timeout duration = {} seconds.".format(
+                                integer_configured_timeout
+                            )
+                        )
+                    except Exception:
+                        reraise(*self._capture_exception())
+
         raise ServerlessTimeoutWarning(
             "WARNING : Function is expected to get timed out. Configured timeout duration = {} seconds.".format(
                 integer_configured_timeout

{sentry_sdk-2.41.0.dist-info → sentry_sdk-2.42.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentry-sdk
-Version: 2.41.0
+Version: 2.42.1
 Summary: Python client for Sentry (https://sentry.io)
 Home-page: https://github.com/getsentry/sentry-python
 Author: Sentry Team and Contributors
@@ -118,6 +118,8 @@ Provides-Extra: tornado
 Requires-Dist: tornado>=6; extra == "tornado"
 Provides-Extra: unleash
 Requires-Dist: UnleashClient>=6.0.1; extra == "unleash"
+Provides-Extra: google-genai
+Requires-Dist: google-genai>=1.29.0; extra == "google-genai"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier