Merge branch 'master' into constantinius/fix/integrations/pydantic-ai-report-image-inputs

constantinius · web-flow · commit 20e46fc1c6dc · 2026-01-14T15:09:59.000+01:00
diff --git a/.github/workflows/release.yml b/.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:
diff --git a/scripts/populate_tox/config.py b/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",
diff --git a/scripts/populate_tox/package_dependencies.jsonl b/scripts/populate_tox/package_dependencies.jsonl
diff --git a/scripts/populate_tox/populate_tox.py b/scripts/populate_tox/populate_tox.py
@@ -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 []
 
 
diff --git a/scripts/populate_tox/releases.jsonl b/scripts/populate_tox/releases.jsonl
diff --git a/sentry_sdk/ai/utils.py b/sentry_sdk/ai/utils.py
@@ -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"):
diff --git a/sentry_sdk/client.py b/sentry_sdk/client.py
@@ -527,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:
diff --git a/sentry_sdk/integrations/__init__.py b/sentry_sdk/integrations/__init__.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),
diff --git a/sentry_sdk/integrations/grpc/__init__.py b/sentry_sdk/integrations/grpc/__init__.py
@@ -50,14 +50,29 @@ def __getitem__(self, _):
 GRPC_VERSION = parse_version(grpc.__version__)
 
 
+def _is_channel_intercepted(channel: "Channel") -> bool:
+    interceptor = getattr(channel, "_interceptor", None)
+    while interceptor is not None:
+        if isinstance(interceptor, ClientInterceptor):
+            return True
+
+        inner_channel = getattr(channel, "_channel", None)
+        if inner_channel is None:
+            return False
+
+        channel = inner_channel
+        interceptor = getattr(channel, "_interceptor", None)
+
+    return False
+
+
 def _wrap_channel_sync(func: "Callable[P, Channel]") -> "Callable[P, Channel]":
     "Wrapper for synchronous secure and insecure channel."
 
     @wraps(func)
     def patched_channel(*args: "Any", **kwargs: "Any") -> "Channel":
         channel = func(*args, **kwargs)
-        if not ClientInterceptor._is_intercepted:
-            ClientInterceptor._is_intercepted = True
+        if not _is_channel_intercepted(channel):
             return intercept_channel(channel, ClientInterceptor())
         else:
             return channel
@@ -70,7 +85,7 @@ def _wrap_intercept_channel(func: "Callable[P, Channel]") -> "Callable[P, Channe
     def patched_intercept_channel(
         channel: "Channel", *interceptors: "grpc.ServerInterceptor"
     ) -> "Channel":
