sentry-sdk 3.0.0a4__py2.py3-none-any.whl → 3.0.0a6__py2.py3-none-any.whl

sentry_sdk/__init__.py

@@ -49,6 +49,7 @@ __all__ = [  # noqa
     "start_session",
     "end_session",
     "set_transaction_name",
+    "update_current_span",
 ]
 
 # Initialize the debug support after everything is loaded

sentry_sdk/ai/utils.py

@@ -8,8 +8,7 @@ from sentry_sdk.tracing import Span
 from sentry_sdk.utils import logger
 
 
-def _normalize_data(data: Any) -> Any:
-
+def _normalize_data(data: Any, unpack: bool = True) -> Any:
     # convert pydantic data (e.g. OpenAI v1+) to json compatible format
     if hasattr(data, "model_dump"):
         try:
@@ -18,17 +17,17 @@ def _normalize_data(data: Any) -> Any:
             logger.warning("Could not convert pydantic data to JSON: %s", e)
             return data
     if isinstance(data, list):
-        if len(data) == 1:
-            return _normalize_data(data[0])  # remove empty dimensions
-        return list(_normalize_data(x) for x in data)
+        if unpack and len(data) == 1:
+            return _normalize_data(data[0], unpack=unpack)  # remove empty dimensions
+        return list(_normalize_data(x, unpack=unpack) for x in data)
     if isinstance(data, dict):
-        return {k: _normalize_data(v) for (k, v) in data.items()}
+        return {k: _normalize_data(v, unpack=unpack) for (k, v) in data.items()}
 
     return data
 
 
-def set_data_normalized(span: Span, key: str, value: Any) -> None:
-    normalized = _normalize_data(value)
+def set_data_normalized(span: Span, key: str, value: Any, unpack: bool = True) -> None:
+    normalized = _normalize_data(value, unpack=unpack)
     if isinstance(normalized, (int, float, bool, str)):
         span.set_attribute(key, normalized)
     else:

sentry_sdk/api.py

@@ -76,6 +76,7 @@ __all__ = [
     "start_session",
     "end_session",
     "set_transaction_name",
+    "update_current_span",
 ]
 
 
