Merge branch 'master' into py-2305-add-query-source-to-methods-that-were-missing-it

ericapisani · ericapisani · commit 141de46a28e4 · 2026-05-12T10:46:06.000-04:00
diff --git a/.github/workflows/ai-integration-test.yml b/.github/workflows/ai-integration-test.yml
@@ -34,7 +34,7 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Run Python SDK Tests
-        uses: getsentry/testing-ai-sdk-integrations@1dd9ee2a2d821f41473fc90809a758e8394c689c
+        uses: getsentry/testing-ai-sdk-integrations@18229d1da4bb8120ce923bdf7aac00fcf6f38311
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2
     secrets: inherit
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@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2.25.4
+      uses: getsentry/craft@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2.26.3
       env:
         GITHUB_TOKEN: ${{ steps.token.outputs.token }}
       with:
diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@71588ddf95134f804e82c5970a8098588e2eaecd
+      - uses: getsentry/github-workflows/validate-pr@43bf14b190c12080cfbedf2d2c82337bc559a0e1
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}
diff --git a/requirements-docs.txt b/requirements-docs.txt
@@ -1,5 +1,5 @@
 gevent
 shibuya
 sphinx<8.2
-sphinx-autodoc-typehints[type_comments]>=1.8.0
+sphinx-autodoc-typehints[type_comments]>=2.3.0
 typing-extensions
diff --git a/scripts/populate_tox/config.py b/scripts/populate_tox/config.py
@@ -310,7 +310,7 @@
         "num_versions": 2,
     },
     "pydantic_ai": {
-        "package": "pydantic-ai",
+        "package": "pydantic-ai-slim",
         "deps": {
             "*": ["pytest-asyncio"],
         },
diff --git a/sentry_sdk/_batcher.py b/sentry_sdk/_batcher.py
@@ -153,9 +153,10 @@ def _add_to_envelope(self, envelope: "Envelope") -> None:
                 },
                 payload=PayloadRef(
                     json={
+                        "version": 2,
                         "items": [
                             self._to_transport_format(item) for item in self._buffer
-                        ]
+                        ],
                     }
                 ),
             )
diff --git a/sentry_sdk/_log_batcher.py b/sentry_sdk/_log_batcher.py
@@ -45,7 +45,12 @@ def _record_lost(self, item: "Log") -> None:
             headers={
                 "item_count": 1,
             },
-            payload=PayloadRef(json={"items": [self._to_transport_format(item)]}),
+            payload=PayloadRef(
+                json={
+                    "version": 2,
+                    "items": [self._to_transport_format(item)],
+                }
+            ),
         )
 
         self._record_lost_func(
diff --git a/sentry_sdk/_span_batcher.py b/sentry_sdk/_span_batcher.py
@@ -224,10 +224,11 @@ def _flush(self, only_pending: bool = False) -> None:
                             },
                             payload=PayloadRef(
                                 json={
+                                    "version": 2,
                                     "items": [
                                         self._to_transport_format(spans[j])
                                         for j in range(start, end)
-                                    ]
+                                    ],
                                 }
                             ),
                         )
diff --git a/sentry_sdk/integrations/asyncpg.py b/sentry_sdk/integrations/asyncpg.py
@@ -16,7 +16,6 @@
 )
 from sentry_sdk.utils import (
     capture_internal_exceptions,
-    ensure_integration_enabled,
     parse_version,
 )
 
@@ -52,8 +51,12 @@ def setup_once() -> None:
         asyncpg.Connection._executemany = _wrap_connection_method(
             asyncpg.Connection._executemany, executemany=True
         )
-        asyncpg.Connection.cursor = _wrap_cursor_creation(asyncpg.Connection.cursor)
         asyncpg.Connection.prepare = _wrap_connection_method(asyncpg.Connection.prepare)
+
+        BaseCursor._bind_exec = _wrap_cursor_method(BaseCursor._bind_exec)
+        BaseCursor._bind = _wrap_cursor_method(BaseCursor._bind)
+        BaseCursor._exec = _wrap_cursor_method(BaseCursor._exec)
+
         asyncpg.connect_utils._connect_addr = _wrap_connect_addr(
             asyncpg.connect_utils._connect_addr
         )
