Skip to content

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

12.5 KB
Raw Blame
/* eslint-disable no-nested-ternary, @typescript-eslint/no-deprecated -- Legacy UI usage retained during migration to design-system components. */
import { Button } from "@/src/components/ui/button";
import { MultiSelectKeyValues } from "@/src/features/scores/components/MultiSelectKeyValues";
import { CompareViewAdapter } from "@/src/features/scores/adapters/index";
import { getScoreDataTypeIcon } from "@/src/features/scores/lib/scoreColumns";
import { FlaskConical, List } from "@langfuse/icons";
import { useRouter } from "next/router";
import { useEffect, useState } from "react";
import { MarkdownJsonView } from "@/src/components/ui/MarkdownJsonView";
import {
  Dialog,
  DialogContent,
  DialogTrigger,
} from "@/src/components/ui/dialog";
import { CreateExperimentsForm } from "@/src/features/experiments/components/CreateExperimentsForm";
import { useExperimentAccess } from "@/src/features/experiments/hooks/useExperimentAccess";
import { toExperimentsResultsUrl } from "@/src/features/experiments/utils/experimentUrlTranslation";
import { useHasProjectAccess } from "@/src/features/rbac/utils/checkProjectAccess";
import { DatasetAnalytics } from "@/src/features/datasets/components/DatasetAnalytics";
import {
  RESOURCE_METRICS,
  isEmptyChart,
} from "@/src/features/dashboard/lib/score-analytics-utils";
import {
  compareViewChartDataToDataPoints,
  getCompareViewChartUnit,
} from "@/src/features/dashboard/lib/chart-data-adapters";
import { Chart } from "@/src/features/widgets/chart-library/Chart";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";
import Page from "@/src/components/layouts/Page";
import { SubHeaderLabel } from "@/src/components/layouts/header";
import {
  SidePanel,
  SidePanelContent,
  SidePanelHeader,
  SidePanelTitle,
} from "@/src/components/ui/side-panel";
import useLocalStorage from "@/src/components/useLocalStorage";
import { useDatasetRunsCompare } from "@/src/features/datasets/hooks/useDatasetRunsCompare";
import { useDatasetRunCompareChartData } from "@/src/features/datasets/hooks/useDatasetRunCompareChartData";
import { Skeleton } from "@/src/components/ui/skeleton";
import {
  DATASET_RUN_COMPARE_TABS,
  getDatasetRunCompareTabs,
} from "@/src/features/navigation/utils/dataset-run-compare-tabs";
import { NoDataOrLoading } from "@/src/components/NoDataOrLoading";