@@ -228,6 +229,14 @@ def flush(
     return get_client().flush(timeout=timeout, callback=callback)
 
 
+@clientmethod
+async def flush_async(
+    timeout: Optional[float] = None,
+    callback: Optional[Callable[[int, float], None]] = None,
+) -> None:
+    return await get_client().flush_async(timeout=timeout, callback=callback)
+
+
 def start_span(**kwargs: Any) -> Span:
     """
     Start and return a span.
@@ -341,3 +350,62 @@ def end_session() -> None:
 @scopemethod
 def set_transaction_name(name: str, source: Optional[str] = None) -> None:
     return get_current_scope().set_transaction_name(name, source)
+
+
+def update_current_span(
+    op: Optional[str] = None,
+    name: Optional[str] = None,
+    attributes: Optional[dict[str, Union[str, int, float, bool]]] = None,
+) -> None:
+    """
+    Update the current active span with the provided parameters.
+
+    This function allows you to modify properties of the currently active span.
+    If no span is currently active, this function will do nothing.
+
+    :param op: The operation name for the span. This is a high-level description
+        of what the span represents (e.g., "http.client", "db.query").
+        You can use predefined constants from :py:class:`sentry_sdk.consts.OP`
+        or provide your own string. If not provided, the span's operation will
+        remain unchanged.
+    :type op: str or None
+
+    :param name: The human-readable name/description for the span. This provides
+        more specific details about what the span represents (e.g., "GET /api/users",
+        "SELECT * FROM users"). If not provided, the span's name will remain unchanged.
+    :type name: str or None
+
+    :param attributes: A dictionary of key-value pairs to add as attributes to the span.
+        Attribute values must be strings, integers, floats, or booleans. These
+        attributes will be merged with any existing span data. If not provided,
+        no attributes will be added.
+    :type attributes: dict[str, Union[str, int, float, bool]] or None
+
+    :returns: None
+
+    .. versionadded:: 2.35.0
+
+    Example::
+
+        import sentry_sdk
+        from sentry_sdk.consts import OP
+
+        sentry_sdk.update_current_span(
+            op=OP.FUNCTION,
+            name="process_user_data",
+            attributes={"user_id": 123, "batch_size": 50}
+        )
+    """
+    current_span = get_current_span()
+
+    if current_span is None:
+        return
+
+    if op is not None:
+        current_span.op = op
+
+    if name is not None:
+        current_span.name = name
+
+    if attributes is not None:
+        current_span.set_attributes(attributes)

sentry_sdk/client.py

@@ -25,7 +25,7 @@ from sentry_sdk.utils import (
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
-from sentry_sdk.transport import BaseHttpTransport, make_transport
+from sentry_sdk.transport import HttpTransportCore, make_transport, AsyncHttpTransport
 from sentry_sdk.consts import (
     SPANDATA,
     DEFAULT_MAX_VALUE_LENGTH,
@@ -214,6 +214,12 @@ class BaseClient:
     def flush(self, *args: Any, **kwargs: Any) -> None:
         return None
 
+    async def close_async(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    async def flush_async(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
     def __enter__(self) -> BaseClient:
         return self
 
@@ -406,7 +412,7 @@ class _Client(BaseClient):
             self.monitor
             or self.log_batcher
             or has_profiling_enabled(self.options)
-            or isinstance(self.transport, BaseHttpTransport)
+            or isinstance(self.transport, HttpTransportCore)
         ):
             # If we have anything on that could spawn a background thread, we
             # need to check if it's safe to use them.
@@ -442,12 +448,12 @@ class _Client(BaseClient):
 
         previous_total_spans: Optional[int] = None
         previous_total_breadcrumbs: Optional[int] = None
+        is_transaction = event.get("type") == "transaction"
 
         if event.get("timestamp") is None:
             event["timestamp"] = datetime.now(timezone.utc)
 
         if scope is not None:
-            is_transaction = event.get("type") == "transaction"
             spans_before = len(event.get("spans", []))
             event_ = scope.apply_to_event(event, hint, self.options)
 
@@ -488,7 +494,8 @@ class _Client(BaseClient):
                 )
 
         if (
-            self.options["attach_stacktrace"]
+            not is_transaction
+            and self.options["attach_stacktrace"]
             and "exception" not in event
             and "stacktrace" not in event
             and "threads" not in event
@@ -917,6 +924,14 @@ class _Client(BaseClient):
 
         return self.integrations.get(integration_name)
 
+    def _close_components(self) -> None:
+        """Kill all client components in the correct order."""
+        self.session_flusher.kill()
+        if self.log_batcher is not None:
+            self.log_batcher.kill()
+        if self.monitor:
+            self.monitor.kill()
+
     def close(
         self,
         timeout: Optional[float] = None,
@@ -927,19 +942,43 @@ class _Client(BaseClient):
         semantics as :py:meth:`Client.flush`.
         """
         if self.transport is not None:
+            if isinstance(self.transport, AsyncHttpTransport) and hasattr(
+                self.transport, "loop"
+            ):
+                logger.debug(
+                    "close() used with AsyncHttpTransport, aborting. Please use close_async() instead."
+                )
+                return
             self.flush(timeout=timeout, callback=callback)
-
-            self.session_flusher.kill()
-
-            if self.log_batcher is not None:
-                self.log_batcher.kill()
-
-            if self.monitor:
-                self.monitor.kill()
-
+            self._close_components()
             self.transport.kill()
             self.transport = None
 
+    async def close_async(
+        self,
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[int, float], None]] = None,
+    ) -> None:
+        """
+        Asynchronously close the client and shut down the transport. Arguments have the same
+        semantics as :py:meth:`Client.flush_async`.
+        """
+        if self.transport is not None:
+            if not (
+                isinstance(self.transport, AsyncHttpTransport)
+                and hasattr(self.transport, "loop")
+            ):
+                logger.debug(
+                    "close_async() used with non-async transport, aborting. Please use close() instead."
+                )
+                return
+            await self.flush_async(timeout=timeout, callback=callback)
+            self._close_components()
+            kill_task = self.transport.kill()  # type: ignore
+            if kill_task is not None:
+                await kill_task
+            self.transport = None
+
     def flush(
         self,
         timeout: Optional[float] = None,
@@ -953,15 +992,52 @@ class _Client(BaseClient):
         :param callback: Is invoked with the number of pending events and the configured timeout.
         """
         if self.transport is not None:
+            if isinstance(self.transport, AsyncHttpTransport) and hasattr(
+                self.transport, "loop"
+            ):
+                logger.debug(
+                    "flush() used with AsyncHttpTransport, aborting. Please use flush_async() instead."
+                )
+                return
             if timeout is None:
                 timeout = self.options["shutdown_timeout"]
-            self.session_flusher.flush()
-
-            if self.log_batcher is not None:
-                self.log_batcher.flush()
+            self._flush_components()
 
             self.transport.flush(timeout=timeout, callback=callback)
 
+    async def flush_async(
+        self,
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[int, float], None]] = None,
+    ) -> None:
+        """
+        Asynchronously wait for the current events to be sent.
+
+        :param timeout: Wait for at most `timeout` seconds. If no `timeout` is provided, the `shutdown_timeout` option value is used.
+
+        :param callback: Is invoked with the number of pending events and the configured timeout.
+        """
+        if self.transport is not None:
+            if not (
+                isinstance(self.transport, AsyncHttpTransport)
+                and hasattr(self.transport, "loop")
+            ):
+                logger.debug(
+                    "flush_async() used with non-async transport, aborting. Please use flush() instead."
+                )
+                return
+            if timeout is None:
+                timeout = self.options["shutdown_timeout"]
+            self._flush_components()
+            flush_task = self.transport.flush(timeout=timeout, callback=callback)  # type: ignore
+            if flush_task is not None:
+                await flush_task
+
+    def _flush_components(self) -> None:
+        self.session_flusher.flush()
+        if self.log_batcher is not None:
+            self.log_batcher.flush()
+
     def __enter__(self) -> _Client:
         return self
 

sentry_sdk/consts.py

@@ -78,6 +78,7 @@ if TYPE_CHECKING:
             "transport_compression_algo": Optional[CompressionAlgo],
             "transport_num_pools": Optional[int],
             "transport_http2": Optional[bool],
+            "transport_async": Optional[bool],
         },
         total=False,
     )
@@ -95,6 +96,17 @@ FALSE_VALUES = [
 ]
 
 
+class SPANTEMPLATE(str, Enum):
+    DEFAULT = "default"
+    AI_AGENT = "ai_agent"
+    AI_TOOL = "ai_tool"
+    AI_CHAT = "ai_chat"
+
+    def __str__(self):
+        # type: () -> str
+        return self.value
+
+
 class SPANDATA:
     """
     Additional information describing the type of the span.
@@ -103,6 +115,9 @@ class SPANDATA:
 
     AI_CITATIONS = "ai.citations"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     References or sources cited by the AI model in its response.
     Example: ["Smith et al. 2020", "Jones 2019"]
     """
@@ -115,65 +130,97 @@ class SPANDATA:
 
     AI_DOCUMENTS = "ai.documents"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Documents or content chunks used as context for the AI model.
     Example: ["doc1.txt", "doc2.pdf"]
     """
 
     AI_FINISH_REASON = "ai.finish_reason"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_FINISH_REASONS instead.
+
     The reason why the model stopped generating.
     Example: "length"
     """
 
     AI_FREQUENCY_PENALTY = "ai.frequency_penalty"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_FREQUENCY_PENALTY instead.
+
     Used to reduce repetitiveness of generated tokens.
     Example: 0.5
     """
 
     AI_FUNCTION_CALL = "ai.function_call"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_TOOL_CALLS instead.
+
     For an AI model call, the function that was called. This is deprecated for OpenAI, and replaced by tool_calls
     """
 
     AI_GENERATION_ID = "ai.generation_id"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_ID instead.
+
     Unique identifier for the completion.
     Example: "gen_123abc"
     """
 
     AI_INPUT_MESSAGES = "ai.input_messages"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_MESSAGES instead.
+
     The input messages to an LLM call.
     Example: [{"role": "user", "message": "hello"}]
     """
 
     AI_LOGIT_BIAS = "ai.logit_bias"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     For an AI model call, the logit bias
     """
 
     AI_METADATA = "ai.metadata"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Extra metadata passed to an AI pipeline step.
     Example: {"executed_function": "add_integers"}
     """
 
     AI_MODEL_ID = "ai.model_id"
     """
-    The unique descriptor of the model being execugted
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_MODEL or GEN_AI_RESPONSE_MODEL instead.
+
+    The unique descriptor of the model being executed.
     Example: gpt-4
     """
 
     AI_PIPELINE_NAME = "ai.pipeline.name"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_PIPELINE_NAME instead.
+
     Name of the AI pipeline or chain being executed.
-    DEPRECATED: Use GEN_AI_PIPELINE_NAME instead.
     Example: "qa-pipeline"
     """
 
     AI_PREAMBLE = "ai.preamble"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     For an AI model call, the preamble parameter.
     Preambles are a part of the prompt used to adjust the model's overall behavior and conversation style.
     Example: "You are now a clown."
@@ -181,6 +228,9 @@ class SPANDATA:
 
     AI_PRESENCE_PENALTY = "ai.presence_penalty"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_PRESENCE_PENALTY instead.
+
     Used to reduce repetitiveness of generated tokens.
     Example: 0.5
     """
@@ -193,89 +243,133 @@ class SPANDATA:
 
     AI_RAW_PROMPTING = "ai.raw_prompting"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Minimize pre-processing done to the prompt sent to the LLM.
     Example: true
     """
 
     AI_RESPONSE_FORMAT = "ai.response_format"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     For an AI model call, the format of the response
     """
 
     AI_RESPONSES = "ai.responses"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_TEXT instead.
+
     The responses to an AI model call. Always as a list.
     Example: ["hello", "world"]
     """
 
     AI_SEARCH_QUERIES = "ai.search_queries"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Queries used to search for relevant context or documents.
     Example: ["climate change effects", "renewable energy"]
     """
 
     AI_SEARCH_REQUIRED = "ai.is_search_required"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Boolean indicating if the model needs to perform a search.
     Example: true
     """
 
     AI_SEARCH_RESULTS = "ai.search_results"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Results returned from search queries for context.
     Example: ["Result 1", "Result 2"]
     """
 
     AI_SEED = "ai.seed"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_SEED instead.
+
     The seed, ideally models given the same seed and same other parameters will produce the exact same output.
     Example: 123.45
     """
 
     AI_STREAMING = "ai.streaming"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_STREAMING instead.
+
     Whether or not the AI model call's response was streamed back asynchronously
-    DEPRECATED: Use GEN_AI_RESPONSE_STREAMING instead.
     Example: true
     """
 
     AI_TAGS = "ai.tags"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Tags that describe an AI pipeline step.
     Example: {"executed_function": "add_integers"}
     """
 
     AI_TEMPERATURE = "ai.temperature"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_TEMPERATURE instead.
+
     For an AI model call, the temperature parameter. Temperature essentially means how random the output will be.
     Example: 0.5
     """
 
     AI_TEXTS = "ai.texts"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Raw text inputs provided to the model.
     Example: ["What is machine learning?"]
     """
 
     AI_TOP_K = "ai.top_k"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_TOP_K instead.
+
     For an AI model call, the top_k parameter. Top_k essentially controls how random the output will be.
     Example: 35
     """
 
     AI_TOP_P = "ai.top_p"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_TOP_P instead.
+
     For an AI model call, the top_p parameter. Top_p essentially controls how random the output will be.
     Example: 0.5
     """
 
     AI_TOOL_CALLS = "ai.tool_calls"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_RESPONSE_TOOL_CALLS instead.
+
     For an AI model call, the function that was called. This is deprecated for OpenAI, and replaced by tool_calls
     """
 
     AI_TOOLS = "ai.tools"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_REQUEST_AVAILABLE_TOOLS instead.
+
     For an AI model call, the functions that are available
     """
 
@@ -287,6 +381,9 @@ class SPANDATA:
 
     AI_WARNINGS = "ai.warnings"
     """
+    .. deprecated::
+        This attribute is deprecated. Use GEN_AI_* attributes instead.
+
     Warning messages generated during model execution.
     Example: ["Token limit exceeded"]
     """
@@ -391,6 +488,18 @@ class SPANDATA:
     Example: "qa-pipeline"
     """
 
+    GEN_AI_RESPONSE_FINISH_REASONS = "gen_ai.response.finish_reasons"
+    """
+    The reason why the model stopped generating.
+    Example: "COMPLETE"
+    """
+
+    GEN_AI_RESPONSE_ID = "gen_ai.response.id"
+    """
+    Unique identifier for the completion.
+    Example: "gen_123abc"
+    """
+
     GEN_AI_RESPONSE_MODEL = "gen_ai.response.model"
     """
     Exact model identifier used to generate the response
@@ -451,12 +560,24 @@ class SPANDATA:
     Example: 0.1
     """
 
+    GEN_AI_REQUEST_SEED = "gen_ai.request.seed"
+    """
+    The seed, ideally models given the same seed and same other parameters will produce the exact same output.
+    Example: "1234567890"
+    """
+
     GEN_AI_REQUEST_TEMPERATURE = "gen_ai.request.temperature"
     """
     The temperature parameter used to control randomness in the output.
     Example: 0.7
     """
 
+    GEN_AI_REQUEST_TOP_K = "gen_ai.request.top_k"
+    """
+    Limits the model to only consider the K most likely next tokens, where K is an integer (e.g., top_k=20 means only the 20 highest probability tokens are considered).
+    Example: 35
+    """
+
     GEN_AI_REQUEST_TOP_P = "gen_ai.request.top_p"
     """
     The top_p parameter used to control diversity via nucleus sampling.
@@ -683,6 +804,7 @@ class OP:
     GEN_AI_EMBEDDINGS = "gen_ai.embeddings"
     GEN_AI_EXECUTE_TOOL = "gen_ai.execute_tool"
     GEN_AI_HANDOFF = "gen_ai.handoff"
+    GEN_AI_PIPELINE = "gen_ai.pipeline"
     GEN_AI_INVOKE_AGENT = "gen_ai.invoke_agent"
     GEN_AI_RESPONSES = "gen_ai.responses"
     GRAPHQL_EXECUTE = "graphql.execute"
@@ -712,11 +834,6 @@ class OP:
     HUGGINGFACE_HUB_CHAT_COMPLETIONS_CREATE = (
         "ai.chat_completions.create.huggingface_hub"
     )
-    LANGCHAIN_PIPELINE = "ai.pipeline.langchain"
-    LANGCHAIN_RUN = "ai.run.langchain"
-    LANGCHAIN_TOOL = "ai.tool.langchain"
-    LANGCHAIN_AGENT = "ai.agent.langchain"
-    LANGCHAIN_CHAT_COMPLETIONS_CREATE = "ai.chat_completions.create.langchain"
     QUEUE_PROCESS = "queue.process"
     QUEUE_PUBLISH = "queue.publish"
     QUEUE_SUBMIT_ARQ = "queue.submit.arq"
@@ -1272,4 +1389,4 @@ DEFAULT_OPTIONS = _get_default_options()
 del _get_default_options
 
 
-VERSION = "3.0.0a4"
+VERSION = "3.0.0a6"

sentry_sdk/crons/api.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 import uuid
 
 import sentry_sdk
+from sentry_sdk.utils import logger
 
 from typing import TYPE_CHECKING
 
@@ -53,4 +54,8 @@ def capture_checkin(
 
     sentry_sdk.capture_event(check_in_event)
 
+    logger.debug(
+        f"[Crons] Captured check-in ({check_in_event.get('check_in_id')}): {check_in_event.get('monitor_slug')} -> {check_in_event.get('status')}"
+    )
+
     return check_in_event["check_in_id"]