feat(spans): Copy transaction tags to segment

CHANGELOG.md

@@ -42,6 +42,7 @@
 - Pass `retention_days` in the Kafka profile messages. ([#3362](https://github.com/getsentry/relay/pull/3362))
 - Support and expose namespaces for metric rate limit propagation via the `x-sentry-rate-limits` header. ([#3347](https://github.com/getsentry/relay/pull/3347))
 - Tag span duration metric by group for all ops supporting description scrubbing. ([#3370](https://github.com/getsentry/relay/pull/3370))
+- Copy transaction tags to segment. ([#3386](https://github.com/getsentry/relay/pull/3386))
 - Route spans according to trace_id. ([#3387](https://github.com/getsentry/relay/pull/3387))
 
 ## 24.3.0

relay-event-schema/src/protocol/span/convert.rs

@@ -55,7 +55,7 @@ macro_rules! map_fields {
             fn from(event: &Event) -> Self {
                 Self {
                     $(
-                        $span_field: event.$event_field.clone(),
+                        $span_field: event.$event_field.clone().map_value(Into::into),
                     )*
                     $(
                         $(
@@ -82,7 +82,7 @@ macro_rules! map_fields {
             fn from(span: &Span) -> Self {
                 Self {
                     $(
-                        $event_field: span.$span_field.clone(),
+                        $event_field: span.$span_field.clone().map_value(Into::into),
                     )*
                     $(
                         $fixed_event_field: $fixed_event_value.into(),
@@ -118,6 +118,7 @@ map_fields!(
         span.platform <=> event.platform,
         span.received <=> event.received,
         span.start_timestamp <=> event.start_timestamp,
+        span.tags <=> event.tags,
         span.timestamp <=> event.timestamp
     }
     contexts {
@@ -136,7 +137,7 @@ map_fields!(
     }
     fixed_for_span {
         // A transaction event corresponds to a segment span.
-        span.is_segment <= Some(true),
+        span.is_segment <= true,
         span.was_transaction <= true
     }
     fixed_for_event {

relay-event-schema/src/protocol/tags.rs

@@ -1,9 +1,9 @@
 #[cfg(feature = "jsonschema")]
 use relay_jsonschema_derive::JsonSchema;
-use relay_protocol::{Annotated, Array, Empty, FromValue, IntoValue, Value};
+use relay_protocol::{Annotated, Array, Empty, FromValue, IntoValue, Object, Value};
 
 use crate::processor::ProcessValue;
-use crate::protocol::{AsPair, LenientString, PairList};
+use crate::protocol::{AsPair, JsonLenientString, LenientString, PairList};
 
 #[derive(Clone, Debug, Default, PartialEq, Empty, IntoValue, ProcessValue)]
 #[cfg_attr(feature = "jsonschema", derive(JsonSchema))]
@@ -76,6 +76,30 @@ impl std::ops::DerefMut for Tags {
     }
 }
 
+impl<T: Into<String>> From<Object<T>> for Tags {
+    fn from(value: Object<T>) -> Self {
+        Self(PairList(
+            value
+                .into_iter()
+                .map(|(k, v)| TagEntry(k.into(), v.map_value(|s| s.into())))
+                .map(Annotated::new)
+                .collect(),
+        ))
+    }
+}
+
+impl From<Tags> for Object<JsonLenientString> {
+    fn from(value: Tags) -> Self {
+        value
+            .0
+             .0
+            .into_iter()
+            .flat_map(Annotated::into_value)
+            .flat_map(|p| Some((p.0.into_value()?, p.1.map_value(Into::into))))
+            .collect()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use similar_asserts::assert_eq;

relay-event-schema/src/protocol/types.rs

@@ -886,6 +886,12 @@ impl std::ops::DerefMut for JsonLenientString {
     }
 }
 
+impl From<JsonLenientString> for String {
+    fn from(value: JsonLenientString) -> Self {
+        value.0
+    }
+}
+
 impl FromValue for JsonLenientString {
     fn from_value(value: Annotated<Value>) -> Annotated<Self> {
         match value {

relay-server/src/services/store.rs

@@ -1350,7 +1350,6 @@ struct SpanKafkaMessage<'a> {
     start_timestamp: f64,
     #[serde(rename(deserialize = "timestamp"), skip_serializing)]
     end_timestamp: f64,
-
     #[serde(default, skip_serializing_if = "Option::is_none")]
     description: Option<&'a RawValue>,
     #[serde(default)]
@@ -1385,14 +1384,21 @@ struct SpanKafkaMessage<'a> {
     span_id: &'a str,
     #[serde(default)]
     start_timestamp_ms: u64,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[serde(default, skip_serializing_if = "none_or_empty_object")]
     tags: Option<&'a RawValue>,
     trace_id: EventId,
 
     #[serde(borrow, default, skip_serializing)]
     platform: Cow<'a, str>, // We only use this for logging for now
 }
 
+fn none_or_empty_object(value: &Option<&RawValue>) -> bool {
+    match value {
+        None => true,
+        Some(raw) => raw.get() == "{}",
+    }
+}
+
 #[derive(Debug, Deserialize)]
 struct SpanMetricsSummary {
     #[serde(default)]

tests/integration/test_spans.py

@@ -396,7 +396,8 @@ def test_span_ingestion(
     for span in spans:
         span.pop("received", None)
 
-    spans.sort(key=lambda msg: msg["span_id"])  # endpoint might overtake envelope
+    # endpoint might overtake envelope
+    spans.sort(key=lambda msg: msg["span_id"])
 
     assert spans == [
         {
@@ -1041,7 +1042,8 @@ def test_span_ingestion_with_performance_scores(
     for span in spans:
         span.pop("received", None)
 
-    spans.sort(key=lambda msg: msg["span_id"])  # endpoint might overtake envelope
+    # endpoint might overtake envelope
+    spans.sort(key=lambda msg: msg["span_id"])
 
     assert spans == [
         {
@@ -1210,7 +1212,8 @@ def summarize_outcomes():
     # First send should be accepted.
     relay.send_event(project_id, event)
     spans = list(spans_consumer.get_spans(max_attempts=2, timeout=10))
-    assert len(spans) == 2  # one for the transaction, one for the contained span
+    # one for the transaction, one for the contained span
+    assert len(spans) == 2
     assert summarize_outcomes() == {(16, 0): 2}  # SpanIndexed, Accepted
 
     # Second send should be rejected immediately.
@@ -1287,3 +1290,60 @@ def summarize_outcomes():
 
     spans_consumer.assert_empty()
     outcomes_consumer.assert_empty()
+
+
+@pytest.mark.parametrize(
+    "tags, expected_tags",
+    [
+        (
+            {
+                "some": "tag",
+                "other": "value",
+            },
+            {
+                "some": "tag",
+                "other": "value",
+            },
+        ),
+        (
+            {
+                "some": 1,
+                "other": True,
+            },
+            {
+                "some": "1",
+                "other": "True",
+            },
+        ),
+    ],
+)
+def test_span_extraction_with_tags(
+    mini_sentry,
+    relay_with_processing,
+    spans_consumer,
+    tags,
+    expected_tags,
+):
+    spans_consumer = spans_consumer()
+
+    relay = relay_with_processing()
+    project_id = 42
+    project_config = mini_sentry.add_full_project_config(project_id)
+    project_config["config"]["features"] = [
+        "projects:span-metrics-extraction",
+    ]
+
+    event = make_transaction(
+        {
+            "event_id": "e022a2da91e9495d944c291fe065972d",
+            "tags": tags,
+        }
+    )
+
+    relay.send_event(project_id, event)
+
+    transaction_span = spans_consumer.get_span()
+
+    assert transaction_span["tags"] == expected_tags
+
+    spans_consumer.assert_empty()