refactor(llm-obs): use formatter::output for spans analytics output

Replace hand-rolled comfy_table rendering with formatter::output so that
spans analytics respects the -o flag (json, yaml, table, csv, tsv) like
every other command. Buckets are flattened into a list of row objects
before being passed to the formatter.

Add unit tests covering single/multi-facet, no-facet aggregate, empty
buckets, missing buckets key, and null fallbacks.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: mbldatadog

src/commands/llm_obs.rs

@@ -277,52 +277,41 @@ fn parse_group_by_facets(group_by: Option<String>, limit: u32) -> Vec<serde_json
         .unwrap_or_default()
 }
 
-fn print_analytics_table(resp: &serde_json::Value, facets: &[String], compute: &str) -> Result<()> {
+fn flatten_analytics_response(
+    resp: &serde_json::Value,
+    facets: &[String],
+    compute: &str,
+) -> Result<Vec<serde_json::Value>> {
     let buckets = resp
         .get("buckets")
         .and_then(|b| b.as_array())
         .ok_or_else(|| anyhow::anyhow!("unexpected response: missing 'buckets' array"))?;
 
-    if buckets.is_empty() {
-        println!("No results.");
-        return Ok(());
-    }
-
-    let mut table = comfy_table::Table::new();
-    let mut headers: Vec<String> = facets.to_vec();
-    headers.push(compute.to_string());
-    table.set_header(&headers);
-
-    for bucket in buckets {
-        let by = bucket.get("by").and_then(|b| b.as_object());
-        let computes = bucket.get("computes").and_then(|c| c.as_object());
-
-        let mut row: Vec<String> = facets
-            .iter()
-            .map(|facet| {
-                by.and_then(|b| b.get(facet))
-                    .map(|v| match v {
-                        serde_json::Value::String(s) => s.clone(),
-                        other => other.to_string(),
-                    })
-                    .unwrap_or_default()
-            })
-            .collect();
-
-        let val = computes
-            .and_then(|c| c.get("c0"))
-            .map(|v| match v {
-                serde_json::Value::Number(n) => n.to_string(),
-                other => other.to_string(),
-            })
-            .unwrap_or_default();
-        row.push(val);
-
-        table.add_row(row);
-    }
-
-    println!("{table}");
-    Ok(())
+    let rows = buckets
+        .iter()
+        .map(|bucket| {
+            let by = bucket.get("by").and_then(|b| b.as_object());
+            let computes = bucket.get("computes").and_then(|c| c.as_object());
+
+            let mut row = serde_json::Map::new();
+            for facet in facets {
+                let val = by
+                    .and_then(|b| b.get(facet))
+                    .cloned()
+                    .unwrap_or(serde_json::Value::Null);
+                row.insert(facet.clone(), val);
+            }
+            let val = computes
+                .and_then(|c| c.get("c0"))
+                .cloned()
+                .unwrap_or(serde_json::Value::Null);
+            row.insert(compute.to_string(), val);
+
+            serde_json::Value::Object(row)
+        })
+        .collect();
+
+    Ok(rows)
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -365,7 +354,8 @@ pub async fn spans_analytics(
     let resp = client::raw_post(cfg, "/api/unstable/llm-obs-query-rewriter/timeseries", body)
         .await
         .map_err(|e| anyhow::anyhow!("failed to run spans analytics: {e:?}"))?;
-    print_analytics_table(&resp, &facets, &compute)
+    let rows = flatten_analytics_response(&resp, &facets, &compute)?;
+    formatter::output(cfg, &rows)
 }
 
 #[cfg(test)]
@@ -465,4 +455,94 @@ mod tests {
         let result = parse_group_by_facets(Some("a,b,c".into()), 25);
         assert!(result.iter().all(|v| v["limit"] == 25));
     }
+
+    // --- flatten_analytics_response ---
+
+    #[test]
+    fn test_flatten_analytics_single_facet() {
+        let resp = serde_json::json!({
+            "buckets": [
+                { "by": { "span_name": "llm.call" }, "computes": { "c0": 42 } },
+                { "by": { "span_name": "tool.run"  }, "computes": { "c0": 7  } },
+            ]
+        });
+        let rows = flatten_analytics_response(&resp, &["span_name".into()], "count").unwrap();
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0]["span_name"], "llm.call");
+        assert_eq!(rows[0]["count"], 42);
+        assert_eq!(rows[1]["span_name"], "tool.run");
+        assert_eq!(rows[1]["count"], 7);
+    }
+
+    #[test]
+    fn test_flatten_analytics_multiple_facets() {
+        let resp = serde_json::json!({
+            "buckets": [
+                {
+                    "by": { "span_name": "llm.call", "@ml_app": "my-app" },
+                    "computes": { "c0": 10 }
+                }
+            ]
+        });
+        let rows =
+            flatten_analytics_response(&resp, &["span_name".into(), "@ml_app".into()], "count")
+                .unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0]["span_name"], "llm.call");
+        assert_eq!(rows[0]["@ml_app"], "my-app");
+        assert_eq!(rows[0]["count"], 10);
+    }
+
+    #[test]
+    fn test_flatten_analytics_no_facets() {
+        // Total aggregate with no group-by: one bucket, no "by" fields, just the compute.
+        let resp = serde_json::json!({
+            "buckets": [
+                { "by": {}, "computes": { "c0": 99 } }
+            ]
+        });
+        let rows = flatten_analytics_response(&resp, &[], "count").unwrap();
+        assert_eq!(rows.len(), 1);
+        assert_eq!(rows[0]["count"], 99);
+        // No extra keys beyond the compute label.
+        assert_eq!(rows[0].as_object().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn test_flatten_analytics_empty_buckets() {
+        let resp = serde_json::json!({ "buckets": [] });
+        let rows = flatten_analytics_response(&resp, &["span_name".into()], "count").unwrap();
+        assert!(rows.is_empty());
+    }
+
+    #[test]
+    fn test_flatten_analytics_missing_buckets_key() {
+        let resp = serde_json::json!({ "data": [] });
+        let err = flatten_analytics_response(&resp, &[], "count").unwrap_err();
+        assert!(err.to_string().contains("missing 'buckets' array"));
+    }
+
+    #[test]
+    fn test_flatten_analytics_missing_facet_value_is_null() {
+        // If a bucket's "by" object is missing a facet, the cell should be null.
+        let resp = serde_json::json!({
+            "buckets": [
+                { "by": {}, "computes": { "c0": 5 } }
+            ]
+        });
+        let rows = flatten_analytics_response(&resp, &["span_name".into()], "count").unwrap();
+        assert_eq!(rows[0]["span_name"], serde_json::Value::Null);
+    }
+
+    #[test]
+    fn test_flatten_analytics_missing_compute_is_null() {
+        // If a bucket has no "computes" object, the compute cell should be null.
+        let resp = serde_json::json!({
+            "buckets": [
+                { "by": { "span_name": "llm.call" } }
+            ]
+        });
+        let rows = flatten_analytics_response(&resp, &["span_name".into()], "count").unwrap();
+        assert_eq!(rows[0]["count"], serde_json::Value::Null);
+    }
 }