feat(ai): Conditionally set total_cost and total_tokens attributes (#4868)

Currently we always set `total_cost` and `total_tokens` attributes on
every AI span, even if `input_tokens` or `output_tokens` are not
present.

At the moment, that is not the behavior we want, since for example we
have spans that are just invoking agent and it has no cost nor any
tokens are used, so setting this attributes is wrong.

This also shows up then in UI and additionally confusing users

Author: vgrozdanic

CHANGELOG.md

@@ -17,6 +17,7 @@
 - Derive a `sentry.description` attribute for V2 spans ([#4832](https://github.com/getsentry/relay/pull/4832))
 - Consider `gen_ai` also as AI span op prefix. ([#4859](https://github.com/getsentry/relay/pull/4859))
 - Change pii scrubbing on some AI attributes to optional ([#4860](https://github.com/getsentry/relay/pull/4860))
+- Conditionally set `total_cost` and `total_tokens` attributes on AI spans. ([#4868](https://github.com/getsentry/relay/pull/4868))
 
 ## 25.6.1
 

relay-event-normalization/src/event.rs

@@ -2410,6 +2410,72 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_ai_data_with_no_tokens() {
+        let json = r#"
+            {
+                "spans": [
+                    {
+                        "timestamp": 1702474613.0495,
+                        "start_timestamp": 1702474613.0175,
+                        "description": "OpenAI ",
+                        "op": "gen_ai.invoke_agent",
+                        "span_id": "9c01bd820a083e63",
+                        "parent_span_id": "a1e13f3f06239d69",
+                        "trace_id": "922dda2462ea4ac2b6a4b339bee90863",
+                        "data": {
+                            "gen_ai.request.model": "claude-2.1"
+                        }
+                    }
+                ]
+            }
+        "#;
+
+        let mut event = Annotated::<Event>::from_json(json).unwrap();
+
+        normalize_event(
+            &mut event,
+            &NormalizationConfig {
+                ai_model_costs: Some(&ModelCosts {
+                    version: 2,
+                    costs: vec![],
+                    models: HashMap::from([(
+                        "claude-2.1".to_owned(),
+                        ModelCostV2 {
+                            input_per_token: 0.01,
+                            output_per_token: 0.02,
+                            output_reasoning_per_token: 0.03,
+                            input_cached_per_token: 0.0,
+                        },
+                    )]),
+                }),
+                ..NormalizationConfig::default()
+            },
+        );
+
+        let spans = event.value().unwrap().spans.value().unwrap();
+
+        assert_eq!(spans.len(), 1);
+        // total_cost shouldn't be set if no tokens are present on span data
+        assert_eq!(
+            spans
+                .first()
+                .and_then(|span| span.value())
+                .and_then(|span| span.data.value())
+                .and_then(|data| data.gen_ai_usage_total_cost.value()),
+            None
+        );
+        // total_tokens shouldn't be set if no tokens are present on span data
+        assert_eq!(
+            spans
+                .first()
+                .and_then(|span| span.value())
+                .and_then(|span| span.data.value())
+                .and_then(|data| data.gen_ai_usage_total_tokens.value()),
+            None
+        );
+    }
+
     #[test]
     fn test_ai_data_with_ai_op_prefix() {
         let json = r#"

relay-event-normalization/src/normalize/span/ai.rs

@@ -11,31 +11,32 @@ fn calculate_ai_model_cost(model_cost: Option<ModelCostV2>, data: &SpanData) ->
     let input_tokens_used = data
         .gen_ai_usage_input_tokens
         .value()
-        .and_then(Value::as_f64)
-        .unwrap_or(0.0);
+        .and_then(Value::as_f64);
 
     let output_tokens_used = data
         .gen_ai_usage_output_tokens
         .value()
-        .and_then(Value::as_f64)
-        .unwrap_or(0.0);
+        .and_then(Value::as_f64);
     let output_reasoning_tokens_used = data
         .gen_ai_usage_output_tokens_reasoning
         .value()
-        .and_then(Value::as_f64)
-        .unwrap_or(0.0);
+        .and_then(Value::as_f64);
     let input_cached_tokens_used = data
         .gen_ai_usage_input_tokens_cached
         .value()
-        .and_then(Value::as_f64)
-        .unwrap_or(0.0);
+        .and_then(Value::as_f64);
+
+    if input_tokens_used.is_none() && output_tokens_used.is_none() {
+        return None;
+    }
 
     let mut result = 0.0;
 
-    result += cost_per_token.input_per_token * input_tokens_used;
-    result += cost_per_token.output_per_token * output_tokens_used;
-    result += cost_per_token.output_reasoning_per_token * output_reasoning_tokens_used;
-    result += cost_per_token.input_cached_per_token * input_cached_tokens_used;
+    result += cost_per_token.input_per_token * input_tokens_used.unwrap_or(0.0);
+    result += cost_per_token.output_per_token * output_tokens_used.unwrap_or(0.0);
+    result +=
+        cost_per_token.output_reasoning_per_token * output_reasoning_tokens_used.unwrap_or(0.0);
+    result += cost_per_token.input_cached_per_token * input_cached_tokens_used.unwrap_or(0.0);
 
     Some(result)
 }
@@ -72,15 +73,20 @@ pub fn map_ai_measurements_to_data(span: &mut Span) {
         let input_tokens = data
             .gen_ai_usage_input_tokens
             .value()
-            .and_then(Value::as_f64)
-            .unwrap_or(0.0);
+            .and_then(Value::as_f64);
         let output_tokens = data
             .gen_ai_usage_output_tokens
             .value()
-            .and_then(Value::as_f64)
-            .unwrap_or(0.0);
-        data.gen_ai_usage_total_tokens
-            .set_value(Value::F64(input_tokens + output_tokens).into());
+            .and_then(Value::as_f64);
+
+        if input_tokens.is_none() && output_tokens.is_none() {
+            // don't set total_tokens if there are no input nor output tokens
+            return;
+        }
+
+        data.gen_ai_usage_total_tokens.set_value(
+            Value::F64(input_tokens.unwrap_or(0.0) + output_tokens.unwrap_or(0.0)).into(),
+        );
     }
 }