Merge branch 'master' into constantinius/feat/integrations/openai-agents-conversation-id

Author: constantinius

.github/workflows/release.yml

@@ -31,7 +31,7 @@ jobs:
         token: ${{ steps.token.outputs.token }}
         fetch-depth: 0
     - name: Prepare release
-      uses: getsentry/craft@39ee616a6a58dc64797feecb145d66770492b66c # v2
+      uses: getsentry/craft@1c58bfd57bfd6a967b6f3fc92bead2c42ee698ce # v2
       env:
         GITHUB_TOKEN: ${{ steps.token.outputs.token }}
       with:

scripts/populate_tox/config.py

@@ -311,6 +311,9 @@
         "deps": {
             "*": ["mockupdb"],
         },
+        "python": {
+            "<3.6": "<3.7",
+        },
     },
     "pyramid": {
         "package": "pyramid",
@@ -368,6 +371,9 @@
             ">=0.9,<0.14": ["fakeredis>=1.0,<1.7.4"],
             "py3.6,py3.7": ["fakeredis!=2.26.0"],
         },
+        "python": {
+            "<0.13": "<3.7",
+        },
     },
     "sanic": {
         "package": "sanic",
@@ -385,6 +391,9 @@
     },
     "sqlalchemy": {
         "package": "sqlalchemy",
+        "python": {
+            "<1.4": "<3.10",
+        },
     },
     "starlette": {
         "package": "starlette",

scripts/populate_tox/package_dependencies.jsonl

@@ -504,6 +504,9 @@ def pick_python_versions_to_test(
     - a free-threaded wheel is distributed; and
     - the SDK supports free-threading.
     """
+    if not python_versions:
+        return []
+
     filtered_python_versions = {
         python_versions[0],
     }
@@ -545,7 +548,8 @@ def _parse_python_versions_from_classifiers(classifiers: list[str]) -> list[Vers
 
     if python_versions:
         python_versions.sort()
-        return python_versions
+
+    return python_versions
 
 
 def determine_python_versions(pypi_data: dict) -> Union[SpecifierSet, list[Version]]:
@@ -579,6 +583,14 @@ def determine_python_versions(pypi_data: dict) -> Union[SpecifierSet, list[Versi
     if requires_python:
         return SpecifierSet(requires_python)
 
+    # If we haven't found neither specific 3.x classifiers nor a requires_python,
+    # check if there is a generic "Python 3" classifier and if so, assume the
+    # package supports all Python versions the SDK does. If this is not the case
+    # in reality, add the actual constraints manually to config.py.
+    for classifier in classifiers:
+        if CLASSIFIER_PREFIX + "3" in classifiers:
+            return SpecifierSet(f">={MIN_PYTHON_VERSION}")
+
     return []
 
 

scripts/populate_tox/populate_tox.py

@@ -256,6 +256,7 @@ class SDKInfo(TypedDict):
     )
 
     MetricType = Literal["counter", "gauge", "distribution"]
+    MetricUnit = Union[DurationUnit, InformationUnit, str]
 
     Metric = TypedDict(
         "Metric",
@@ -266,7 +267,7 @@ class SDKInfo(TypedDict):
             "name": str,
             "type": MetricType,
             "value": float,
-            "unit": Optional[str],
+            "unit": Optional[MetricUnit],
             "attributes": Attributes,
         },
     )

scripts/populate_tox/releases.jsonl

@@ -40,6 +40,38 @@ class GEN_AI_ALLOWED_MESSAGE_ROLES:
         GEN_AI_MESSAGE_ROLE_MAPPING[source_role] = target_role
 
 
+def parse_data_uri(url: str) -> "Tuple[str, str]":
+    """
+    Parse a data URI and return (mime_type, content).
+
+    Data URI format (RFC 2397): data:[<mediatype>][;base64],<data>
+
+    Examples:
+        data:image/jpeg;base64,/9j/4AAQ... → ("image/jpeg", "/9j/4AAQ...")
+        data:text/plain,Hello → ("text/plain", "Hello")
+        data:;base64,SGVsbG8= → ("", "SGVsbG8=")
+
+    Raises:
+        ValueError: If the URL is not a valid data URI (missing comma separator)
+    """
+    if "," not in url:
+        raise ValueError("Invalid data URI: missing comma separator")
+
+    header, content = url.split(",", 1)
+
+    # Extract mime type from header
+    # Format: "data:<mime>[;param1][;param2]..." e.g. "data:image/jpeg;base64"
+    # Remove "data:" prefix, then take everything before the first semicolon
+    if header.startswith("data:"):
+        mime_part = header[5:]  # Remove "data:" prefix
+    else:
+        mime_part = header
+
+    mime_type = mime_part.split(";")[0]
+
+    return mime_type, content
+
+
 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"):

sentry_sdk/_types.py

@@ -188,6 +188,7 @@ def __init__(self, options: "Optional[Dict[str, Any]]" = None) -> None:
         self.monitor: "Optional[Monitor]" = None
         self.log_batcher: "Optional[LogBatcher]" = None
         self.metrics_batcher: "Optional[MetricsBatcher]" = None
+        self.integrations: "dict[str, Integration]" = {}
 
     def __getstate__(self, *args: "Any", **kwargs: "Any") -> "Any":
         return {"options": {}}
@@ -526,12 +527,21 @@ def _prepare_event(
             spans_delta = spans_before - len(
                 cast(List[Dict[str, object]], event.get("spans", []))
             )
-            if is_transaction and spans_delta > 0 and self.transport is not None:
-                self.transport.record_lost_event(
-                    "event_processor", data_category="span", quantity=spans_delta
-                )
+            span_recorder_dropped_spans: int = event.pop("_dropped_spans", 0)
+
+            if is_transaction and self.transport is not None:
+                if spans_delta > 0:
+                    self.transport.record_lost_event(
+                        "event_processor", data_category="span", quantity=spans_delta
+                    )
+                if span_recorder_dropped_spans > 0:
+                    self.transport.record_lost_event(
+                        "buffer_overflow",
+                        data_category="span",
+                        quantity=span_recorder_dropped_spans,
+                    )
 
-            dropped_spans: int = event.pop("_dropped_spans", 0) + spans_delta
+            dropped_spans: int = span_recorder_dropped_spans + spans_delta
             if dropped_spans > 0:
                 previous_total_spans = spans_before + dropped_spans
             if scope._n_breadcrumbs_truncated > 0:

sentry_sdk/ai/utils.py

@@ -81,6 +81,7 @@ def iter_default_integrations(
     "sentry_sdk.integrations.fastapi.FastApiIntegration",
     "sentry_sdk.integrations.flask.FlaskIntegration",
     "sentry_sdk.integrations.gql.GQLIntegration",
+    "sentry_sdk.integrations.google_genai.GoogleGenAIIntegration",
     "sentry_sdk.integrations.graphene.GrapheneIntegration",
     "sentry_sdk.integrations.httpx.HttpxIntegration",
     "sentry_sdk.integrations.huey.HueyIntegration",
@@ -148,6 +149,7 @@ def iter_default_integrations(
     "openai_agents": (0, 0, 19),
     "openfeature": (0, 7, 1),
     "pydantic_ai": (1, 0, 0),
+    "pymongo": (3, 5, 0),
     "quart": (0, 16, 0),
     "ray": (2, 7, 0),
     "requests": (2, 0, 0),

sentry_sdk/client.py

@@ -47,6 +47,10 @@ def patch_asyncio() -> None:
         loop = asyncio.get_running_loop()
         orig_task_factory = loop.get_task_factory()
 
+        # Check if already patched
+        if getattr(orig_task_factory, "_is_sentry_task_factory", False):
+            return
+
         def _sentry_task_factory(
             loop: "asyncio.AbstractEventLoop",
             coro: "Coroutine[Any, Any, Any]",
@@ -102,6 +106,7 @@ async def _task_with_sentry_span_creation() -> "Any":
 
             return task
 
+        _sentry_task_factory._is_sentry_task_factory = True  # type: ignore
         loop.set_task_factory(_sentry_task_factory)  # type: ignore
 
     except RuntimeError:
@@ -138,3 +143,48 @@ class AsyncioIntegration(Integration):
     @staticmethod
     def setup_once() -> None:
         patch_asyncio()
+
+
+def enable_asyncio_integration(*args: "Any", **kwargs: "Any") -> None:
+    """
+    Enable AsyncioIntegration with the provided options.
+
+    This is useful in scenarios where Sentry needs to be initialized before
+    an event loop is set up, but you still want to instrument asyncio once there
+    is an event loop. In that case, you can sentry_sdk.init() early on without
+    the AsyncioIntegration and then, once the event loop has been set up,
+    execute:
+
+    ```python
+    from sentry_sdk.integrations.asyncio import enable_asyncio_integration
+
+    async def async_entrypoint():
+        enable_asyncio_integration()
+    ```
+
+    Any arguments provided will be passed to AsyncioIntegration() as is.
+
+    If AsyncioIntegration has already patched the current event loop, this
+    function won't have any effect.
+
+    If AsyncioIntegration was provided in
+    sentry_sdk.init(disabled_integrations=[...]), this function will ignore that
+    and the integration will be enabled.
+    """
+    client = sentry_sdk.get_client()
+    if not client.is_active():
+        return
+
+    # This function purposefully bypasses the integration machinery in
+    # integrations/__init__.py. _installed_integrations/_processed_integrations
+    # is used to prevent double patching the same module, but in the case of
+    # the AsyncioIntegration, we don't monkeypatch the standard library directly,
+    # we patch the currently running event loop, and we keep the record of doing
+    # that on the loop itself.
+    logger.debug("Setting up integration asyncio")
+
+    integration = AsyncioIntegration(*args, **kwargs)
+    integration.setup_once()
+
+    if "asyncio" not in client.integrations:
+        client.integrations["asyncio"] = integration