@@ -159,21 +162,26 @@ async def _inner(*args: "Any", **kwargs: "Any") -> "T":
     return _inner
 
 
-def _wrap_cursor_creation(f: "Callable[..., T]") -> "Callable[..., T]":
-    @ensure_integration_enabled(AsyncPGIntegration, f)
-    def _inner(*args: "Any", **kwargs: "Any") -> "T":  # noqa: N807
-        query = args[1]
-        params_list = args[2] if len(args) > 2 else None
+def _wrap_cursor_method(
+    f: "Callable[..., Awaitable[T]]",
+) -> "Callable[..., Awaitable[T]]":
+    async def _inner(*args: "Any", **kwargs: "Any") -> "T":
+        if sentry_sdk.get_client().get_integration(AsyncPGIntegration) is None:
+            return await f(*args, **kwargs)
 
-        with _record(
-            None,
-            query,
-            params_list,
+        cursor = args[0]
+        query = _normalize_query(cursor._query)
+        with record_sql_queries_supporting_streaming(
+            cursor=cursor,
+            query=query,
+            params_list=None,
+            paramstyle=None,
             executemany=False,
+            record_cursor_repr=True,
+            span_origin=AsyncPGIntegration.origin,
         ) as span:
-            _set_db_data(span, args[0])
-
-            res = f(*args, **kwargs)
+            _set_db_data(span, cursor._connection)
+            res = await f(*args, **kwargs)
 
             if isinstance(span, StreamedSpan):
                 with capture_internal_exceptions():
diff --git a/tests/integrations/asyncpg/test_asyncpg.py b/tests/integrations/asyncpg/test_asyncpg.py
@@ -342,7 +342,7 @@ async def test_cursor(sentry_init, capture_events) -> None:
         {"category": "query", "data": {}, "message": "BEGIN;", "type": "default"},
         {
             "category": "query",
-            "data": {},
+            "data": {"db.cursor": mock.ANY},
             "message": "SELECT * FROM users WHERE dob > $1",
             "type": "default",
         },
@@ -400,7 +400,19 @@ async def test_cursor_manual(sentry_init, capture_events) -> None:
         {"category": "query", "data": {}, "message": "BEGIN;", "type": "default"},
         {
             "category": "query",
-            "data": {},
+            "data": {"db.cursor": mock.ANY},
+            "message": "SELECT * FROM users WHERE dob > $1",
+            "type": "default",
+        },
+        {
+            "category": "query",
+            "data": {"db.cursor": mock.ANY},
+            "message": "SELECT * FROM users WHERE dob > $1",
+            "type": "default",
+        },
+        {
+            "category": "query",
+            "data": {"db.cursor": mock.ANY},
             "message": "SELECT * FROM users WHERE dob > $1",
             "type": "default",
         },
@@ -1329,9 +1341,13 @@ async def test_query_source_prepare(
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("span_streaming", [True, False])
-async def test_query_source_cursor(
+async def test_cursor__bind_exec_creates_spans(
     sentry_init, capture_events, capture_items, span_streaming
-):
+) -> None:
+    """
+    Exercises the bind_exec patch through the iterator that's created in asyncpg when "for record in conn.cursor" is called.
+    See https://github.com/MagicStack/asyncpg/blob/db8ecc2a38e16fb0c090aef6f5506547c2831c24/asyncpg/cursor.py#L234
+    """
     sentry_init(
         integrations=[AsyncPGIntegration()],
         traces_sample_rate=1.0,
@@ -1346,50 +1362,178 @@ async def test_query_source_cursor(
         items = capture_items("span")
         with sentry_sdk.traces.start_span(name="test_transaction"):
             conn: Connection = await connect(PG_CONNECTION_URI)
+
+            await conn.executemany(
+                "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
+                [
+                    ("Bob", "secret_pw", datetime.date(1984, 3, 1)),
+                    ("Alice", "pw", datetime.date(1990, 12, 25)),
+                ],
+            )
+
             async with conn.transaction():
-                async for _ in conn.cursor(
-                    "SELECT * FROM users WHERE dob > $1", datetime.date(1970, 1, 1)
+                async for record in conn.cursor(
+                    "SELECT * FROM users WHERE dob > $1",
+                    datetime.date(1970, 1, 1),
                 ):
                     pass
+
             await conn.close()
         sentry_sdk.flush()
 
         spans = [item.payload for item in items]
-        assert len(spans) == 5
+
+        assert len(spans) == 6
+
         connect_span = spans[0]
-        begin_span = spans[1]
-        query_span = spans[2]
-        commit_span = spans[3]
-        segment = spans[4]
+        executemany_span = spans[1]
+        begin_span = spans[2]
+        bind_exec_span = spans[3]
+        commit_span = spans[4]
+        segment = spans[5]
 
         assert connect_span["name"] == "connect"
+        assert (
+            executemany_span["name"]
+            == "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)"
+        )
         assert begin_span["name"] == "BEGIN;"
-        assert query_span["name"] == "SELECT * FROM users WHERE dob > $1"
+        assert bind_exec_span["name"] == "SELECT * FROM users WHERE dob > $1"
         assert commit_span["name"] == "COMMIT;"
         assert segment["name"] == "test_transaction"
+
+        assert bind_exec_span["attributes"]["sentry.origin"] == "auto.db.asyncpg"
+        assert bind_exec_span["attributes"]["sentry.op"] == "db"
+        assert bind_exec_span["attributes"]["db.system"] == "postgresql"
+        assert bind_exec_span["attributes"]["db.driver.name"] == "asyncpg"
+        assert bind_exec_span["attributes"]["server.address"] == PG_HOST
+        assert bind_exec_span["attributes"]["server.port"] == PG_PORT
+        assert bind_exec_span["attributes"]["db.name"] == PG_NAME
+        assert bind_exec_span["attributes"]["db.user"] == PG_USER
     else:
         events = capture_events()
+
         with start_transaction(name="test_transaction", sampled=True):
             conn: Connection = await connect(PG_CONNECTION_URI)
+
+            await conn.executemany(
+                "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
+                [
+                    ("Bob", "secret_pw", datetime.date(1984, 3, 1)),
+                    ("Alice", "pw", datetime.date(1990, 12, 25)),
+                ],
+            )
+
             async with conn.transaction():
-                async for _ in conn.cursor(
-                    "SELECT * FROM users WHERE dob > $1", datetime.date(1970, 1, 1)
+                async for record in conn.cursor(
+                    "SELECT * FROM users WHERE dob > $1",
+                    datetime.date(1970, 1, 1),
                 ):
                     pass
+
             await conn.close()
 
         (event,) = events
-        spans = event["spans"]
-        assert len(spans) == 4
 
-        connect_span = spans[0]
-        begin_span = spans[1]
-        query_span = spans[2]
-        commit_span = spans[3]
+        assert len(event["spans"]) == 5
+
+        connect_span = event["spans"][0]
+        executemany_span = event["spans"][1]
+        begin_span = event["spans"][2]
+        bind_exec_span = event["spans"][3]
+        commit_span = event["spans"][4]
 
         assert connect_span["description"] == "connect"
+        assert (
+            executemany_span["description"]
+            == "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)"
+        )
         assert begin_span["description"] == "BEGIN;"
-        assert query_span["description"] == "SELECT * FROM users WHERE dob > $1"
+        assert bind_exec_span["description"] == "SELECT * FROM users WHERE dob > $1"
         assert commit_span["description"] == "COMMIT;"
 
-    _assert_query_source(query_span, span_streaming, "test_query_source_cursor")
+        assert bind_exec_span["origin"] == "auto.db.asyncpg"
+        assert bind_exec_span["data"]["db.system"] == "postgresql"
+        assert bind_exec_span["data"]["db.driver.name"] == "asyncpg"
+        assert bind_exec_span["data"]["server.address"] == PG_HOST
+        assert bind_exec_span["data"]["server.port"] == PG_PORT
+        assert bind_exec_span["data"]["db.name"] == PG_NAME
+        assert bind_exec_span["data"]["db.user"] == PG_USER
+
+    _assert_query_source(
+        bind_exec_span,
+        span_streaming,
+        "test_cursor__bind_exec_creates_spans",
+    )
+
+
+@pytest.mark.asyncio
+async def test_cursor__bind_and__exec_methods_create_spans(
+    sentry_init, capture_events
+) -> None:
+    sentry_init(
+        integrations=[AsyncPGIntegration()],
+        traces_sample_rate=1.0,
+        enable_db_query_source=True,
+        db_query_source_threshold_ms=0,
+    )
+    events = capture_events()
+
+    with start_transaction(name="test_transaction"):
+        conn: Connection = await connect(PG_CONNECTION_URI)
+
+        await conn.executemany(
+            "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)",
+            [
+                ("Bob", "secret_pw", datetime.date(1984, 3, 1)),
+                ("Alice", "pw", datetime.date(1990, 12, 25)),
+            ],
+        )
+
+        async with conn.transaction():
+            # This exercises the `_bind` patch and the `cursor` patch
+            cur = await conn.cursor(
+                "SELECT * FROM users WHERE dob > $1", datetime.date(1970, 1, 1)
+            )
+            # These exercise the `_exec` patch
+            await cur.fetchrow()
+            await cur.fetchrow()
+
+        await conn.close()
+
+    (event,) = events
+
+    assert len(event["spans"]) == 7
+
+    connect_span = event["spans"][0]
+    executemany_span = event["spans"][1]
+    begin_span = event["spans"][2]
+    cursor_creation_and_bind_span = event["spans"][3]
+    fetchrow_span_1 = event["spans"][4]
+    fetchrow_span_2 = event["spans"][5]
+    commit_span = event["spans"][6]
+
+    assert connect_span["description"] == "connect"
+    assert (
+        executemany_span["description"]
+        == "INSERT INTO users(name, password, dob) VALUES($1, $2, $3)"
+    )
+    assert begin_span["description"] == "BEGIN;"
+    assert fetchrow_span_1["description"] == "SELECT * FROM users WHERE dob > $1"
+    assert (
+        cursor_creation_and_bind_span["description"]
+        == "SELECT * FROM users WHERE dob > $1"
+    )
+    assert fetchrow_span_2["description"] == "SELECT * FROM users WHERE dob > $1"
+    assert commit_span["description"] == "COMMIT;"
+
+    for span in (cursor_creation_and_bind_span, fetchrow_span_1, fetchrow_span_2):
+        assert span["data"]["db.cursor"] is not None
+        assert span["data"]["db.system"] == "postgresql"
+        assert span["data"]["db.driver.name"] == "asyncpg"
+        assert span["origin"] == "auto.db.asyncpg"
+        _assert_query_source(
+            span,
+            False,
+            "test_cursor__bind_and__exec_methods_create_spans",
+        )
diff --git a/tests/test_logs.py b/tests/test_logs.py
diff --git a/tests/test_metrics.py b/tests/test_metrics.py
diff --git a/tests/tracing/test_span_batcher.py b/tests/tracing/test_span_batcher.py
diff --git a/tox.ini b/tox.ini

Original file line number	Diff line number	Diff line change
`@@ -153,9 +153,10 @@ def _add_to_envelope(self, envelope: "Envelope") -> None:`
`153`	`153`	`},`
`154`	`154`	`payload=PayloadRef(`
`155`	`155`	`json={`
	`156`	`+ "version": 2,`
`156`	`157`	`"items": [`
`157`	`158`	`self._to_transport_format(item) for item in self._buffer`
`158`		`- ]`
	`159`	`+ ],`
`159`	`160`	`}`
`160`	`161`	`),`
`161`	`162`	`)`
Original file line number	Diff line number	Diff line change
`@@ -224,10 +224,11 @@ def _flush(self, only_pending: bool = False) -> None:`
`224`	`224`	`},`
`225`	`225`	`payload=PayloadRef(`
`226`	`226`	`json={`
	`227`	`+ "version": 2,`
`227`	`228`	`"items": [`
`228`	`229`	`self._to_transport_format(spans[j])`
`229`	`230`	`for j in range(start, end)`
`230`		`- ]`
	`231`	`+ ],`
`231`	`232`	`}`
`232`	`233`	`),`
`233`	`234`	`)`