Merge branch 'master' into jgreer013/issue-6596

Author: alexander-alderman-webb

sentry_sdk/integrations/_asgi_common.py

@@ -135,6 +135,9 @@ def _get_request_attributes(asgi_scope: "Any") -> "dict[str, Any]":
                 if query_string is not None
                 else url_without_query_string
             )
+            attributes["url.path"] = asgi_scope.get("root_path", "") + asgi_scope.get(
+                "path", ""
+            )
 
     client = asgi_scope.get("client")
     if client and should_send_default_pii():

sentry_sdk/integrations/aiohttp.py

@@ -159,11 +159,17 @@ async def sentry_app_handle(
                                 header_value
                             )
 
-                        url_query_attribute = (
-                            {"url.query": request.query_string}
-                            if request.query_string
-                            else {}
-                        )
+                        url_attributes = {}
+                        if should_send_default_pii():
+                            url_attributes["url.full"] = "%s://%s%s" % (
+                                request.scheme,
+                                request.host,
+                                request.path,
+                            )
+                            url_attributes["url.path"] = request.path
+
+                            if request.query_string:
+                                url_attributes["url.query"] = request.query_string
 
                         client_address_attributes = {}
                         if should_send_default_pii() and request.remote:
@@ -180,10 +186,8 @@ async def sentry_app_handle(
                                 "sentry.op": OP.HTTP_SERVER,
                                 "sentry.origin": AioHttpIntegration.origin,
                                 "sentry.span.source": SegmentSource.ROUTE.value,
-                                "url.full": "%s://%s%s"
-                                % (request.scheme, request.host, request.path),
                                 "http.request.method": request.method,
-                                **url_query_attribute,
+                                **url_attributes,
                                 **client_address_attributes,
                                 **header_attributes,
                             },
@@ -354,8 +358,10 @@ async def on_request_start(
                 "sentry.origin": AioHttpIntegration.origin,
                 "http.request.method": method,
             }
-            if parsed_url is not None:
+            if parsed_url is not None and should_send_default_pii():
                 attributes["url.full"] = parsed_url.url
+                attributes["url.path"] = params.url.path
+
                 if parsed_url.query:
                     attributes["url.query"] = parsed_url.query
                 if parsed_url.fragment:

sentry_sdk/integrations/redis/_async_common.py

@@ -1,14 +1,15 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations.redis.consts import SPAN_ORIGIN
 from sentry_sdk.integrations.redis.modules.caches import (
     _compile_cache_span_properties,
     _set_cache_data,
 )
 from sentry_sdk.integrations.redis.modules.queries import _compile_db_span_properties
 from sentry_sdk.integrations.redis.utils import (
+    _get_safe_command,
     _set_client_data,
     _set_pipeline_data,
 )
@@ -109,6 +110,12 @@ async def _sentry_execute_command(
             integration,
         )
 
+        additional_cache_span_attributes = {}
+        with capture_internal_exceptions():
+            additional_cache_span_attributes[SPANDATA.DB_QUERY_TEXT] = (
+                _get_safe_command(name, args)
+            )
+
         cache_span: "Optional[Union[Span, StreamedSpan]]" = None
         if cache_properties["is_cache_key"] and cache_properties["op"] is not None:
             if span_streaming:
@@ -117,6 +124,7 @@ async def _sentry_execute_command(
                     attributes={
                         "sentry.op": cache_properties["op"],
                         "sentry.origin": SPAN_ORIGIN,
+                        **additional_cache_span_attributes,
                     },
                 )
             else:
