feat(integrations): Add http.route attribute to server spans

sentry_sdk/consts.py

@@ -878,6 +878,12 @@ class SPANDATA:
     Example: GET
     """
 
+    HTTP_ROUTE = "http.route"
+    """
+    The matched route, that is, the path template used to match the request.
+    Example: /users/{id}
+    """
+
     HTTP_QUERY = "http.query"
     """
     The Query string present in the URL.

sentry_sdk/integrations/aiohttp.py

@@ -29,6 +29,7 @@
     SegmentNameSource,
     SpanStatus,
     StreamedSpan,
+    get_current_span,
 )
 from sentry_sdk.tracing import (
     BAGGAGE_HEADER_NAME,
@@ -327,6 +328,7 @@
                 return rv
 
             name = None
+            http_route = None
 
             try:
                 if integration.transaction_style == "handler_name":
@@ -335,20 +337,25 @@
                     route_info = rv.get_info()
                     pattern = route_info.get("path") or route_info.get("formatter")
                     name = "{} {}".format(request.method, pattern)
+                    http_route = pattern
             except Exception:
                 pass
 
             if name is not None:
-                current_span = sentry_sdk.get_current_span()
+                current_span = get_current_span()
                 if isinstance(current_span, StreamedSpan) and not isinstance(
                     current_span, NoOpStreamedSpan
                 ):
                     current_span._segment.name = name
                     current_span._segment.set_attribute(
                         "sentry.segment.name.source",
                         SEGMENT_SOURCE_FOR_STYLE[integration.transaction_style].value,
                     )
+                    if http_route is not None:
+                        current_span._segment.set_attribute(
+                            SPANDATA.HTTP_ROUTE, http_route
+                        )
                 else:
                     current_scope = sentry_sdk.get_current_scope()
                     current_scope.set_transaction_name(
                         name,

sentry_sdk/integrations/asgi.py

@@ -246,13 +246,19 @@ async def _run_app(
                     span_ctx: "ContextManager[Union[Span, StreamedSpan, None]]"
                     if span_streaming:
                         segment: "Optional[StreamedSpan]" = None
+                        segment_source = getattr(
+                            transaction_source, "value", transaction_source
+                        )
                         attributes: "Attributes" = {
-                            "sentry.segment.name.source": getattr(
-                                transaction_source, "value", transaction_source
-                            ),
+                            "sentry.segment.name.source": segment_source,
                             "sentry.origin": self.span_origin,
                             "network.protocol.name": ty,
                         }
+                        if (
+                            segment_source == SegmentNameSource.ROUTE.value
+                            and transaction_name != _DEFAULT_TRANSACTION_NAME
+                        ):
+                            attributes[SPANDATA.HTTP_ROUTE] = transaction_name
 
                         if scope.get("client"):
                             client_options = sentry_sdk.get_client().options
@@ -412,6 +418,13 @@ async def _sentry_wrapped_send(
                                         span.set_attribute(
                                             "sentry.segment.name.source", source
                                         )
+                                        if (
+                                            source == SegmentNameSource.ROUTE.value
+                                            and name != _DEFAULT_TRANSACTION_NAME
+                                        ):
+                                            span.set_attribute(
+                                                SPANDATA.HTTP_ROUTE, name
+                                            )
         finally:
             _asgi_middleware_applied.set(False)
 

sentry_sdk/integrations/bottle.py

@@ -2,6 +2,7 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import (
     _DEFAULT_FAILED_REQUEST_STATUS_CODES,
     DidNotEnable,
@@ -10,8 +11,15 @@
 )
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
-from sentry_sdk.traces import SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE
-from sentry_sdk.tracing import SOURCE_FOR_STYLE as TRANSACTION_SOURCE_FOR_STYLE
+from sentry_sdk.traces import (
+    SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE,
+)
+from sentry_sdk.traces import (
+    SegmentNameSource,
+)
+from sentry_sdk.tracing import (
+    SOURCE_FOR_STYLE as TRANSACTION_SOURCE_FOR_STYLE,
+)
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     capture_internal_exceptions,
@@ -181,9 +189,15 @@ def _set_segment_name_and_source(transaction_style: str) -> None:
                 or "bottle request"
             )
 
+        source = SEGMENT_SOURCE_FOR_STYLE[transaction_style]
+        if source == SegmentNameSource.ROUTE:
+            sentry_sdk.get_current_scope().set_segment_attribute(
+                SPANDATA.HTTP_ROUTE, name
+            )
+
         sentry_sdk.get_current_scope().set_transaction_name(
             name,
-            source=SEGMENT_SOURCE_FOR_STYLE[transaction_style],
+            source=source,
         )
     except RuntimeError:
         pass

sentry_sdk/integrations/django/__init__.py

@@ -472,6 +472,8 @@ def _set_transaction_name_and_source(
             source = TransactionSource.URL
         else:
             source = SOURCE_FOR_STYLE[transaction_style]
+            if source == TransactionSource.ROUTE:
+                scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, transaction_name)
 
         scope.set_transaction_name(
             transaction_name,

sentry_sdk/integrations/falcon.py

@@ -1,9 +1,11 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
+from sentry_sdk.traces import SegmentNameSource
 from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
@@ -122,7 +124,10 @@ def process_resource(
         }
         name = name_for_style[integration.transaction_style]
         source = sentry_sdk.traces.SOURCE_FOR_STYLE[integration.transaction_style]
-        sentry_sdk.set_transaction_name(name, source)
+        scope = sentry_sdk.get_current_scope()
+        if source == SegmentNameSource.ROUTE:
+            scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
+        scope.set_transaction_name(name, source)
 
 
 TRANSACTION_STYLE_VALUES = ("uri_template", "path")

sentry_sdk/integrations/fastapi.py

@@ -84,6 +84,8 @@ def _set_transaction_name_and_source(
         source = TransactionSource.ROUTE
     else:
         source = SOURCE_FOR_STYLE[transaction_style]
+        if source == TransactionSource.ROUTE:
+            scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
 
     scope.set_transaction_name(name, source=source)
 

sentry_sdk/integrations/flask.py

@@ -1,14 +1,15 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
     RequestExtractor,
 )
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
+from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -134,10 +135,11 @@ def _set_transaction_name_and_source(
             "url": request.url_rule.rule,
             "endpoint": request.url_rule.endpoint,
         }
-        scope.set_transaction_name(
-            name_for_style[transaction_style],
-            source=SOURCE_FOR_STYLE[transaction_style],
-        )
+        name = name_for_style[transaction_style]
+        source = SOURCE_FOR_STYLE[transaction_style]
+        if source == TransactionSource.ROUTE:
+            scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
+        scope.set_transaction_name(name, source=source)
     except Exception:
         pass
 

sentry_sdk/integrations/pyramid.py

@@ -4,11 +4,17 @@
 import weakref
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.traces import SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE
+from sentry_sdk.traces import (
+    SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE,
+)
+from sentry_sdk.traces import (
+    SegmentNameSource,
+)
 from sentry_sdk.tracing import SOURCE_FOR_STYLE as TRANSACTION_SOURCE_FOR_STYLE
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
@@ -182,8 +188,12 @@ def _set_transaction_name_and_source(
             if is_span_streaming_enabled
             else TRANSACTION_SOURCE_FOR_STYLE[transaction_style]
         )
+        name = name_for_style[transaction_style]
+        if source == SegmentNameSource.ROUTE:
+            scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
+
         scope.set_transaction_name(
-            name_for_style[transaction_style],
+            name,
             source=source,
         )
     except Exception:

sentry_sdk/integrations/quart.py

@@ -5,14 +5,20 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.data_collection import _apply_data_collection_filtering_to_query_string
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations._wsgi_common import _filter_headers
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.traces import SOURCE_FOR_STYLE as SEGMENT_SOURCE_FOR_STYLE
-from sentry_sdk.traces import StreamedSpan, get_current_span
-from sentry_sdk.tracing import SOURCE_FOR_STYLE as TRANSACTION_SOURCE_FOR_STYLE
+from sentry_sdk.traces import SegmentNameSource, StreamedSpan, get_current_span
+from sentry_sdk.tracing import (
+    SOURCE_FOR_STYLE as TRANSACTION_SOURCE_FOR_STYLE,
+)
+from sentry_sdk.tracing import (
+    TransactionSource,
+)
 from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     capture_internal_exceptions,
@@ -163,8 +169,12 @@ def _set_transaction_name_and_source(
             else TRANSACTION_SOURCE_FOR_STYLE[transaction_style]
         )
 
+        name = name_for_style[transaction_style]
+        if source in (TransactionSource.ROUTE, SegmentNameSource.ROUTE):
+            scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
+
         scope.set_transaction_name(
-            name=name_for_style[transaction_style],
+            name=name,
             source=source,
         )
     except Exception:

sentry_sdk/integrations/starlette.py

@@ -880,6 +880,8 @@ def _set_transaction_name_and_source(
     if name is None:
         name = _DEFAULT_TRANSACTION_NAME
         source = TransactionSource.ROUTE
+    elif source == TransactionSource.ROUTE:
+        scope.set_segment_attribute(SPANDATA.HTTP_ROUTE, name)
 
     scope.set_transaction_name(name, source=source)
 

sentry_sdk/scope.py

@@ -2053,6 +2053,20 @@ def set_attributes(self, attributes: "dict[str, AttributeValue]") -> None:
         for attribute, value in attributes.items():
             self.set_attribute(attribute, value)
 
+    def set_segment_attribute(self, key: str, value: "AttributeValue") -> None:
+        """
+        Set an attribute on the active segment span (the root of the trace in
+        this service).
+
+        Unlike :py:meth:`set_attribute`, which applies to all telemetry captured
+        while the scope is active, this sets the attribute on the segment span
+        only.
+
+        This method has no effect outside of span streaming mode.
+        """
+        if isinstance(self._span, StreamedSpan):
+            self._span._segment.set_attribute(key, value)
+
     def remove_attribute(self, attribute: str) -> None:
         """Remove an attribute if set on the scope. No-op if there is no such attribute."""
         try:

tests/integrations/aiohttp/test_aiohttp.py

@@ -1877,6 +1877,10 @@ async def hello(request):
     assert server_segment["name"] == expected_name
     assert server_segment["is_segment"]
     assert server_segment["attributes"]["sentry.segment.name.source"] == expected_source
+    if expected_source == "route":
+        assert server_segment["attributes"]["http.route"] == "/{var}"
+    else:
+        assert "http.route" not in server_segment["attributes"]
 
 
 @pytest.mark.asyncio

tests/integrations/asgi/test_asgi.py

@@ -670,6 +670,7 @@ async def test_transaction_style(
 
         assert span["name"] == expected_transaction
         assert span["attributes"]["sentry.segment.name.source"] == expected_source
+        assert "http.route" not in span["attributes"]
 
     else:
         (transaction_event,) = events
@@ -678,6 +679,40 @@ async def test_transaction_style(
         assert transaction_event["transaction_info"] == {"source": expected_source}
 
 
+@pytest.mark.asyncio
+async def test_http_route_set_for_route_segment_name(
+    sentry_init,
+    asgi3_app,
+    capture_items,
+):
+    sentry_init(
+        traces_sample_rate=1.0,
+        trace_lifecycle="stream",
+    )
+    app = SentryAsgiMiddleware(asgi3_app, transaction_style="url")
+
+    class Route:
+        path = "/message/{message_id}"
+
+    scope = {
+        "endpoint": asgi3_app,
+        "route": Route(),
+        "client": ("127.0.0.1", 60457),
+    }
+
+    async with TestClient(app, scope=scope) as client:
+        items = capture_items("span")
+        await client.get("/message/123456")
+
+    sentry_sdk.flush()
+
+    assert len(items) == 1
+    span = items[0].payload
+    assert span["name"] == "/message/{message_id}"
+    assert span["attributes"]["sentry.segment.name.source"] == "route"
+    assert span["attributes"]["http.route"] == "/message/{message_id}"
+
+
 def mock_asgi2_app():
     pass
 

tests/integrations/bottle/test_bottle.py

@@ -660,6 +660,10 @@ def named_hi():
 
     assert segment["name"].endswith(expected_name)
     assert segment["attributes"]["sentry.segment.name.source"] == expected_source
+    if expected_source == "route":
+        assert segment["attributes"]["http.route"] == expected_name
+    else:
+        assert "http.route" not in segment["attributes"]
 
 
 def test_span_streaming_with_error(sentry_init, capture_items):

tests/integrations/django/test_basic.py

@@ -1083,6 +1083,10 @@ def test_transaction_style(
 
         assert spans[2]["is_segment"] is True
         assert spans[2]["attributes"]["sentry.segment.name.source"] == expected_source
+        if expected_source == "route":
+            assert spans[2]["attributes"]["http.route"] == expected_transaction
+        else:
+            assert "http.route" not in spans[2]["attributes"]
 
         (event,) = (item.payload for item in items if item.type == "event")
     else: