feat: Support httpx2 (#6463)

### Description

Support [httpx2](https://github.com/pydantic/httpx2).

Copy our httpx integration and tests and use that as the basis for the
new integration, so that if the new fork diverges, we can only edit the
dedicated integration.

Changes compared to `HttpxIntegration`:
- Renamed all httpx -> httpx2 (duh)
- Needed a replacement for `pytest-httpx`. Picked `httpx2-pytest` since
it's drop-in. Since it's a new project, pinned it to the current version
for additional safety.
- The tests needed adapting to be 3.14 compatible (httpx isn't tested on
3.14): `asyncio.get_event_loop().run_until_complete` -> `asyncio.run`

Docs: getsentry/sentry-docs#17940

#### Issues
- Closes #6448
- Closes
https://linear.app/getsentry/issue/PY-2502/add-support-for-httpx2

#### Reminders
- Please add tests to validate your changes, and lint your code using
`uv run ruff`.
- Add GH Issue ID _&_ Linear ID (if applicable)
- PR title should use [conventional
commit](https://develop.sentry.dev/engineering-practices/commit-messages/#type)
style (`feat:`, `fix:`, `ref:`, `meta:`)
- For external contributors:
[CONTRIBUTING.md](https://github.com/getsentry/sentry-python/blob/master/CONTRIBUTING.md),
[Sentry SDK development docs](https://develop.sentry.dev/sdk/), [Discord
community](https://discord.gg/Ww9hbqr)

Author: sentrivana

.github/workflows/test-integrations-network.yml

@@ -59,6 +59,10 @@ jobs:
         run: |
           set -x # print commands that are executed
           ./scripts/runtox.sh "py${{ matrix.python-version }}-httpx"
+      - name: Test httpx2
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh "py${{ matrix.python-version }}-httpx2"
       - name: Test pyreqwest
         run: |
           set -x # print commands that are executed

pyproject.toml

@@ -64,6 +64,7 @@ typing = [
     "typer",
     "strawberry-graphql",
     "httpx",
+    "httpx2",
     "botocore-stubs",
     "werkzeug",
 ]

scripts/populate_tox/config.py

@@ -202,6 +202,13 @@
             ">=0.28": ">=3.9",
         },
     },
+    "httpx2": {
+        "package": "httpx2",
+        "deps": {
+            "*": ["anyio>=3,<5", "httpx2-pytest==1.0.1"],
+        },
+        "python": ">=3.10",
+    },
     "huey": {
         "package": "huey",
         "num_versions": 2,

scripts/populate_tox/package_dependencies.jsonl

@@ -124,6 +124,7 @@
     "Network": [
         "grpc",
         "httpx",
+        "httpx2",
         "pyreqwest",
         "requests",
     ],

scripts/populate_tox/releases.jsonl

@@ -84,6 +84,7 @@ def iter_default_integrations(
     "sentry_sdk.integrations.google_genai.GoogleGenAIIntegration",
     "sentry_sdk.integrations.graphene.GrapheneIntegration",
     "sentry_sdk.integrations.httpx.HttpxIntegration",
+    "sentry_sdk.integrations.httpx2.Httpx2Integration",
     "sentry_sdk.integrations.huey.HueyIntegration",
     "sentry_sdk.integrations.huggingface_hub.HuggingfaceHubIntegration",
     "sentry_sdk.integrations.langchain.LangchainIntegration",
@@ -138,6 +139,7 @@ def iter_default_integrations(
     "google_genai": (1, 29, 0),  # google-genai
     "grpc": (1, 32, 0),  # grpcio
     "httpx": (0, 16, 0),
+    "httpx2": (2, 0, 0),
     "huggingface_hub": (0, 24, 7),
     "langchain": (0, 1, 0),
     "langgraph": (0, 6, 6),

scripts/split_tox_gh_actions/split_tox_gh_actions.py

@@ -0,0 +1,262 @@
+from typing import TYPE_CHECKING
+
+import sentry_sdk
+from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.tracing import BAGGAGE_HEADER_NAME
+from sentry_sdk.tracing_utils import (
+    add_http_request_source,
+    add_sentry_baggage_to_headers,
+    has_span_streaming_enabled,
+    should_propagate_trace,
+)
+from sentry_sdk.utils import (
+    SENSITIVE_DATA_SUBSTITUTE,
+    capture_internal_exceptions,
+    ensure_integration_enabled,
+    logger,
+    parse_url,
+)
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from sentry_sdk._types import Attributes
+
+
+try:
+    from httpx2 import AsyncClient, Client, Request, Response
+except ImportError:
+    raise DidNotEnable("httpx2 is not installed")
+
+__all__ = ["Httpx2Integration"]
+
+
+class Httpx2Integration(Integration):
+    identifier = "httpx2"
+    origin = f"auto.http.{identifier}"
+
+    @staticmethod
+    def setup_once() -> None:
+        """
+        httpx2 has its own transport layer and can be customized when needed,
+        so patch Client.send and AsyncClient.send to support both synchronous and async interfaces.
+        """
+        _install_httpx2_client()
+        _install_httpx2_async_client()
+
+
+def _install_httpx2_client() -> None:
+    real_send = Client.send
+
+    @ensure_integration_enabled(Httpx2Integration, real_send)
+    def send(self: "Client", request: "Request", **kwargs: "Any") -> "Response":
+        client = sentry_sdk.get_client()
+        is_span_streaming_enabled = has_span_streaming_enabled(client.options)
+
+        parsed_url = None
+        with capture_internal_exceptions():
+            parsed_url = parse_url(str(request.url), sanitize=False)
+
+        if is_span_streaming_enabled:
+            with sentry_sdk.traces.start_span(
+                name="%s %s"
+                % (
+                    request.method,
+                    parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
+                ),
+                attributes={
+                    "sentry.op": OP.HTTP_CLIENT,
+                    "sentry.origin": Httpx2Integration.origin,
+                    "http.request.method": request.method,
+                },
+            ) as streamed_span:
+                attributes: "Attributes" = {}
+
+                if parsed_url is not None:
+                    attributes["url.full"] = parsed_url.url
+                    if parsed_url.query:
+                        attributes["url.query"] = parsed_url.query
+                    if parsed_url.fragment:
+                        attributes["url.fragment"] = parsed_url.fragment
+
+                if should_propagate_trace(client, str(request.url)):
+                    for (
+                        key,
+                        value,
+                    ) in (
+                        sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+                    ):
+                        logger.debug(
+                            f"[Tracing] Adding `{key}` header {value} to outgoing request to {request.url}."
+                        )
+
+                        if key == BAGGAGE_HEADER_NAME:
+                            add_sentry_baggage_to_headers(request.headers, value)
+                        else:
+                            request.headers[key] = value
+
+                try:
+                    rv = real_send(self, request, **kwargs)
+
+                    streamed_span.status = "error" if rv.status_code >= 400 else "ok"
+                    attributes["http.response.status_code"] = rv.status_code
+                finally:
+                    streamed_span.set_attributes(attributes)
+
+                # Needs to happen within the context manager as we want to attach the
+                # final data before the span finishes and is sent for ingesting.
+                with capture_internal_exceptions():
+                    add_http_request_source(streamed_span)
+        else:
+            with sentry_sdk.start_span(
+                op=OP.HTTP_CLIENT,
+                name="%s %s"
+                % (
+                    request.method,
+                    parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
+                ),
+                origin=Httpx2Integration.origin,
+            ) as span:
+                span.set_data(SPANDATA.HTTP_METHOD, request.method)
+                if parsed_url is not None:
+                    span.set_data("url", parsed_url.url)
+                    span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
+                    span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+
+                if should_propagate_trace(client, str(request.url)):
+                    for (
+                        key,
+                        value,
+                    ) in (
+                        sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+                    ):
+                        logger.debug(
+                            f"[Tracing] Adding `{key}` header {value} to outgoing request to {request.url}."
+                        )
+
+                        if key == BAGGAGE_HEADER_NAME:
+                            add_sentry_baggage_to_headers(request.headers, value)
+                        else:
+                            request.headers[key] = value
+
+                rv = real_send(self, request, **kwargs)
+
+                span.set_http_status(rv.status_code)
+                span.set_data("reason", rv.reason_phrase)
+
+            with capture_internal_exceptions():
+                add_http_request_source(span)
+
+        return rv
+
+    Client.send = send  # type: ignore
+
+
+def _install_httpx2_async_client() -> None:
+    real_send = AsyncClient.send
+
+    async def send(
+        self: "AsyncClient", request: "Request", **kwargs: "Any"
+    ) -> "Response":
+        client = sentry_sdk.get_client()
+        if client.get_integration(Httpx2Integration) is None:
+            return await real_send(self, request, **kwargs)
+
+        is_span_streaming_enabled = has_span_streaming_enabled(client.options)
+        parsed_url = None
+        with capture_internal_exceptions():
+            parsed_url = parse_url(str(request.url), sanitize=False)
+
+        if is_span_streaming_enabled:
+            with sentry_sdk.traces.start_span(
+                name="%s %s"
+                % (
+                    request.method,
+                    parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
+                ),
+                attributes={
+                    "sentry.op": OP.HTTP_CLIENT,
+                    "sentry.origin": Httpx2Integration.origin,
+                    "http.request.method": request.method,
+                },
+            ) as streamed_span:
+                attributes: "Attributes" = {}
+
+                if parsed_url is not None:
+                    attributes["url.full"] = parsed_url.url
+                    if parsed_url.query:
+                        attributes["url.query"] = parsed_url.query
+                    if parsed_url.fragment:
+                        attributes["url.fragment"] = parsed_url.fragment
+
+                if should_propagate_trace(client, str(request.url)):
+                    for (
+                        key,
+                        value,
+                    ) in (
+                        sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+                    ):
+                        logger.debug(
+                            f"[Tracing] Adding `{key}` header {value} to outgoing request to {request.url}."
+                        )
+
+                        if key == BAGGAGE_HEADER_NAME:
+                            add_sentry_baggage_to_headers(request.headers, value)
+                        else:
+                            request.headers[key] = value
+
+                try:
+                    rv = await real_send(self, request, **kwargs)
+
+                    streamed_span.status = "error" if rv.status_code >= 400 else "ok"
+                    attributes["http.response.status_code"] = rv.status_code
+                finally:
+                    streamed_span.set_attributes(attributes)
+
+                # Needs to happen within the context manager as we want to attach the
+                # final data before the span finishes and is sent for ingesting.
+                with capture_internal_exceptions():
+                    add_http_request_source(streamed_span)
+        else:
+            with sentry_sdk.start_span(
+                op=OP.HTTP_CLIENT,
+                name="%s %s"
+                % (
+                    request.method,
+                    parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE,
+                ),
+                origin=Httpx2Integration.origin,
+            ) as span:
+                span.set_data(SPANDATA.HTTP_METHOD, request.method)
+                if parsed_url is not None:
+                    span.set_data("url", parsed_url.url)
+                    span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
+                    span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+
+                if should_propagate_trace(client, str(request.url)):
+                    for (
+                        key,
+                        value,
+                    ) in (
+                        sentry_sdk.get_current_scope().iter_trace_propagation_headers()
+                    ):
+                        logger.debug(
+                            f"[Tracing] Adding `{key}` header {value} to outgoing request to {request.url}."
+                        )
+                        if key == BAGGAGE_HEADER_NAME:
+                            add_sentry_baggage_to_headers(request.headers, value)
+                        else:
+                            request.headers[key] = value
+
+                rv = await real_send(self, request, **kwargs)
+
+                span.set_http_status(rv.status_code)
+                span.set_data("reason", rv.reason_phrase)
+
+            with capture_internal_exceptions():
+                add_http_request_source(span)
+
+        return rv
+
+    AsyncClient.send = send  # type: ignore

sentry_sdk/integrations/__init__.py

@@ -0,0 +1,10 @@
+import os
+import sys
+
+import pytest
+
+pytest.importorskip("httpx2")
+
+# Load `httpx2_helpers` into the module search path to test request source path names relative to module. See
+# `test_request_source_with_module_in_search_path`
+sys.path.insert(0, os.path.join(os.path.dirname(__file__)))