Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

15.7 KB
Raw Blame
/* eslint-disable @typescript-eslint/no-use-before-define */
import React, { useEffect, useRef, useState } from "react";
import { useVirtualizer } from "@tanstack/react-virtual";
import { type FilterState } from "@langfuse/shared";

import { LazySessionTraceEventsRow } from "@/src/features/sessions/LazySessionTraceEventsRow";
import { SessionVirtualizedRow } from "@/src/features/sessions/SessionVirtualizedRow";
import { type EventSessionTrace } from "@/src/features/sessions/sessionDetailPageTypes";
import { computeIdleGapSeconds } from "@/src/features/sessions/sessionIdleGap";
import { useElementSize } from "@/src/hooks/useElementSize";
import { useDebounce } from "@/src/hooks/useDebounce";
import { useVirtualizedScrollSpy } from "@/src/hooks/useVirtualizedScrollSpy";
import {
  ModernSessionSidebar,
  type ModernSessionSidebarFilterControls,
  type ModernSessionSidebarTrace,
} from "@/src/features/sessions/ModernSessionSidebar";
import { api } from "@/src/utils/api";

const MODERN_SESSION_OVERSCAN = 5;
const SIDEBAR_TRACE_CHUNK_SIZE = 20;
const SIDEBAR_OBSERVATION_PAGE_SIZE = 100;
const EMPTY_TRACES: EventSessionTrace[] = [];

type ConnectedModernSessionBodyLegacyProps = {
  tracesState:
    | { type: "loading" }
    | { type: "loaded"; traces: EventSessionTrace[] };
  projectId: string;
  sessionId: string;
  sessionMinTimestamp: Date;
  sessionMaxTimestamp: Date;
  openPeek: (id: string, row: EventSessionTrace) => void;
  traceCommentCounts: Map<string, number> | undefined;
  filterState: FilterState;
  filterMeasurementKey: string;
  viewLabel: string | null;
  showInlineToolCalls: boolean;
  showSystemPrompt: boolean;
  sidebarFilterControls: ModernSessionSidebarFilterControls;
  onFilterObservationByName: (
    name: string,
    operator: "any of" | "none of",
  ) => void;
};