-        if ClientInterceptor._is_intercepted:
+        if _is_channel_intercepted(channel):
             interceptors = tuple(
                 [
                     interceptor
diff --git a/sentry_sdk/integrations/grpc/client.py b/sentry_sdk/integrations/grpc/client.py
@@ -22,8 +22,6 @@ class ClientInterceptor(
     grpc.UnaryUnaryClientInterceptor,  # type: ignore
     grpc.UnaryStreamClientInterceptor,  # type: ignore
 ):
-    _is_intercepted = False
-
     def intercept_unary_unary(
         self: "ClientInterceptor",
         continuation: "Callable[[ClientCallDetails, Message], _UnaryOutcome]",
diff --git a/sentry_sdk/metrics.py b/sentry_sdk/metrics.py
@@ -1,8 +1,3 @@
-"""
-NOTE: This file contains experimental code that may be changed or removed at any
-time without prior notice.
-"""
-
 import time
 from typing import Any, Optional, TYPE_CHECKING, Union
 
diff --git a/tests/integrations/grpc/test_grpc.py b/tests/integrations/grpc/test_grpc.py
@@ -8,6 +8,7 @@
 from sentry_sdk import start_span, start_transaction
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations.grpc import GRPCIntegration
+from sentry_sdk.integrations.grpc.client import ClientInterceptor
 from tests.conftest import ApproxDict
 from tests.integrations.grpc.grpc_test_service_pb2 import gRPCTestMessage
 from tests.integrations.grpc.grpc_test_service_pb2_grpc import (
@@ -269,6 +270,42 @@ def test_grpc_client_other_interceptor(sentry_init, capture_events_forksafe):
     )
 
 
+@pytest.mark.forked
+def test_prevent_dual_client_interceptor(sentry_init, capture_events_forksafe):
+    sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
+    events = capture_events_forksafe()
+
+    server, channel = _set_up()
+
+    # Intercept the channel
+    channel = grpc.intercept_channel(channel, ClientInterceptor())
+    stub = gRPCTestServiceStub(channel)
+
+    with start_transaction():
+        stub.TestServe(gRPCTestMessage(text="test"))
+
+    _tear_down(server=server)
+
+    events.write_file.close()
+    events.read_event()
+    local_transaction = events.read_event()
+    span = local_transaction["spans"][0]
+
+    assert len(local_transaction["spans"]) == 1
+    assert span["op"] == OP.GRPC_CLIENT
+    assert (
+        span["description"]
+        == "unary unary call to /grpc_test_server.gRPCTestService/TestServe"
+    )
+    assert span["data"] == ApproxDict(
+        {
+            "type": "unary unary",
+            "method": "/grpc_test_server.gRPCTestService/TestServe",
+            "code": "OK",
+        }
+    )
+
+
 @pytest.mark.forked
 def test_grpc_client_and_servers_interceptors_integration(
     sentry_init, capture_events_forksafe
diff --git a/tests/test_ai_monitoring.py b/tests/test_ai_monitoring.py
@@ -17,6 +17,7 @@
     truncate_and_annotate_messages,
     truncate_messages_by_size,
     _find_truncation_index,
+    parse_data_uri,
     redact_blob_message_parts,
 )
 from sentry_sdk.serializer import serialize
@@ -757,3 +758,87 @@ def test_handles_non_dict_content_items(self):
 
         # Should return same list since no blobs
         assert result is messages
+
+
+class TestParseDataUri:
+    def test_parses_base64_image_data_uri(self):
+        """Test parsing a standard base64-encoded image data URI"""
+        uri = "data:image/jpeg;base64,/9j/4AAQSkZJRg=="
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "image/jpeg"
+        assert content == "/9j/4AAQSkZJRg=="
+
+    def test_parses_png_data_uri(self):
+        """Test parsing a PNG image data URI"""
+        uri = "data:image/png;base64,iVBORw0KGgo="
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "image/png"
+        assert content == "iVBORw0KGgo="
+
+    def test_parses_plain_text_data_uri(self):
+        """Test parsing a plain text data URI without base64 encoding"""
+        uri = "data:text/plain,Hello World"
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "text/plain"
+        assert content == "Hello World"
+
+    def test_parses_data_uri_with_empty_mime_type(self):
+        """Test parsing a data URI with empty mime type"""
+        uri = "data:;base64,SGVsbG8="
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == ""
+        assert content == "SGVsbG8="
+
+    def test_parses_data_uri_with_only_data_prefix(self):
+        """Test parsing a data URI with only the data: prefix and content"""
+        uri = "data:,Hello"
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == ""
+        assert content == "Hello"
+
+    def test_raises_on_missing_comma(self):
+        """Test that ValueError is raised when comma separator is missing"""
+        with pytest.raises(ValueError, match="missing comma separator"):
+            parse_data_uri("data:image/jpeg;base64")
+
+    def test_raises_on_empty_string(self):
+        """Test that ValueError is raised for empty string"""
+        with pytest.raises(ValueError, match="missing comma separator"):
+            parse_data_uri("")
+
+    def test_handles_content_with_commas(self):
+        """Test that only the first comma is used as separator"""
+        uri = "data:text/plain,Hello,World,With,Commas"
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "text/plain"
+        assert content == "Hello,World,With,Commas"
+
+    def test_parses_data_uri_with_multiple_parameters(self):
+        """Test parsing a data URI with multiple parameters in header"""
+        uri = "data:text/plain;charset=utf-8;base64,SGVsbG8="
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "text/plain"
+        assert content == "SGVsbG8="
+
+    def test_parses_audio_data_uri(self):
+        """Test parsing an audio data URI"""
+        uri = "data:audio/wav;base64,UklGRiQA"
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "audio/wav"
+        assert content == "UklGRiQA"
+
+    def test_handles_uri_without_data_prefix(self):
+        """Test parsing a URI that doesn't have the data: prefix"""
+        uri = "image/jpeg;base64,/9j/4AAQ"
+        mime_type, content = parse_data_uri(uri)
+
+        assert mime_type == "image/jpeg"
+        assert content == "/9j/4AAQ"
diff --git a/tests/tracing/test_misc.py b/tests/tracing/test_misc.py
@@ -37,6 +37,26 @@ def test_span_trimming(sentry_init, capture_events):
     assert "dropped_spans" not in event
 
 
+def test_span_trimming_produces_client_report(
+    sentry_init, capture_events, capture_record_lost_event_calls
+):
+    sentry_init(traces_sample_rate=1.0, _experiments={"max_spans": 3})
+    events = capture_events()
+    record_lost_event_calls = capture_record_lost_event_calls()
+
+    with start_transaction(name="hi"):
+        for i in range(10):
+            with start_span(op="foo{}".format(i)):
+                pass
+
+    (event,) = events
+
+    assert len(event["spans"]) == 3
+
+    # 7 spans were dropped (10 total - 3 kept = 7 dropped)
+    assert ("buffer_overflow", "span", None, 7) in record_lost_event_calls
+
+
 def test_span_data_scrubbing_and_trimming(sentry_init, capture_events):
     sentry_init(traces_sample_rate=1.0, _experiments={"max_spans": 3})
     events = capture_events()
diff --git a/tox.ini b/tox.ini
