Skip to content

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

3.5 KB
Raw Blame
import {
  queryClickhouse,
  type ClickhouseQueryOpts,
} from "../../../server/repositories/clickhouse";
import { type PreferredClickhouseService } from "../../../server/clickhouse/client";
import { QueryBuilder } from "./queryBuilder";
import { type QueryType, type ViewVersion } from "../types";
import { env } from "../../../env";

export type PreparedQuery = {
  compiledQuery: string;
  parameters: Record<string, unknown>;
  preferredClickhouseService: PreferredClickhouseService | undefined;
  tags: { projectId: string };
  clickhouseSettings: Record<string, string>;
  usesTraceTable: boolean;
  fromTimestamp: string;
};

export async function prepareExecuteQuery(opts: {
  projectId: string;
  query: QueryType;
  version?: ViewVersion;
  enableSingleLevelOptimization?: boolean;
}): Promise<PreparedQuery> {
  const {
    projectId,
    query,
    version = "v1",
    enableSingleLevelOptimization = false,
  } = opts;

  const chartConfig =
    (query as unknown as { config?: QueryType["chartConfig"] }).config ??
    query.chartConfig;
  const queryBuilder = new QueryBuilder(chartConfig, version);

  const { query: compiledQuery, parameters } = await queryBuilder.build(
    query,
    projectId,
    enableSingleLevelOptimization ||
      env.LANGFUSE_ENABLE_SINGLE_LEVEL_QUERY_OPTIMIZATION === "true",
  );

  // v2 score views are score-based, but can add events_core joins for
  // trace/observation dimensions. Route based on the compiled query so only
  // generated queries that actually touch events use the events readonly pool.
  const usesEventsTable =
    compiledQuery.includes("events_core") ||
    compiledQuery.includes("events_full");
  const preferredClickhouseService = usesEventsTable
    ? ("EventsReadOnly" as const)
    : undefined;

  const tags = { projectId };

  const clickhouseSettings: Record<string, string> = {
    date_time_output_format: "iso",
    ...(env.CLICKHOUSE_USE_QUERY_CONDITION_CACHE === "true"
      ? { use_query_condition_cache: "true" }
      : {}),
    max_bytes_before_external_group_by: String(
      env.CLICKHOUSE_MAX_BYTES_BEFORE_EXTERNAL_GROUP_BY,
    ),
  };

  return {
    compiledQuery,
    parameters,
    preferredClickhouseService,
    tags,
    clickhouseSettings,
    usesTraceTable: compiledQuery.includes("traces"),
    fromTimestamp: query.fromTimestamp,
  };
}

export function toClickhouseQueryOpts(
  prepared: PreparedQuery,
): Omit<ClickhouseQueryOpts, "allowLegacyEventsRead"> {
  return {
    query: prepared.compiledQuery,
    params: prepared.parameters,
    // Large filter values (e.g. long IN lists) would overflow the URL.
    useMultipartParamsAuto: true,
    clickhouseSettings: prepared.clickhouseSettings,
    tags: prepared.tags,
    preferredClickhouseService: prepared.preferredClickhouseService,
  };
}

export async function executeQuery(
  projectId: string,
  query: QueryType,
  version: ViewVersion = "v1",
  enableSingleLevelOptimization = false,
  options?: Pick<ClickhouseQueryOpts, "clickhouseSettings">,
): Promise<Array<Record<string, unknown>>> {
  const prepared = await prepareExecuteQuery({
    projectId,
    query,
    version,
    enableSingleLevelOptimization,
  });

  const chOpts = toClickhouseQueryOpts(prepared);
  chOpts.clickhouseSettings = {
    ...chOpts.clickhouseSettings,
    ...options?.clickhouseSettings,
  };

  if (!prepared.usesTraceTable) {
    return queryClickhouse<Record<string, unknown>>(chOpts);
  }

  return queryClickhouse<Record<string, unknown>>({
    ...chOpts,
    query: prepared.compiledQuery,
    params: prepared.parameters,
    tags: prepared.tags,
  });
}