function DatasetCompareChartsLegacy() {
  const router = useRouter();
  const capture = usePostHogClientCapture();
  const projectId = router.query.projectId as string;
  const datasetId = router.query.datasetId as string;

  const [isCreateExperimentDialogOpen, setIsCreateExperimentDialogOpen] =
    useState(false);

  const [selectedMetrics, setSelectedMetrics] = useLocalStorage<string[]>(
    `${projectId}-dataset-compare-metrics`,
    RESOURCE_METRICS.map((metric) => metric.key),
  );

  const hasExperimentWriteAccess = useHasProjectAccess({
    projectId,
    scope: "promptExperiments:CUD",
  });

  const {
    runIds,
    runs,
    dataset,
    handleExperimentSettled: handleExperimentSettledBase,
    setRunState,
    setLocalRuns,
  } = useDatasetRunsCompare(projectId, datasetId);

  const { chartDataMap, scoreAnalyticsOptions, scoreKeyToData, isLoading } =
    useDatasetRunCompareChartData(projectId, datasetId, runIds);

  const handleExperimentSettled = async (data?: {
    success: boolean;
    datasetId: string;
    runId: string;
    runName: string;
  }) => {
    setIsCreateExperimentDialogOpen(false);
    await handleExperimentSettledBase(data);
  };

  return (
    <Page
      headerProps={{
        title: `Compare experiments: ${dataset.data?.name ?? datasetId}`,
        tabsProps: {
          tabs: getDatasetRunCompareTabs(projectId, datasetId),
          activeTab: DATASET_RUN_COMPARE_TABS.CHARTS,
        },
        breadcrumb: [
          {
            name: "Datasets",
            href: `/project/${projectId}/datasets`,
          },
          {
            name: dataset.data?.name ?? datasetId,
            href: `/project/${projectId}/datasets/${datasetId}`,
          },
          {
            name: "Experiments",
            href: `/project/${projectId}/datasets/${datasetId}/experiments`,
          },
        ],
        help: {
          description: "Compare your experiments side by side",
        },
        actionButtonsRight: (
          <>
            <Dialog
              key="create-experiment-dialog"
              open={isCreateExperimentDialogOpen}
              onOpenChange={setIsCreateExperimentDialogOpen}
            >
              <DialogTrigger asChild disabled={!hasExperimentWriteAccess}>
                <Button
                  variant="outline"
                  disabled={!hasExperimentWriteAccess}
                  onClick={() => capture("dataset_run:new_form_open")}
                >
                  <FlaskConical size="base" color="default" />
                  <span className="ml-2 hidden md:block">New experiment</span>
                </Button>
              </DialogTrigger>
              <DialogContent className="max-h-[90vh] overflow-y-auto">
                <CreateExperimentsForm
                  key={`create-experiment-form-${datasetId}`}
                  projectId={projectId as string}
                  setFormOpen={setIsCreateExperimentDialogOpen}
                  defaultValues={{
                    datasetId,
                  }}
                  handleExperimentSettled={handleExperimentSettled}
                  showSDKRunInfoPage
                />
              </DialogContent>
            </Dialog>
            <MultiSelectKeyValues
              key="select-runs"
              title="Experiments"
              showSelectedValueStrings={false}
              placeholder="Select runs to compare"
              className="w-fit"
              variant="outline"
              hideClearButton
              iconLeft={
                <List size="base" color="default" __rawClassName="mr-2" />
              }
              options={runs.map((run) => ({
                key: run.key,
                value: run.value,
                disabled: runIds?.includes(run.key) && runIds.length === 1,
              }))}
              values={runs.filter((run) => runIds?.includes(run.key))}
              onValueChange={(values, changedValueId, selectedValueKeys) => {
                if (values.length === 0) return;
                if (changedValueId) {
                  if (selectedValueKeys?.has(changedValueId)) {
                    capture("dataset_run:compare_run_added");
                    setRunState({
                      runs: [...(runIds ?? []), changedValueId],
                    });
                    setLocalRuns([]);
                  } else {
                    capture("dataset_run:compare_run_removed");
                    setRunState({
                      runs: runIds?.filter((id) => id !== changedValueId) ?? [],
                    });
                    setLocalRuns([]);
                  }
                }
              }}
            />
          </>
        ),
      }}
    >
      <div className="grid flex-1 grid-cols-[1fr_auto] overflow-hidden">
        <div className="flex h-full flex-col gap-2 overflow-hidden px-3 py-2">
          <div className="flex w-full justify-end">
            <DatasetAnalytics
              key="dataset-analytics"
              scoreOptions={scoreAnalyticsOptions}
              selectedMetrics={selectedMetrics}
              setSelectedMetrics={setSelectedMetrics}
            />
          </div>
          <div className="overflow-y-auto">
            {Boolean(selectedMetrics.length) && Boolean(chartDataMap?.size) ? (
              <div className="grid w-full grid-cols-2 gap-4 xl:grid-cols-3">
                {selectedMetrics.map((key) => {
                  if (isLoading) {
                    return <Skeleton key={key} className="h-52 w-full" />;
                  }

                  const adapter = new CompareViewAdapter(chartDataMap, key);
                  const { chartData, chartLabels } = adapter.toChartData();

                  const scoreData = scoreKeyToData.get(key);
                  const title = scoreData
                    ? `${getScoreDataTypeIcon(scoreData.dataType)} ${scoreData.name} (${scoreData.source.toLowerCase()})`
                    : (RESOURCE_METRICS.find((metric) => metric.key === key)
                        ?.label ?? key);

                  if (isEmptyChart({ data: chartData })) {
                    return (
                      <div
                        key={key}
                        className="flex min-h-[200px] max-w-full min-w-0 flex-col gap-2"
                      >
                        <span className="shrink-0 text-sm font-bold">
                          {title}
                        </span>
                        <NoDataOrLoading
                          isLoading={false}
                          className="min-h-32 flex-1"
                        />
                      </div>
                    );
                  }

                  const dataPoints = compareViewChartDataToDataPoints(
                    chartData,
                    chartLabels,
                    key,
                  );

                  const chartType =
                    chartLabels.length === 1
                      ? "LINE_TIME_SERIES"
                      : "BAR_TIME_SERIES";

                  return (
                    <div
                      key={key}
                      className="flex min-h-[200px] max-w-full min-w-0 flex-col gap-2"
                    >
                      <span className="shrink-0 text-sm font-bold">
                        {title}
                      </span>
                      <div className="min-h-[200px] min-w-0 flex-1">
                        <Chart
                          chartType={chartType}
                          data={dataPoints}
                          rowLimit={Math.max(dataPoints.length, 1)}
                          chartConfig={{
                            type: chartType,
                            unit: getCompareViewChartUnit(key),
                          }}
                          // The x-axis is dataset-run names — long and cluttered;
                          // show them on hover instead of on the axis.
                          hideXAxisLabels
                        />
                      </div>
                    </div>
                  );
                })}
              </div>
            ) : isLoading ? (
              <Skeleton className="h-52 w-full" />
            ) : (
              <span className="text-muted-foreground -mt-2 text-sm">
                {Boolean(chartDataMap?.size)
                  ? "All charts hidden. Enable them in the Charts dropdown."
                  : "Select more than one run to generate charts."}
              </span>
            )}
          </div>
        </div>
        <SidePanel
          mobileTitle={dataset.data?.name ?? datasetId}
          id="compare-dataset-runs"
          scrollable={false}
        >
          <SidePanelHeader>
            <SidePanelTitle>{dataset.data?.name}</SidePanelTitle>
          </SidePanelHeader>
          <SidePanelContent className="overflow-y-auto p-1">
            <div className="w-full space-y-4">
              <div>
                <SubHeaderLabel title="Description" />
                <span className="text-muted-foreground text-sm">
                  {dataset.data?.description ?? "No description"}
                </span>
              </div>
              {dataset.data?.metadata && (
                <div>
                  <SubHeaderLabel title="Metadata" />
                  <MarkdownJsonView content={dataset.data?.metadata} />
                </div>
              )}
            </div>
          </SidePanelContent>
        </SidePanel>
      </div>
    </Page>
  );
}

function asArrayValue(value: string | string[] | undefined) {
  if (!value) return [];
  return Array.isArray(value) ? value : [value];
}

export default function DatasetCompareChartsPage() {
  const router = useRouter();
  const projectId = router.query.projectId as string;
  const runsQuery = router.query.runs;
  const { isExperimentsBetaActive, isInitializing } = useExperimentAccess();

  useEffect(() => {
    if (
      !router.isReady ||
      isInitializing ||
      !isExperimentsBetaActive ||
      !projectId
    ) {
      return;
    }

    router.replace(toExperimentsResultsUrl(projectId, asArrayValue(runsQuery)));
  }, [isExperimentsBetaActive, isInitializing, projectId, router, runsQuery]);

  if (!router.isReady || isInitializing || isExperimentsBetaActive) {
    return <Skeleton className="h-full w-full" />;
  }

  return <DatasetCompareChartsLegacy />;
}