export function ConnectedModernSessionBodyLegacy({
  tracesState,
  projectId,
  sessionId,
  sessionMinTimestamp,
  sessionMaxTimestamp,
  openPeek,
  traceCommentCounts,
  filterState,
  filterMeasurementKey,
  viewLabel,
  showInlineToolCalls,
  showSystemPrompt,
  sidebarFilterControls,
  onFilterObservationByName,
}: ConnectedModernSessionBodyLegacyProps) {
  const traces =
    tracesState.type === "loaded" ? tracesState.traces : EMPTY_TRACES;
  const [search, setSearch] = useState("");
  const [searchQuery, setSearchQuery] = useState("");
  const debouncedSetSearchQuery = useDebounce(setSearchQuery, 500, false);
  const isSearchPending = search.trim() !== searchQuery;
  const [collapsedTraceIds, setCollapsedTraceIds] = useState<Set<string>>(
    new Set(),
  );
  const [visibleTraceIds, setVisibleTraceIds] = useState<string[]>([]);
  const [pageCounts, setPageCounts] = useState<Record<string, number>>({});
  const expandedTraceIds = new Set(
    traces
      .filter((trace) => !collapsedTraceIds.has(trace.id))
      .map((trace) => trace.id),
  );

  const baseFilters: FilterState = [
    ...filterState,
    {
      column: "sessionId",
      type: "string",
      operator: "=",
      value: sessionId,
    },
    {
      column: "startTime",
      type: "datetime",
      operator: ">=",
      value: sessionMinTimestamp,
    },
    {
      column: "startTime",
      type: "datetime",
      operator: "<=",
      value: sessionMaxTimestamp,
    },
  ];
  const filtersRequireIO = filterState.some(
    (filter) =>
      (filter.column === "hasInput" || filter.column === "hasOutput") &&
      filter.type === "boolean" &&
      filter.operator === "=" &&
      filter.value,
  );

  const traceIndexById = new Map(
    traces.map((trace, index) => [trace.id, index] as const),
  );
  const activeChunkIndices = new Set<number>();
  if (!searchQuery) {
    for (const traceId of visibleTraceIds) {
      if (!expandedTraceIds.has(traceId)) continue;
      const traceIndex = traceIndexById.get(traceId);
      if (traceIndex === undefined) continue;
      activeChunkIndices.add(Math.floor(traceIndex / SIDEBAR_TRACE_CHUNK_SIZE));
    }
  }

  const queryDescriptors: Array<{
    key: string;
    page: number;
    traceIds: string[] | undefined;
  }> = [];
  if (searchQuery) {
    const key = `search:${filterMeasurementKey}:${searchQuery}`;
    const pageCount = pageCounts[key] ?? 1;
    for (let page = 1; page <= pageCount; page++) {
      queryDescriptors.push({ key, page, traceIds: undefined });
    }
  } else {
    for (const chunkIndex of activeChunkIndices) {
      const key = `browse:${filterMeasurementKey}:${chunkIndex}`;
      const pageCount = pageCounts[key] ?? 1;
      const startIndex = chunkIndex * SIDEBAR_TRACE_CHUNK_SIZE;
      const traceIds = traces
        .slice(startIndex, startIndex + SIDEBAR_TRACE_CHUNK_SIZE)
        .map((trace) => trace.id);
      for (let page = 1; page <= pageCount; page++) {
        queryDescriptors.push({ key, page, traceIds });
      }
    }
  }

  const observationQueries = api.useQueries((t) =>
    queryDescriptors.map((descriptor) =>
      t.events.all(
        {
          projectId,
          filter: descriptor.traceIds
            ? [
                ...baseFilters,
                {
                  column: "traceId",
                  type: "stringOptions",
                  operator: "any of",
                  value: descriptor.traceIds,
                },
              ]
            : baseFilters,
          searchQuery: searchQuery || null,
          searchType: searchQuery ? ["id"] : [],
          page: descriptor.page,
          limit: SIDEBAR_OBSERVATION_PAGE_SIZE,
          orderBy: { column: "startTime", order: "ASC" },
        },
        {
          staleTime: 60 * 1000,
          refetchOnWindowFocus: false,
        },
      ),
    ),
  );

  const observationsByTraceId = new Map<
    string,
    NonNullable<ModernSessionSidebarTrace["observations"]>
  >();
  const observationIdsByTraceId = new Map<string, Set<string>>();
  const traceIdsWithMatchingTraceLevelIO = new Set<string>();
  for (const query of observationQueries) {
    for (const observation of query.data?.observations ?? []) {
      if (!observation.traceId) {
        continue;
      }
      if (observation.id === `t-${observation.traceId}`) {
        traceIdsWithMatchingTraceLevelIO.add(observation.traceId);
        continue;
      }
      const observationIds = observationIdsByTraceId.get(observation.traceId);
      if (observationIds?.has(observation.id)) {
        continue;
      }
      if (observationIds) observationIds.add(observation.id);
      else {
        observationIdsByTraceId.set(
          observation.traceId,
          new Set([observation.id]),
        );
      }
      const observations = observationsByTraceId.get(observation.traceId);
      const row = {
        id: observation.id,
        name: observation.name,
        type: observation.type,
        latency: observation.latency,
      };
      if (observations) observations.push(row);
      else observationsByTraceId.set(observation.traceId, [row]);
    }
  }

  const sidebarTraces: ModernSessionSidebarTrace[] = [];
  for (const [index, trace] of traces.entries()) {
    const chunkIndex = Math.floor(index / SIDEBAR_TRACE_CHUNK_SIZE);
    const chunkKey = `browse:${filterMeasurementKey}:${chunkIndex}`;
    const relevantQueryIndices = queryDescriptors.flatMap(
      (descriptor, queryIndex) =>
        descriptor.key ===
        (searchQuery
          ? `search:${filterMeasurementKey}:${searchQuery}`
          : chunkKey)
          ? [queryIndex]
          : [],
    );
    const hasLoadedObservations = observationsByTraceId.has(trace.id);
    const isPending =
      relevantQueryIndices.length === 0 ||
      relevantQueryIndices.every(
        (queryIndex) => observationQueries[queryIndex]?.isPending,
      );
    const isError = relevantQueryIndices.some(
      (queryIndex) => observationQueries[queryIndex]?.isError,
    );
    const lastRelevantQuery =
      observationQueries[relevantQueryIndices.at(-1) ?? -1];
    const mayHaveMoreObservations = Boolean(
      lastRelevantQuery?.isPending || lastRelevantQuery?.data?.hasMore,
    );
    const observations = (() => {
      if (isPending && !hasLoadedObservations) {
        return undefined;
      }
      if (isError) {
        return null;
      }
      if (mayHaveMoreObservations && !hasLoadedObservations) {
        return undefined;
      }
      return observationsByTraceId.get(trace.id) ?? [];
    })();

    if (
      searchQuery &&
      !observationsByTraceId.has(trace.id) &&
      !traceIdsWithMatchingTraceLevelIO.has(trace.id)
    ) {
      continue;
    }

    sidebarTraces.push({
      trace,
      turnNumber: index + 1,
      idleGapSeconds:
        index === 0 ? null : computeIdleGapSeconds(traces[index - 1]!, trace),
      observations,
      hasMatchingTraceLevelIO:
        filtersRequireIO && traceIdsWithMatchingTraceLevelIO.has(trace.id),
    });
  }

  const lastQueryByKey = new Map<string, number>();
  queryDescriptors.forEach((descriptor, queryIndex) => {
    lastQueryByKey.set(descriptor.key, queryIndex);
  });
  const hasMoreObservations = Array.from(lastQueryByKey.values()).some(
    (queryIndex) => observationQueries[queryIndex]?.data?.hasMore,
  );
  const isLoadingMoreObservations = Array.from(lastQueryByKey.values()).some(
    (queryIndex) => observationQueries[queryIndex]?.isFetching,
  );
  const observationLoadError = observationQueries.some(
    (query) => query.isError,
  );

  const loadMoreObservations = () => {
    setPageCounts((current) => {
      let next = current;
      for (const [key, queryIndex] of lastQueryByKey) {
        const query = observationQueries[queryIndex];
        const descriptor = queryDescriptors[queryIndex];
        if (!query?.data?.hasMore || query.isFetching || !descriptor) {
          continue;
        }
        if (next === current) next = { ...current };
        next[key] = Math.max(current[key] ?? 1, descriptor.page + 1);
      }
      return next;
    });
  };

  const handleVisibleTraceIdsChange = (nextTraceIds: string[]) => {
    setVisibleTraceIds((current) => {
      if (
        current.length === nextTraceIds.length &&
        current.every((traceId, index) => traceId === nextTraceIds[index])
      ) {
        return current;
      }
      return nextTraceIds;
    });
  };

  const handleSearchChange = (nextSearch: string) => {
    setSearch(nextSearch);
    debouncedSetSearchQuery(nextSearch.trim());
  };

  const toggleTraceExpanded = (traceId: string) => {
    setCollapsedTraceIds((current) => {
      const next = new Set(current);
      if (next.has(traceId)) next.delete(traceId);
      else next.add(traceId);
      return next;
    });
  };
  const [feedRef, feedSize] = useElementSize<HTMLDivElement>();
  const virtualizer = useVirtualizer({
    count: traces.length,
    getScrollElement: () => feedRef.current,
    estimateSize: () => 520,
    overscan: MODERN_SESSION_OVERSCAN,
    getItemKey: (index) => traces[index]?.id ?? index,
  });
  const {
    activeItemId: activeTraceId,
    virtualItems,
    selectItem: selectTrace,
  } = useVirtualizedScrollSpy({
    items: traces,
    virtualizer,
    scrollElementRef: feedRef,
    viewportHeight: feedSize?.height ?? 0,
    endTransitionRatio: 0.2,
  });
  const observationScrollCleanupRef = useRef<(() => void) | null>(null);
  useEffect(() => () => observationScrollCleanupRef.current?.(), []);
  const handleSelect = (index: number, observationId?: string) => {
    observationScrollCleanupRef.current?.();
    observationScrollCleanupRef.current = null;
    selectTrace(index);
    if (!observationId) return;

    const feed = feedRef.current;
    if (!feed) return;

    const scrollToObservation = () => {
      const observation = Array.from(
        feed.querySelectorAll<HTMLElement>("[data-session-observation-id]"),
      ).find(
        (element) => element.dataset.sessionObservationId === observationId,
      );
      if (!observation) return false;

      const top =
        feed.scrollTop +
        observation.getBoundingClientRect().top -
        feed.getBoundingClientRect().top -
        Math.max(0, (feed.clientHeight - observation.clientHeight) / 2);
      feed.scrollTo({ top, behavior: "smooth" });
      return true;
    };

    if (scrollToObservation()) return;

    let timeout: number;
    const cleanup = () => {
      observer.disconnect();
      window.clearTimeout(timeout);
    };
    const observer = new MutationObserver(() => {
      if (!scrollToObservation()) return;
      cleanup();
      if (observationScrollCleanupRef.current === cleanup) {
        observationScrollCleanupRef.current = null;
      }
    });
    observer.observe(feed, { childList: true, subtree: true });
    timeout = window.setTimeout(() => {
      cleanup();
      if (observationScrollCleanupRef.current === cleanup) {
        observationScrollCleanupRef.current = null;
      }
    }, 5_000);
    observationScrollCleanupRef.current = cleanup;
  };

  return (
    <div className="bg-background session-review-stack:grid-rows-[minmax(7rem,9rem)_minmax(0,1fr)] session-review-stack:gap-x-0 relative grid min-h-0 flex-1 grid-rows-[minmax(10rem,13rem)_minmax(0,1fr)] gap-x-4 overflow-hidden @3xl/session-workspace:grid-cols-[clamp(200px,24cqw,296px)_minmax(0,1fr)] @3xl/session-workspace:grid-rows-1">
      {tracesState.type === "loading" ? (
        <ModernSessionSidebar state="loading" />
      ) : (
        <ModernSessionSidebar
          state="loaded"
          traces={isSearchPending ? [] : sidebarTraces}
          activeTraceId={activeTraceId}
          filterControls={sidebarFilterControls}
          search={search}
          onSearchChange={handleSearchChange}
          expandedTraceIds={expandedTraceIds}
          onToggleTraceExpanded={toggleTraceExpanded}
          onFilterObservationByName={onFilterObservationByName}
          onSelect={handleSelect}
          onVisibleTraceIdsChange={handleVisibleTraceIdsChange}
          hasMoreObservations={hasMoreObservations}
          isLoadingMoreObservations={
            isSearchPending || isLoadingMoreObservations
          }
          observationLoadError={observationLoadError}
          onLoadMoreObservations={loadMoreObservations}
          onViewportUnderfilled={
            searchQuery && !isSearchPending ? loadMoreObservations : undefined
          }
        />
      )}
      <div className="bg-card dark:bg-background session-review-stack:min-w-0 relative min-h-0 min-w-[320px]">
        <div
          ref={feedRef}
          className="h-full min-h-0 overflow-y-auto scroll-smooth"
        >
          <div
            style={{
              height: `${virtualizer.getTotalSize()}px`,
              width: "100%",
              position: "relative",
            }}
          >
            {virtualItems.map((virtualItem) => {
              const trace = traces[virtualItem.index];
              if (!trace) return null;

              return (
                <SessionVirtualizedRow
                  key={virtualItem.key}
                  itemKey={String(virtualItem.key)}
                  measurementKey={`${String(virtualItem.key)}:${showInlineToolCalls}:${showSystemPrompt}:${filterMeasurementKey}`}
                  source="modern"
                  virtualItem={virtualItem}
                  virtualizer={virtualizer}
                >
                  <LazySessionTraceEventsRow
                    trace={trace}
                    projectId={projectId}
                    sessionId={sessionId}
                    openPeek={openPeek}
                    traceCommentCounts={traceCommentCounts}
                    index={virtualItem.index}
                    filterState={filterState}
                    viewLabel={viewLabel}
                    surface="modern"
                    contentMode={showInlineToolCalls ? "all" : "conversation"}
                    showSystemPrompt={showSystemPrompt}
                  />
                </SessionVirtualizedRow>
              );
            })}
          </div>
        </div>
      </div>
    </div>
  );
}