fix(eap): Handle user attributes colliding with sentry attributes (#95369)

Zylphrex · web-flow · commit 64777364d91a · 2025-07-14T20:28:40.000Z
Users can send custom attributes that happen to be named the same as the
public aliases as sentry attributes. For example, they can name an
attribute `timestamp`. When this happens, we should not return its key
as `timestamp`. Instead, we should return it as `tags[{name},{type}]` to
disambiguate it from the sentry defined attribute.
diff --git a/src/sentry/search/eap/utils.py b/src/sentry/search/eap/utils.py
@@ -12,6 +12,7 @@
 from sentry_protos.snuba.v1.trace_item_attribute_pb2 import Function
 
 from sentry.exceptions import InvalidSearchQuery
+from sentry.search.eap.columns import ResolvedAttribute
 from sentry.search.eap.constants import SAMPLING_MODE_MAP
 from sentry.search.eap.ourlogs.attributes import (
     LOGS_INTERNAL_TO_PUBLIC_ALIAS_MAPPINGS,
@@ -20,8 +21,10 @@
     LOGS_PRIVATE_ATTRIBUTES,
     LOGS_REPLACEMENT_ATTRIBUTES,
     LOGS_REPLACEMENT_MAP,
+    OURLOG_ATTRIBUTE_DEFINITIONS,
 )
 from sentry.search.eap.spans.attributes import (
+    SPAN_ATTRIBUTE_DEFINITIONS,
     SPAN_INTERNAL_TO_SECONDARY_ALIASES_MAPPING,
     SPANS_INTERNAL_TO_PUBLIC_ALIAS_MAPPINGS,
     SPANS_PRIVATE_ATTRIBUTE_PREFIXES,
@@ -124,6 +127,11 @@ def validate_sampling(sampling_mode: SAMPLING_MODES | None) -> DownsampledStorag
     SupportedTraceItemType.LOGS: LOGS_INTERNAL_TO_PUBLIC_ALIAS_MAPPINGS,
 }
 
+PUBLIC_ALIAS_TO_INTERNAL_MAPPING: dict[SupportedTraceItemType, dict[str, ResolvedAttribute]] = {
+    SupportedTraceItemType.SPANS: SPAN_ATTRIBUTE_DEFINITIONS,
+    SupportedTraceItemType.LOGS: OURLOG_ATTRIBUTE_DEFINITIONS,
+}
+
 
 PRIVATE_ATTRIBUTES: dict[SupportedTraceItemType, set[str]] = {
     SupportedTraceItemType.SPANS: SPANS_PRIVATE_ATTRIBUTES,
@@ -158,7 +166,17 @@ def translate_internal_to_public_alias(
     item_type: SupportedTraceItemType,
 ) -> str | None:
     mapping = INTERNAL_TO_PUBLIC_ALIAS_MAPPINGS.get(item_type, {}).get(type, {})
-    return mapping.get(internal_alias)
+    public_alias = mapping.get(internal_alias)
+    if public_alias is not None:
+        return public_alias
+
+    resolved_column = PUBLIC_ALIAS_TO_INTERNAL_MAPPING.get(item_type, {}).get(internal_alias)
+    if resolved_column is not None:
+        # if there is a known public alias with this exact name, it means we need to wrap
+        # it in the explicitly typed tags syntax in order for it to reference the correct column
+        return f"tags[{internal_alias},{type}]"
+
+    return None
 
 
 def get_secondary_aliases(
diff --git a/tests/snuba/api/endpoints/test_organization_trace_item_attributes.py b/tests/snuba/api/endpoints/test_organization_trace_item_attributes.py
@@ -159,7 +159,7 @@ def test_body_attribute(self):
 
         assert response.status_code == 200, response.content
         keys = {item["key"] for item in response.data}
-        assert keys == {"severity", "message", "project"}
+        assert keys == {"severity", "message", "project", "tags[message,string]"}
 
     def test_disallowed_attributes(self):
         logs = [
@@ -181,6 +181,29 @@ def test_disallowed_attributes(self):
         keys = {item["key"] for item in response.data}
         assert keys == {"severity", "message", "project", "sentry.item_type2"}
 
+    def test_attribute_collision(self):
+        logs = [
+            self.create_ourlog(
+                organization=self.organization,
+                project=self.project,
+                attributes={"timestamp": "bar", "severity": "baz"},
+            ),
+        ]
+
+        self.store_ourlogs(logs)
+
+        response = self.do_request()
+
+        assert response.status_code == 200, response.content
+        keys = {item["key"] for item in response.data}
+        assert keys == {
+            "message",
+            "project",
+            "severity",
+            "tags[severity,string]",
+            "tags[timestamp,string]",
+        }
+
 
 class OrganizationTraceItemAttributesEndpointSpansTest(
     OrganizationTraceItemAttributesEndpointTestBase, BaseSpansTestCase
@@ -465,6 +488,39 @@ def test_tags_list_sentry_conventions(self):
             key=itemgetter("key"),
         )
 
+    def test_attribute_collision(self):
+        self.store_segment(
+            self.project.id,
+            uuid4().hex,
+            uuid4().hex,
+            span_id=uuid4().hex[:16],
+            organization_id=self.organization.id,
+            parent_span_id=None,
+            timestamp=before_now(days=0, minutes=10).replace(microsecond=0),
+            transaction="foo",
+            duration=100,
+            exclusive_time=100,
+            tags={
+                "span.op": "foo",
+                "span.duration": "bar",
+            },
+            is_eap=True,
+        )
+
+        response = self.do_request()
+        assert response.status_code == 200, response.data
+        assert response.data == [
+            {
+                "key": "span.description",
+                "name": "span.description",
+                "secondaryAliases": ["description", "message"],
+            },
+            {"key": "project", "name": "project"},
+            {"key": "transaction", "name": "transaction"},
+            {"key": "tags[span.duration,string]", "name": "tags[span.duration,string]"},
+            {"key": "tags[span.op,string]", "name": "tags[span.op,string]"},
+        ]
+
 
 class OrganizationTraceItemAttributeValuesEndpointBaseTest(APITestCase, SnubaTestCase):
     feature_flags: dict[str, bool]
diff --git a/tests/snuba/api/endpoints/test_project_trace_item_details.py b/tests/snuba/api/endpoints/test_project_trace_item_details.py
@@ -7,7 +7,7 @@
 from sentry.testutils.helpers.datetime import before_now
 
 
-class ProjectEventDetailsTest(APITestCase, SnubaTestCase, OurLogTestCase, SpanTestCase):
+class ProjectTraceItemDetailsEndpointTest(APITestCase, SnubaTestCase, OurLogTestCase, SpanTestCase):
     def setUp(self):
         super().setUp()
         self.login_as(user=self.user)
@@ -38,47 +38,27 @@ def do_request(self, event_type: str, item_id: str, features=None):
             )
 
     def test_simple(self):
-        logs = [
-            self.create_ourlog(
-                {
-                    "body": "foo",
-                    "trace_id": self.trace_uuid,
+        log = self.create_ourlog(
+            {
+                "body": "foo",
+                "trace_id": self.trace_uuid,
+            },
+            attributes={
+                "str_attr": {
+                    "string_value": "1",
                 },
-                attributes={
-                    "str_attr": {
-                        "string_value": "1",
-                    },
-                    "int_attr": {"int_value": 2},
-                    "float_attr": {
-                        "double_value": 3.0,
-                    },
-                    "bool_attr": {
-                        "bool_value": True,
-                    },
+                "int_attr": {"int_value": 2},
+                "float_attr": {
+                    "double_value": 3.0,
+                },
+                "bool_attr": {
+                    "bool_value": True,
                 },
-                timestamp=self.one_min_ago,
-            ),
-        ]
-        self.store_ourlogs(logs)
-        item_list_url = reverse(
-            "sentry-api-0-organization-events",
-            kwargs={
-                "organization_id_or_slug": self.project.organization.slug,
             },
+            timestamp=self.one_min_ago,
         )
-        with self.feature(self.features):
-            item_list_response = self.client.get(
-                item_list_url,
-                {
-                    "field": ["message", "sentry.item_id", "sentry.trace_id"],
-                    "query": "",
-                    "orderby": "sentry.item_id",
-                    "project": self.project.id,
-                    "dataset": "ourlogs",
-                },
-            )
-        assert item_list_response.data is not None
-        item_id = item_list_response.data["data"][0]["sentry.item_id"]
+        self.store_ourlogs([log])
+        item_id = uuid.UUID(bytes=bytes(reversed(log.item_id))).hex
 
         trace_details_response = self.do_request("logs", item_id)
 
@@ -113,47 +93,27 @@ def test_simple(self):
         )
 
     def test_simple_using_logs_item_type(self):
-        logs = [
-            self.create_ourlog(
-                {
-                    "body": "foo",
-                    "trace_id": self.trace_uuid,
+        log = self.create_ourlog(
+            {
+                "body": "foo",
+                "trace_id": self.trace_uuid,
+            },
+            attributes={
+                "str_attr": {
+                    "string_value": "1",
                 },
-                attributes={
-                    "str_attr": {
-                        "string_value": "1",
-                    },
-                    "int_attr": {"int_value": 2},
-                    "float_attr": {
-                        "double_value": 3.0,
-                    },
-                    "bool_attr": {
-                        "bool_value": True,
-                    },
+                "int_attr": {"int_value": 2},
+                "float_attr": {
+                    "double_value": 3.0,
+                },
+                "bool_attr": {
+                    "bool_value": True,
                 },
-                timestamp=self.one_min_ago,
-            ),
-        ]
-        self.store_ourlogs(logs)
-        item_list_url = reverse(
-            "sentry-api-0-organization-events",
-            kwargs={
-                "organization_id_or_slug": self.project.organization.slug,
             },
+            timestamp=self.one_min_ago,
         )
-        with self.feature(self.features):
-            item_list_response = self.client.get(
-                item_list_url,
-                {
-                    "field": ["message", "sentry.item_id", "sentry.trace_id"],
-                    "query": "",
-                    "orderby": "sentry.item_id",
-                    "project": self.project.id,
-                    "dataset": "ourlogs",
-                },
-            )
-        assert item_list_response.data is not None
-        item_id = item_list_response.data["data"][0]["sentry.item_id"]
+        self.store_ourlogs([log])
+        item_id = uuid.UUID(bytes=bytes(reversed(log.item_id))).hex
 
         trace_details_response = self.do_request("logs", item_id)
 
@@ -325,49 +285,29 @@ def test_simple_using_spans_item_type_with_sentry_conventions(self):
         )
 
     def test_logs_with_a_meta_key(self):
-        logs = [
-            self.create_ourlog(
-                {
-                    "body": "[Filtered]",
-                    "trace_id": self.trace_uuid,
+        log = self.create_ourlog(
+            {
+                "body": "[Filtered]",
+                "trace_id": self.trace_uuid,
+            },
+            attributes={
+                "str_attr": {
+                    "string_value": "1",
                 },
-                attributes={
-                    "str_attr": {
-                        "string_value": "1",
-                    },
-                    "sentry._meta.fields.attributes.sentry.body": '{"length": 300, "reason": "value too long"}',
-                    "sentry._meta.fields.attributes.float_attr": '{"unit": "float"}',
-                    "int_attr": {"int_value": 2},
-                    "float_attr": {
-                        "double_value": 3.0,
-                    },
-                    "bool_attr": {
-                        "bool_value": True,
-                    },
+                "sentry._meta.fields.attributes.sentry.body": '{"length": 300, "reason": "value too long"}',
+                "sentry._meta.fields.attributes.float_attr": '{"unit": "float"}',
+                "int_attr": {"int_value": 2},
+                "float_attr": {
+                    "double_value": 3.0,
+                },
+                "bool_attr": {
+                    "bool_value": True,
                 },
-                timestamp=self.one_min_ago,
-            ),
-        ]
-        self.store_ourlogs(logs)
-        item_list_url = reverse(
-            "sentry-api-0-organization-events",
-            kwargs={
-                "organization_id_or_slug": self.project.organization.slug,
             },
+            timestamp=self.one_min_ago,
         )
-        with self.feature(self.features):
-            item_list_response = self.client.get(
-                item_list_url,
-                {
-                    "field": ["message", "sentry.item_id", "sentry.trace_id"],
-                    "query": "",
-                    "orderby": "sentry.item_id",
-                    "project": self.project.id,
-                    "dataset": "ourlogs",
-                },
-            )
-        assert item_list_response.data is not None
-        item_id = item_list_response.data["data"][0]["sentry.item_id"]
+        self.store_ourlogs([log])
+        item_id = uuid.UUID(bytes=bytes(reversed(log.item_id))).hex
 
         trace_details_response = self.do_request("logs", item_id)
 
@@ -407,3 +347,49 @@ def test_logs_with_a_meta_key(self):
             ).isoformat()
             + "Z",
         }
+
+    def test_user_attributes_collide_with_sentry_attributes(self):
+        log = self.create_ourlog(
+            {
+                "body": "foo",
+                "trace_id": self.trace_uuid,
+            },
+            attributes={"timestamp": "bar", "severity": "baz"},
+            timestamp=self.one_min_ago,
+        )
+
+        self.store_ourlogs([log])
+        item_id = uuid.UUID(bytes=bytes(reversed(log.item_id))).hex
+
+        trace_details_response = self.do_request("logs", item_id)
+        assert trace_details_response.status_code == 200, trace_details_response.content
+
+        timestamp_nanos = int(self.one_min_ago.timestamp() * 1_000_000_000)
+        assert trace_details_response.data == {
+            "attributes": [
+                {"name": "project_id", "type": "int", "value": str(self.project.id)},
+                {"name": "severity_number", "type": "int", "value": "0"},
+                {
+                    "name": "tags[sentry.timestamp_nanos,number]",
+                    "type": "int",
+                    "value": str(timestamp_nanos),
+                },
+                {
+                    "name": "tags[sentry.timestamp_precise,number]",
+                    "type": "int",
+                    "value": str(timestamp_nanos),
+                },
+                {"name": "message", "type": "str", "value": "foo"},
+                {"name": "severity", "type": "str", "value": "INFO"},
+                {"name": "tags[severity,string]", "type": "str", "value": "baz"},
+                {"name": "tags[timestamp,string]", "type": "str", "value": "bar"},
+                {"name": "trace", "type": "str", "value": self.trace_uuid},
+            ],
+            "meta": {},
+            "itemId": item_id,
+            "timestamp": self.one_min_ago.replace(
+                microsecond=0,
+                tzinfo=None,
+            ).isoformat()
+            + "Z",
+        }
