show top span name for pending traces (#945)

dinmukhamedm · ellipsis-dev[bot] · web-flow · commit f626dd932a14 · 2025-10-16T15:32:32.000+01:00
* show top span name for pending traces

* small fixes

* fix bugbot comment

* infer top span name in the backend

* small fixes

* Update frontend/components/traces/traces-table/index.tsx

Co-authored-by: ellipsis-dev[bot] &lt;65095814+ellipsis-dev[bot]@users.noreply.github.com&gt;

---------

Co-authored-by: ellipsis-dev[bot] &lt;65095814+ellipsis-dev[bot]@users.noreply.github.com&gt;
diff --git a/app-server/src/ch/traces.rs b/app-server/src/ch/traces.rs
@@ -1,12 +1,14 @@
+use std::collections::HashSet;
+
 use chrono::{DateTime, Utc};
 use clickhouse::Row;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use super::spans::CHSpan;
-use super::utils::{chrono_to_nanoseconds, nanoseconds_to_chrono};
-use crate::db::spans::SpanType;
+use super::utils::chrono_to_nanoseconds;
+use crate::db::spans::{Span, SpanType};
 use crate::db::trace::Trace;
+use crate::traces::spans::SpanUsage;
 
 #[derive(Debug, Clone, Serialize, Deserialize, Row)]
 pub struct CHTrace {
@@ -92,7 +94,7 @@ pub struct TraceAggregation {
     pub user_id: Option<String>,
     pub status: Option<String>,
     pub metadata: Option<serde_json::Value>,
-    pub tags: Vec<String>,
+    pub tags: HashSet<String>,
     pub num_spans: i32,
     pub top_span_id: Option<Uuid>,
     pub top_span_name: Option<String>,
@@ -101,13 +103,13 @@ pub struct TraceAggregation {
 }
 
 impl TraceAggregation {
-    /// Aggregate statistics from a batch of CHSpans grouped by trace_id
-    pub fn from_ch_spans(spans: &[CHSpan]) -> Vec<Self> {
+    /// Aggregate statistics from a batch of Spans and SpanUsage grouped by trace_id
+    pub fn from_spans(spans: &[Span], span_usage_vec: &[SpanUsage]) -> Vec<Self> {
         use std::collections::HashMap;
 
         let mut trace_aggregations: HashMap<Uuid, TraceAggregation> = HashMap::new();
 
-        for span in spans {
+        for (span, span_usage) in spans.iter().zip(span_usage_vec.iter()) {
             let entry =
                 trace_aggregations
                     .entry(span.trace_id)
@@ -126,70 +128,86 @@ impl TraceAggregation {
                         user_id: None,
                         status: None,
                         metadata: None,
-                        tags: Vec::new(),
+                        tags: HashSet::new(),
                         num_spans: 0,
                         top_span_id: None,
                         top_span_name: None,
                         top_span_type: 0,
                         trace_type: 0,
                     });
 
-            // Convert nanoseconds to DateTime<Utc>
-            let start_dt = nanoseconds_to_chrono(span.start_time);
+            // Aggregate min start_time
             entry.start_time = Some(match entry.start_time {
-                Some(existing) => existing.min(start_dt),
-                None => start_dt,
+                Some(existing) => existing.min(span.start_time),
+                None => span.start_time,
             });
 
             // Aggregate max end_time
-            let end_dt = nanoseconds_to_chrono(span.end_time);
             entry.end_time = Some(match entry.end_time {
-                Some(existing) => existing.max(end_dt),
-                None => end_dt,
+                Some(existing) => existing.max(span.end_time),
+                None => span.end_time,
             });
 
-            // Sum tokens and costs
-            entry.input_tokens += span.input_tokens;
-            entry.output_tokens += span.output_tokens;
-            entry.total_tokens += span.total_tokens;
-            entry.input_cost += span.input_cost;
-            entry.output_cost += span.output_cost;
-            entry.total_cost += span.total_cost;
+            // Sum tokens and costs from SpanUsage
+            entry.input_tokens += span_usage.input_tokens;
+            entry.output_tokens += span_usage.output_tokens;
+            entry.total_tokens += span_usage.total_tokens;
+            entry.input_cost += span_usage.input_cost;
+            entry.output_cost += span_usage.output_cost;
+            entry.total_cost += span_usage.total_cost;
 
             // Use "any" strategy for these fields (take first non-empty value)
-            if entry.session_id.is_none() && !span.session_id.is_empty() {
-                entry.session_id = Some(span.session_id.clone());
+            if entry.session_id.is_none() {
+                if let Some(session_id) = span.attributes.session_id() {
+                    if !session_id.is_empty() {
+                        entry.session_id = Some(session_id);
+                    }
+                }
             }
-            if entry.user_id.is_none() && !span.user_id.is_empty() {
-                entry.user_id = Some(span.user_id.clone());
+            if entry.user_id.is_none() {
+                if let Some(user_id) = span.attributes.user_id() {
+                    if !user_id.is_empty() {
+                        entry.user_id = Some(user_id);
+                    }
+                }
             }
-            if entry.status.is_none() && !span.status.is_empty() {
-                entry.status = Some(span.status.clone());
+            if entry.status.is_none() {
+                if let Some(status) = &span.status {
+                    if !status.is_empty() {
+                        entry.status = Some(status.clone());
+                    }
+                }
             }
-            if entry.metadata.is_none() && !span.trace_metadata.is_empty() {
-                if let Ok(parsed) = serde_json::from_str(&span.trace_metadata) {
-                    entry.metadata = Some(parsed);
+            if entry.metadata.is_none() {
+                if let Some(metadata) = span.attributes.metadata() {
+                    if let Ok(metadata_value) = serde_json::to_value(&metadata) {
+                        entry.metadata = Some(metadata_value);
+                    }
                 }
             }
-            if span.trace_type != 0 {
-                entry.trace_type = span.trace_type;
+            if let Some(trace_type) = span.attributes.trace_type() {
+                entry.trace_type = trace_type.clone().into();
             }
 
-            if SpanType::from(span.span_type) == SpanType::EVALUATION {
+            if span.span_type == SpanType::EVALUATION {
                 entry.trace_type = 1;
             }
 
-            if span.parent_span_id == Uuid::nil() {
+            if span.parent_span_id.is_none() {
                 entry.top_span_id = Some(span.span_id);
                 entry.top_span_name = Some(span.name.clone());
-                entry.top_span_type = span.span_type as u8;
+                entry.top_span_type = span.span_type.clone().into();
+            }
+
+            if entry.top_span_name.is_none() {
+                let path = span.attributes.path().unwrap_or_default();
+                path.first()
+                    .map(|name| entry.top_span_name = Some(name.clone()));
             }
 
             // Collect unique tags
-            for tag in &span.tags_array {
-                if !entry.tags.contains(tag) {
-                    entry.tags.push(tag.clone());
-                }
+            for tag in span.attributes.tags() {
+                entry.tags.insert(tag);
             }
 
             entry.num_spans += 1;
diff --git a/app-server/src/ch/utils.rs b/app-server/src/ch/utils.rs
@@ -1,4 +1,4 @@
-use chrono::{DateTime, TimeZone, Utc};
+use chrono::{DateTime, Utc};
 
 pub fn chrono_to_nanoseconds(chrono_dt: DateTime<Utc>) -> i64 {
     let timestamp = chrono_dt.timestamp(); // seconds since the Unix epoch
@@ -9,11 +9,3 @@ pub fn chrono_to_nanoseconds(chrono_dt: DateTime<Utc>) -> i64 {
 
     total_nanos
 }
-
-pub fn nanoseconds_to_chrono(nanos: i64) -> DateTime<Utc> {
-    let seconds = nanos / 1_000_000_000;
-    let nanos_remainder = (nanos % 1_000_000_000) as u32;
-    Utc.timestamp_opt(seconds, nanos_remainder)
-        .single()
-        .unwrap_or(Utc.timestamp_opt(0, 0).single().unwrap())
-}
diff --git a/app-server/src/db/trace.rs b/app-server/src/db/trace.rs
@@ -207,7 +207,7 @@ pub async fn upsert_trace_statistics_batch(
         .bind(agg.output_cost)
         .bind(agg.total_cost)
         .bind(&agg.status)
-        .bind(&agg.tags)
+        .bind(&agg.tags.iter().collect::<Vec<_>>())
         .bind(agg.num_spans)
         .fetch_one(pool)
         .await?;
diff --git a/app-server/src/traces/consumer.rs b/app-server/src/traces/consumer.rs
@@ -309,7 +309,7 @@ async fn process_batch(
     }
 
     // Process trace aggregations and update trace statistics
-    let trace_aggregations = TraceAggregation::from_ch_spans(&ch_spans);
+    let trace_aggregations = TraceAggregation::from_spans(&spans, &span_usage_vec);
     if !trace_aggregations.is_empty() {
         // Upsert trace statistics in PostgreSQL
         match upsert_trace_statistics_batch(&db.pool, &trace_aggregations).await {
diff --git a/frontend/components/traces/traces-table/columns.tsx b/frontend/components/traces/traces-table/columns.tsx
@@ -1,9 +1,7 @@
 import { ColumnDef } from "@tanstack/react-table";
 import { capitalize } from "lodash";
-import { X } from "lucide-react";
 
 import ClientTimestampFormatter from "@/components/client-timestamp-formatter";
-import { NoSpanTooltip } from "@/components/traces/no-span-tooltip.tsx";
 import SpanTypeIcon, { createSpanTypeIcon } from "@/components/traces/span-type-icon";
 import { Badge } from "@/components/ui/badge.tsx";
 import { ColumnFilter } from "@/components/ui/datatable-filter/utils";
@@ -75,32 +73,33 @@ export const columns: ColumnDef<TraceRow, any>[] = [
     accessorKey: "topSpanType",
     header: "Top level span",
     id: "top_span_type",
-    cell: (row) => (
-      <div className="cursor-pointer flex gap-2 items-center">
-        <div className="flex items-center gap-2">
-          {row.row.original.topSpanName ? (
-            <SpanTypeIcon className="z-10" spanType={row.getValue()} />
-          ) : isStringDateOld(row.row.original.endTime) ? (
-            <NoSpanTooltip>
-              <div className="flex items-center gap-2 rounded-sm bg-secondary p-1">
-                <X className="w-4 h-4" />
-              </div>
-            </NoSpanTooltip>
+    cell: (row) => {
+      const topSpanId = row.row.original.topSpanId;
+      const hasTopSpan = !!topSpanId && topSpanId !== "00000000-0000-0000-0000-000000000000";
+      const isOld = isStringDateOld(row.row.original.endTime);
+      const shouldAnimate = !hasTopSpan && !isOld;
+
+      return (
+        <div className="cursor-pointer flex gap-2 items-center">
+          <div className="flex items-center gap-2">
+            {hasTopSpan ? (
+              <SpanTypeIcon className="z-10" spanType={row.getValue()} />
+            ) : (
+              <SpanTypeIcon className={cn("z-10", shouldAnimate && "animate-pulse")} spanType={SpanType.DEFAULT} />
+            )}
+          </div>
+          {hasTopSpan ? (
+            <div className="text-sm truncate">{row.row.original.topSpanName}</div>
+          ) : row.row.original.topSpanName ? (
+            <div className={cn("text-sm truncate text-muted-foreground", shouldAnimate && "animate-pulse")}>
+              {row.row.original.topSpanName}
+            </div>
           ) : (
-            <Skeleton className="w-6 h-6 bg-secondary rounded-sm" />
+            <Skeleton className="w-14 h-4 text-secondary-foreground py-0.5 bg-secondary rounded-full text-sm" />
           )}
         </div>
-        {row.row.original.topSpanName ? (
-          <div className="text-sm truncate">{row.row.original.topSpanName}</div>
-        ) : isStringDateOld(row.row.original.endTime) ? (
-          <NoSpanTooltip>
-            <div className="flex text-muted-foreground">None</div>
-          </NoSpanTooltip>
-        ) : (
-          <Skeleton className="w-14 h-4 text-secondary-foreground py-0.5 bg-secondary rounded-full text-sm" />
-        )}
-      </div>
-    ),
+      );
+    },
     size: 150,
   },
   {
diff --git a/frontend/components/traces/traces-table/index.tsx b/frontend/components/traces/traces-table/index.tsx
@@ -142,6 +142,10 @@ export default function TracesTable() {
 
       const isTopSpan = spanData.parentSpanId === null;
 
+      // Extract inferred top span name from lmnr.span.path (first element)
+      const spanPath = spanData.attributes?.["lmnr.span.path"];
+      const inferredTopSpanName = Array.isArray(spanPath) && spanPath.length > 0 ? spanPath[0] : undefined;
+
       if (existingTraceIndex !== -1) {
         // Update existing trace
         const newTraces = [...currentTraces];
@@ -153,6 +157,8 @@ export default function TracesTable() {
         const spanInputCost = spanData.attributes?.["gen_ai.usage.input_cost"] || 0;
         const spanOutputCost = spanData.attributes?.["gen_ai.usage.output_cost"] || 0;
 
+        const newTopSpanName = isTopSpan ? spanData.name : (inferredTopSpanName ?? existingTrace.topSpanName);
+
         newTraces[existingTraceIndex] = {
           ...existingTrace,
           startTime:
@@ -169,7 +175,7 @@ export default function TracesTable() {
           inputCost: existingTrace.inputCost + spanInputCost,
           outputCost: existingTrace.outputCost + spanOutputCost,
           totalCost: existingTrace.totalCost + spanInputCost + spanOutputCost,
-          topSpanName: isTopSpan ? spanData.name : existingTrace.topSpanName,
+          topSpanName: newTopSpanName,
           topSpanId: isTopSpan ? spanData.spanId : existingTrace.topSpanId,
           topSpanType: isTopSpan ? spanData.spanType : existingTrace.topSpanType,
           userId: spanData.attributes?.["lmnr.association.properties.user_id"] || existingTrace.userId,
@@ -200,7 +206,7 @@ export default function TracesTable() {
           metadata: spanData.attributes?.["metadata"] || null,
           topSpanId: isTopSpan ? spanData.spanId : null,
           traceType: "DEFAULT",
-          topSpanName: isTopSpan ? spanData.name : null,
+          topSpanName: isTopSpan ? spanData.name : inferredTopSpanName,
           topSpanType: isTopSpan ? spanData.spanType : null,
           status: spanData.status,
           userId: spanData.attributes?.["lmnr.association.properties.user_id"] || null,

Original file line number	Diff line number	Diff line change
`@@ -309,7 +309,7 @@ async fn process_batch(`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`// Process trace aggregations and update trace statistics`
`312`		`- let trace_aggregations = TraceAggregation::from_ch_spans(&ch_spans);`
	`312`	`+ let trace_aggregations = TraceAggregation::from_spans(&spans, &span_usage_vec);`
`313`	`313`	`if !trace_aggregations.is_empty() {`
`314`	`314`	`// Upsert trace statistics in PostgreSQL`
`315`	`315`	`match upsert_trace_statistics_batch(&db.pool, &trace_aggregations).await {`