@@ -129,13 +137,20 @@ async def _sentry_execute_command(
 
         db_properties = _compile_db_span_properties(integration, name, args)
 
+        additional_db_span_attributes = {}
+        with capture_internal_exceptions():
+            additional_db_span_attributes[SPANDATA.DB_QUERY_TEXT] = _get_safe_command(
+                name, args
+            )
+
         db_span: "Union[Span, StreamedSpan]"
         if span_streaming:
             db_span = sentry_sdk.traces.start_span(
                 name=db_properties["description"],
                 attributes={
                     "sentry.op": db_properties["op"],
                     "sentry.origin": SPAN_ORIGIN,
+                    **additional_db_span_attributes,
                 },
             )
         else:

sentry_sdk/integrations/redis/_sync_common.py

@@ -1,14 +1,15 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations.redis.consts import SPAN_ORIGIN
 from sentry_sdk.integrations.redis.modules.caches import (
     _compile_cache_span_properties,
     _set_cache_data,
 )
 from sentry_sdk.integrations.redis.modules.queries import _compile_db_span_properties
 from sentry_sdk.integrations.redis.utils import (
+    _get_safe_command,
     _set_client_data,
     _set_pipeline_data,
 )
@@ -108,6 +109,12 @@ def sentry_patched_execute_command(
             integration,
         )
 
+        additional_cache_span_attributes = {}
+        with capture_internal_exceptions():
+            additional_cache_span_attributes[SPANDATA.DB_QUERY_TEXT] = (
+                _get_safe_command(name, args)
+            )
+
         cache_span: "Optional[Union[Span, StreamedSpan]]" = None
         if cache_properties["is_cache_key"] and cache_properties["op"] is not None:
             if span_streaming:
@@ -116,6 +123,7 @@ def sentry_patched_execute_command(
                     attributes={
                         "sentry.op": cache_properties["op"],
                         "sentry.origin": SPAN_ORIGIN,
+                        **additional_cache_span_attributes,
                     },
                 )
             else:
@@ -128,13 +136,20 @@ def sentry_patched_execute_command(
 
         db_properties = _compile_db_span_properties(integration, name, args)
 
+        additional_db_span_attributes = {}
+        with capture_internal_exceptions():
+            additional_db_span_attributes[SPANDATA.DB_QUERY_TEXT] = _get_safe_command(
+                name, args
+            )
+
         db_span: "Union[Span, StreamedSpan]"
         if span_streaming:
             db_span = sentry_sdk.traces.start_span(
                 name=db_properties["description"],
                 attributes={
                     "sentry.op": db_properties["op"],
                     "sentry.origin": SPAN_ORIGIN,
+                    **additional_db_span_attributes,
                 },
             )
         else:

sentry_sdk/integrations/wsgi.py

@@ -394,12 +394,6 @@ def _get_request_attributes(
     for header, value in headers.items():
         attributes[f"http.request.header.{header.lower()}"] = value
 
-    query_string = environ.get("QUERY_STRING")
-    if query_string:
-        attributes["http.query"] = query_string
-
-    attributes["url.full"] = get_request_url(environ, use_x_forwarded_for)
-
     url_scheme = environ.get("wsgi.url_scheme")
     if url_scheme:
         attributes["network.protocol.name"] = url_scheme
@@ -420,4 +414,14 @@ def _get_request_attributes(
         if client_ip:
             attributes["client.address"] = client_ip
 
+        query_string = environ.get("QUERY_STRING")
+        if query_string:
+            attributes["http.query"] = query_string
+
+        path = environ.get("PATH_INFO", "")
+        if path:
+            attributes["url.path"] = path
+
+        attributes["url.full"] = get_request_url(environ, use_x_forwarded_for)
+
     return attributes

tests/integrations/aiohttp/test_aiohttp.py

@@ -1137,10 +1137,14 @@ async def handle(_):
 
 
 @pytest.mark.asyncio
-async def test_tracing_span_streaming(sentry_init, aiohttp_client, capture_items):
+@pytest.mark.parametrize("send_pii", [True, False])
+async def test_tracing_span_streaming(
+    sentry_init, aiohttp_client, capture_items, send_pii
+):
     sentry_init(
         integrations=[AioHttpIntegration()],
         traces_sample_rate=1.0,
+        send_default_pii=send_pii,
         _experiments={"trace_lifecycle": "stream"},
     )
 
@@ -1184,13 +1188,25 @@ async def hello(request):
 
     # Request attributes derived directly from the aiohttp request.
     assert server_span["attributes"]["http.request.method"] == "GET"
-    # client.address and user.ip_address is gated on send_default_pii (default False), so it must
-    # not be captured here.
-    assert "client.address" not in server_span["attributes"]
-    assert "user.ip_address" not in server_span["attributes"]
-    url_full = server_span["attributes"]["url.full"]
-    assert url_full.startswith("http://127.0.0.1:")
-    assert url_full.endswith("/")
+
+    if send_pii:
+        assert "client.address" in server_span["attributes"]
+        assert "user.ip_address" in server_span["attributes"]
+
+        url_full = server_span["attributes"]["url.full"]
+        assert url_full.startswith("http://127.0.0.1:")
+        assert url_full.endswith("/")
+
+        url_path = server_span["attributes"]["url.path"]
+        assert url_path == "/"
+    else:
+        assert "url.full" not in server_span["attributes"]
+        assert "url.path" not in server_span["attributes"]
+        assert "url.query" not in server_span["attributes"]
+
+        assert "client.address" not in server_span["attributes"]
+        assert "user.ip_address" not in server_span["attributes"]
+
     # aiohttp's test client always sends a Host header; we assert it propagates
     # into the span attributes via _filter_headers.
     assert "http.request.header.host" in server_span["attributes"]
@@ -1280,12 +1296,14 @@ async def hello(request):
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("send_pii", [True, False])
 async def test_url_query_attribute_span_streaming(
-    sentry_init, aiohttp_client, capture_items
+    sentry_init, aiohttp_client, capture_items, send_pii
 ):
     sentry_init(
         integrations=[AioHttpIntegration()],
         traces_sample_rate=1.0,
+        send_default_pii=send_pii,
         _experiments={"trace_lifecycle": "stream"},
     )
 
@@ -1306,7 +1324,10 @@ async def hello(request):
     assert len(items) == 2
     server_segment, client_segment = [item.payload for item in items]
 
-    assert server_segment["attributes"]["url.query"] == "foo=bar&baz=qux"
+    if send_pii:
+        assert server_segment["attributes"]["url.query"] == "foo=bar&baz=qux"
+    else:
+        assert "url.query" not in server_segment["attributes"]
 
 
 @pytest.mark.asyncio
@@ -1486,12 +1507,14 @@ async def hello(request):
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("send_pii", [True, False])
 async def test_outgoing_client_span_span_streaming(
-    sentry_init, aiohttp_raw_server, aiohttp_client, capture_items
+    sentry_init, aiohttp_raw_server, aiohttp_client, capture_items, send_pii
 ):
     sentry_init(
         integrations=[AioHttpIntegration()],
         traces_sample_rate=1.0,
+        send_default_pii=send_pii,
         _experiments={"trace_lifecycle": "stream"},
     )
 
@@ -1536,14 +1559,19 @@ async def hello(request):
     assert inner_client_span["attributes"]["sentry.origin"] == "auto.http.aiohttp"
     assert inner_client_span["attributes"]["http.request.method"] == "GET"
     assert inner_client_span["attributes"]["http.response.status_code"] == 200
-    assert inner_client_span["attributes"]["url.query"] == "foo=bar"
     assert inner_client_span["status"] == "ok"
 
-    url_full = inner_client_span["attributes"]["url.full"]
-    # parse_url() splits the URL — url.full is the base URL only, with the
-    # query string captured separately on url.query.
-    assert url_full.startswith("http://127.0.0.1:")
-    assert url_full.endswith("/")
+    if send_pii:
+        assert inner_client_span["attributes"]["url.query"] == "foo=bar"
+
+        url_full = inner_client_span["attributes"]["url.full"]
+
+        # parse_url() splits the URL — url.full is the base URL only, with the
+        # query string captured separately on url.query.
+        assert url_full.startswith("http://127.0.0.1:")
+        assert url_full.endswith("/")
+
+        assert inner_client_span["attributes"]["url.path"] == "/"
 
 
 @pytest.mark.asyncio

tests/integrations/asgi/test_asgi.py

@@ -221,6 +221,7 @@ async def test_capture_transaction(
                 span["attributes"]["url.full"]
                 == "http://localhost/some_url?somevalue=123"
             )
+            assert span["attributes"]["url.path"] == "/some_url"
             assert span["attributes"]["http.query"] == "somevalue=123"
 
     else:
@@ -242,6 +243,30 @@ async def test_capture_transaction(
         }
 
 
+@pytest.mark.asyncio
+async def test_capture_transaction_with_root_path(
+    sentry_init,
+    asgi3_app,
+    capture_items,
+):
+    sentry_init(
+        send_default_pii=True,
+        traces_sample_rate=1.0,
+        _experiments={"trace_lifecycle": "stream"},
+    )
+    app = SentryAsgiMiddleware(asgi3_app)
+
+    async with TestClient(app, scope={"root_path": "/api"}) as client:
+        items = capture_items("span")
+        await client.get("/some_url")
+
+    sentry_sdk.flush()
+
+    assert len(items) == 1
+    span = items[0].payload
+    assert span["attributes"]["url.path"] == "/api/some_url"
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "span_streaming",