Fix TraceTransaction deserialization: API returns snake_case, not camelCase

- Remove #[serde(rename_all = "camelCase")] from TraceTransaction
- Fix field renames: span.op → transaction.op, span.duration → transaction.duration
- Make span_description and span_status optional with #[serde(default)]
- Add missing fields: parent_event_id, generation, profiler_id, performance_issues
- Update all tests to use snake_case field names matching real API
- Add reproduction test with actual API response format
- Bump version to 0.2.5

Author: utapyngo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sentry-mcp"
-version = "0.2.4"
+version = "0.2.5"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/utapyngo/sentry-mcp-rs"

Cargo.toml

@@ -123,16 +123,13 @@ pub struct TraceResponse {
 }
 
 #[derive(Debug, Clone, Deserialize)]
-#[serde(rename_all = "camelCase")]
 #[allow(dead_code)]
 pub struct TraceTransaction {
     pub event_id: String,
     pub project_id: i64,
     pub project_slug: String,
     pub transaction: String,
-    #[serde(rename = "start_timestamp")]
     pub start_timestamp: f64,
-    #[serde(rename = "sdk.name")]
     pub sdk_name: Option<String>,
     pub timestamp: f64,
     #[serde(default)]
@@ -141,14 +138,20 @@ pub struct TraceTransaction {
     pub errors: Vec<serde_json::Value>,
     pub span_id: Option<String>,
     pub parent_span_id: Option<String>,
-    #[serde(rename = "span.op")]
+    pub parent_event_id: Option<String>,
+    #[serde(default)]
+    pub generation: i32,
+    pub profiler_id: Option<String>,
+    #[serde(default)]
+    pub performance_issues: Vec<serde_json::Value>,
+    #[serde(rename = "transaction.op")]
     pub span_op: Option<String>,
-    #[serde(rename = "span.description")]
+    #[serde(rename = "transaction.duration")]
+    pub span_duration: Option<f64>,
+    #[serde(default)]
     pub span_description: Option<String>,
-    #[serde(rename = "span.status")]
+    #[serde(default)]
     pub span_status: Option<String>,
-    #[serde(rename = "span.duration")]
-    pub span_duration: Option<f64>,
 }
 
 #[derive(Debug, Serialize)]
@@ -404,9 +407,9 @@ mod tests {
         let mock_server = MockServer::start().await;
         let response = r#"{
             "transactions": [{
-                "eventId": "tx1",
-                "projectId": 1,
-                "projectSlug": "test",
+                "event_id": "tx1",
+                "project_id": 1,
+                "project_slug": "test",
                 "transaction": "GET /api",
                 "start_timestamp": 1704067200.0,
                 "timestamp": 1704067201.0

src/api_client.rs

@@ -178,9 +178,9 @@ fn test_trace_response_deserialize_empty() {
 #[test]
 fn test_trace_transaction_deserialize_minimal() {
     let json = json!({
-        "eventId": "abc123",
-        "projectId": 1,
-        "projectSlug": "proj",
+        "event_id": "abc123",
+        "project_id": 1,
+        "project_slug": "proj",
         "transaction": "test-tx",
         "start_timestamp": 1000.0,
         "timestamp": 1001.0
@@ -197,46 +197,42 @@ fn test_trace_transaction_deserialize_minimal() {
 #[test]
 fn test_trace_transaction_deserialize_full() {
     let json = json!({
-        "eventId": "abc123",
-        "projectId": 1,
-        "projectSlug": "proj",
+        "event_id": "abc123",
+        "project_id": 1,
+        "project_slug": "proj",
         "transaction": "test-tx",
         "start_timestamp": 1000.0,
-        "sdk.name": "sentry.python",
+        "sdk_name": "sentry.python",
         "timestamp": 1001.0,
         "children": [],
         "errors": [{"title": "Error"}],
-        "spanId": "span1",
-        "parentSpanId": "span0",
-        "span.op": "http.request",
-        "span.description": "GET /api",
-        "span.status": "ok",
-        "span.duration": 150.5
+        "span_id": "span1",
+        "parent_span_id": "span0",
+        "transaction.op": "http.request",
+        "transaction.duration": 150.5
     });
     let tx: TraceTransaction = serde_json::from_value(json).unwrap();
     assert_eq!(tx.sdk_name.as_deref(), Some("sentry.python"));
     assert_eq!(tx.span_id.as_deref(), Some("span1"));
     assert_eq!(tx.parent_span_id.as_deref(), Some("span0"));
     assert_eq!(tx.span_op.as_deref(), Some("http.request"));
-    assert_eq!(tx.span_description.as_deref(), Some("GET /api"));
-    assert_eq!(tx.span_status.as_deref(), Some("ok"));
     assert_eq!(tx.span_duration, Some(150.5));
     assert_eq!(tx.errors.len(), 1);
 }
 
 #[test]
 fn test_trace_transaction_with_children() {
     let json = json!({
-        "eventId": "parent",
-        "projectId": 1,
-        "projectSlug": "proj",
+        "event_id": "parent",
+        "project_id": 1,
+        "project_slug": "proj",
         "transaction": "parent-tx",
         "start_timestamp": 1000.0,
         "timestamp": 1001.0,
         "children": [{
-            "eventId": "child",
-            "projectId": 1,
-            "projectSlug": "proj",
+            "event_id": "child",
+            "project_id": 1,
+            "project_slug": "proj",
             "transaction": "child-tx",
             "start_timestamp": 1000.1,
             "timestamp": 1000.5,
@@ -248,3 +244,33 @@ fn test_trace_transaction_with_children() {
     assert_eq!(tx.children[0].event_id, "child");
     assert_eq!(tx.children[0].transaction, "child-tx");
 }
+
+#[test]
+fn test_trace_transaction_actual_api_format() {
+    let json = json!({
+        "event_id": "4ff9a0a8138a447c9e0572a2eeff55d8",
+        "span_id": "91958dc2ae005f54",
+        "timestamp": 1771164551.832868,
+        "transaction": "/api/wf__model__doc_type/pk/",
+        "transaction.duration": 326,
+        "transaction.op": "http.server",
+        "project_id": 19,
+        "project_slug": "platform_test_project",
+        "parent_span_id": null,
+        "parent_event_id": null,
+        "generation": 0,
+        "errors": [],
+        "performance_issues": [],
+        "start_timestamp": 1771164551.506479,
+        "sdk_name": "sentry.python.django",
+        "profiler_id": null,
+        "children": []
+    });
+    let tx: TraceTransaction = serde_json::from_value(json).unwrap();
+    assert_eq!(tx.event_id, "4ff9a0a8138a447c9e0572a2eeff55d8");
+    assert_eq!(tx.project_id, 19);
+    assert_eq!(tx.project_slug, "platform_test_project");
+    assert_eq!(tx.span_op.as_deref(), Some("http.server"));
+    assert_eq!(tx.span_duration, Some(326.0));
+    assert_eq!(tx.sdk_name.as_deref(), Some("sentry.python.django"));
+}

tests/api_client_tests.rs

@@ -124,6 +124,10 @@ fn make_trace() -> TraceResponse {
             span_duration: Some(1000.0),
             span_description: Some("GET /api/test".to_string()),
             span_status: Some("ok".to_string()),
+            parent_event_id: None,
+            generation: 0,
+            profiler_id: None,
+            performance_issues: vec![],
         }],
         orphan_errors: vec![],
     }

tests/execute_tests.rs

@@ -36,10 +36,14 @@ fn make_tx(
         errors: vec![],
         span_id: Some("span1".to_string()),
         parent_span_id: None,
+        parent_event_id: None,
+        generation: 0,
+        profiler_id: None,
+        performance_issues: vec![],
         span_op: op.map(|s| s.to_string()),
+        span_duration: duration,
         span_description: Some("test description".to_string()),
         span_status: Some("ok".to_string()),
-        span_duration: duration,
     }
 }
 
@@ -110,20 +114,20 @@ fn test_format_span_tree_with_depth() {
 }
 
 #[test]
-fn test_format_span_tree_error_status() {
-    let mut tx = make_tx(Some("http"), Some(100.0), vec![]);
-    tx.span_status = Some("internal_error".to_string());
+fn test_format_span_tree_unknown_op() {
+    let tx = make_tx(None, Some(100.0), vec![]);
     let mut output = String::new();
     format_span_tree(&tx, 0, &mut output);
-    assert!(output.contains("✗"));
+    assert!(output.contains("unknown"));
 }
 
 #[test]
-fn test_format_span_tree_unknown_op() {
-    let tx = make_tx(None, Some(100.0), vec![]);
+fn test_format_span_tree_error_status() {
+    let mut tx = make_tx(Some("http"), Some(100.0), vec![]);
+    tx.span_status = Some("internal_error".to_string());
     let mut output = String::new();
     format_span_tree(&tx, 0, &mut output);
-    assert!(output.contains("unknown"));
+    assert!(output.contains("✗"));
 }
 
 #[test]
@@ -259,10 +263,10 @@ fn test_format_span_tree_deep_nesting() {
     format_span_tree(&root, 0, &mut output);
     let lines: Vec<&str> = output.lines().collect();
     assert_eq!(lines.len(), 4);
-    assert!(lines[0].starts_with("✓"));
-    assert!(lines[1].starts_with("  ✓"));
-    assert!(lines[2].starts_with("    ✓"));
-    assert!(lines[3].starts_with("      ✓"));
+    assert!(lines[0].starts_with("✓ [root]"));
+    assert!(lines[1].starts_with("  ✓ [level1]"));
+    assert!(lines[2].starts_with("    ✓ [level2]"));
+    assert!(lines[3].starts_with("      ✓ [level3]"));
 }
 
 #[test]