Skip to content

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

refactor(query-ast): compile events simple aggregates through the AST (#18418)

Niklas Semmlerd08d9684e652
diff --git a/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.ts b/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.ts
index 3e5f6be364..e85aa4898b 100644
--- a/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.ts
+++ b/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.ts
@@ -1493,7 +1493,7 @@ export type SessionEventsMetricsRow = {
* Aggregation fields for session-level queries.
* These fields use ClickHouse aggregation functions and require GROUP BY session_id.
*/
-const EVENTS_SESSION_AGGREGATION_FIELDS = {
+export const EVENTS_SESSION_AGGREGATION_FIELDS = {
session_id: "session_id",
max_timestamp: "max(start_time) AS max_timestamp",
min_timestamp: "min(start_time) AS min_timestamp",
@@ -1533,7 +1533,7 @@ const EVENTS_SESSION_AGGREGATION_FIELDS = {
/**
* Field sets for session aggregation queries
*/
-const SESSION_AGGREGATION_FIELD_SETS = {
+export const SESSION_AGGREGATION_FIELD_SETS = {
all: Object.keys(EVENTS_SESSION_AGGREGATION_FIELDS) as Array<
keyof typeof EVENTS_SESSION_AGGREGATION_FIELDS
>,
@@ -1980,7 +1980,7 @@ export class EventsAggQueryBuilder extends AbstractCTEQueryBuilder {
* Aggregation fields for experiment-level queries.
* These fields use ClickHouse aggregation functions and require GROUP BY experiment_id, project_id.
*/
-const EXPERIMENTS_AGGREGATION_FIELDS = {
+export const EXPERIMENTS_AGGREGATION_FIELDS = {
// Base aggregated fields
experimentId: "e.experiment_id AS experiment_id",
experimentName: "any(e.experiment_name) AS experiment_name",
@@ -2007,7 +2007,7 @@ const EXPERIMENTS_AGGREGATION_FIELDS = {
/**
* Field sets for experiment aggregation queries.
*/
-const EXPERIMENTS_AGGREGATION_FIELD_SETS = {
+export const EXPERIMENTS_AGGREGATION_FIELD_SETS = {
count: ["experimentId"] as const,
base: [
"experimentId",
diff --git a/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts b/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
index 7aea2a495b..3411a1c298 100644
--- a/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
+++ b/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
@@ -35,59 +35,6 @@ export const eventsTraceMetadata = (projectId: string): EventsQueryBuilder =>
.whereRaw("e.is_deleted = 0")
.limitBy("e.trace_id");
-export const promptEventsForMetrics = (params: {
- projectId: string;
- promptIds: string[];
- fromTimestamp?: string;
- toTimestamp?: string;
-}): CTEWithSchema => {
- const builder = new EventsQueryBuilder({ projectId: params.projectId })
- .selectRaw(
- "e.project_id AS project_id",
- "e.prompt_id AS prompt_id",
- "e.prompt_version AS prompt_version",
- "e.trace_id AS trace_id",
- "e.span_id AS span_id",
- "e.start_time AS start_time",
- "e.end_time AS end_time",
- "e.usage_details AS usage_details",
- "e.cost_details AS cost_details",
- "e.is_deleted AS is_deleted",
- )
- .whereRaw("e.type = 'GENERATION'")
- .whereRaw("e.prompt_id IN ({promptIds: Array(String)})", {
- promptIds: params.promptIds,
- })
- .when(Boolean(params.fromTimestamp), (b) =>
- b.whereRaw("e.start_time >= {fromTimestamp: DateTime64(6)}", {
- fromTimestamp: params.fromTimestamp,
- }),
- )
- .when(Boolean(params.toTimestamp), (b) =>
- b.whereRaw("e.start_time <= {toTimestamp: DateTime64(6)}", {
- toTimestamp: params.toTimestamp,
- }),
- )
- .orderByColumns([{ column: "e.event_ts", direction: "DESC" }])
- .limitBy("e.span_id", "e.project_id");
-
- return {
- ...builder.buildWithParams(),
- schema: [
- "project_id",
- "prompt_id",
- "prompt_version",
- "trace_id",
- "span_id",
- "start_time",
- "end_time",
- "usage_details",
- "cost_details",
- "is_deleted",
- ],
- };
-};
-
interface EventsTracesAggregationParams {
projectId: string;
traceIds?: string[];
diff --git a/packages/shared/src/server/queries/index.ts b/packages/shared/src/server/queries/index.ts
index cd8ee8c16f..aa2d9e3c0a 100644
--- a/packages/shared/src/server/queries/index.ts
+++ b/packages/shared/src/server/queries/index.ts
@@ -91,7 +91,6 @@ export {
eventsTraceMetadata,
eventsTracesAggregation,
eventsTracesScoresAggregation,
- promptEventsForMetrics,
scoreBooleansAggregation,
} from "./clickhouse-sql/query-fragments";
export {
diff --git a/packages/shared/src/server/query-ast/binds.test.ts b/packages/shared/src/server/query-ast/binds.test.ts
index 3be4215484..21577f8b5e 100644
--- a/packages/shared/src/server/query-ast/binds.test.ts
+++ b/packages/shared/src/server/query-ast/binds.test.ts
@@ -1,9 +1,12 @@
+import { sql as sql_ } from "kysely";
import { describe, expect, it } from "vitest";
import { compileClickhouseQuery } from "./compile";
import { getClickhouseKysely } from "./dialect";
+import { useFinal } from "./extensions";
const ctx = { projectId: "proj-1" };
+const START = new Date("2026-01-01T00:00:00.000Z");
function compile(builder: Parameters<typeof compileClickhouseQuery>[0]) {
return compileClickhouseQuery(builder, ctx);
@@ -45,7 +48,7 @@ describe("typed params from the column registry", () => {
expect(sql).not.toMatch(/metadata_names in \(\{p\d+:Array\(String\)\}\)/);
});
- it("keeps DateTime64(3) when comparing through toStartOfMinute / toDate", () => {
+ it("keeps the column's DateTime precision through toStartOfMinute / toDate", () => {
const start = "2026-01-01 00:00:00.000";
const { sql: minuteSql } = compile(
getClickhouseKysely()
@@ -60,7 +63,7 @@ describe("typed params from the column registry", () => {
),
);
expect(minuteSql).toMatch(
- /toStartOfMinute\(start_time\) = toStartOfMinute\(\{p\d+:DateTime64\(3\)\}\)/,
+ /toStartOfMinute\(start_time\) = toStartOfMinute\(\{p\d+:DateTime64\(6\)\}\)/,
);
const { sql: dateSql } = compile(
@@ -80,6 +83,270 @@ describe("typed params from the column registry", () => {
);
});
+ it("binds a shared column name with the type of the table it is read from", () => {
+ const { sql } = compile(
+ getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select("e.span_id")
+ .where("e.start_time", ">=", START)
+ .where("e.trace_id", "in", (qb) =>
+ qb
+ .selectFrom("observations")
+ .select("trace_id")
+ .where("start_time", ">=", START),
+ ),
+ );
+ expect(sql).toMatch(/e\.start_time >= \{p\d+:DateTime64\(6\)\}/);
+ expect(sql).toMatch(
+ /where project_id = .* and start_time >= \{p\d+:DateTime64\(3\)\}/,
+ );
+ });
+
+ it("resolves the bind type through a FINAL table", () => {
+ const { sql } = compile(
+ getClickhouseKysely()
+ .selectFrom("scores as s")
+ .select("s.id")
+ .where("s.event_ts", ">=", START)
+ .$call(useFinal(["scores"])),
+ );
+ expect(sql).toMatch(/s\.event_ts >= \{p\d+:DateTime64\(3\)\}/);
+ });
+
+ it("resolves a qualifier declared in an enclosing select", () => {
+ const { sql } = compile(
+ getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select("e.span_id")
+ .where((eb) =>
+ eb.exists(
+ eb
+ .selectFrom("observations as o")
+ .select("o.trace_id")
+ .where("e.start_time", ">=", START),
+ ),
+ ),
+ );
+ expect(sql).toMatch(/e\.start_time >= \{p\d+:DateTime64\(6\)\}/);
+ });
+
+ // A CTE or subquery column keeps the type of the column it selects.
+ it.each([
+ [
+ "a CTE named like a registry table",
+ () =>
+ getClickhouseKysely()
+ .with("observations", (db) =>
+ db.selectFrom("events_core").select("start_time"),
+ )
+ .selectFrom("observations")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ [
+ "an aliased CTE column read through a table alias",
+ () =>
+ getClickhouseKysely()
+ .with("recent", (db) =>
+ db.selectFrom("events_core as e").select("e.start_time as ts"),
+ )
+ .selectFrom("recent as r")
+ .select("r.ts")
+ .where("r.ts", ">=", START),
+ ],
+ [
+ "a CTE reading an earlier CTE",
+ () =>
+ getClickhouseKysely()
+ .with("first", (db) =>
+ db.selectFrom("events_core").select("start_time"),
+ )
+ .with("second", (db) => db.selectFrom("first").selectAll())
+ .selectFrom("second")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ [
+ "an aliased subquery in FROM",
+ () =>
+ getClickhouseKysely()
+ .selectFrom((db) =>
+ db.selectFrom("events_core").select("start_time").as("sub"),
+ )
+ .select("sub.start_time")
+ .where("sub.start_time", ">=", START),
+ ],
+ [
+ "a type-preserving aggregate in a CTE",
+ () =>
+ getClickhouseKysely()
+ .with("bounds", (db) =>
+ db
+ .selectFrom("events_core")
+ .select((eb) => eb.fn.max("start_time").as("start_time")),
+ )
+ .selectFrom("bounds")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ [
+ "max written as a plain function",
+ () =>
+ getClickhouseKysely()
+ .with("bounds", (db) =>
+ db
+ .selectFrom("events_core")
+ .select((eb) =>
+ eb.fn<Date>("max", ["start_time"]).as("start_time"),
+ ),
+ )
+ .selectFrom("bounds")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ [
+ "argMax",
+ () =>
+ getClickhouseKysely()
+ .with("latest", (db) =>
+ db
+ .selectFrom("events_core")
+ .select((eb) =>
+ eb
+ .fn<Date>("argMax", ["start_time", "event_ts"])
+ .as("start_time"),
+ ),
+ )
+ .selectFrom("latest")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ [
+ "anyLast",
+ () =>
+ getClickhouseKysely()
+ .with("latest", (db) =>
+ db
+ .selectFrom("events_core")
+ .select((eb) => eb.fn<Date>("anyLast", ["start_time"]).as("ts")),
+ )
+ .selectFrom("latest")
+ .select("ts")
+ .where("ts", ">=", START),
+ ],
+ [
+ "a qualified * in a CTE",
+ () =>
+ getClickhouseKysely()
+ .with("rows", (db) =>
+ db.selectFrom("events_core as e").selectAll("e"),
+ )
+ .selectFrom("rows")
+ .select("start_time")
+ .where("start_time", ">=", START),
+ ],
+ ])("propagates the source column type through %s", (_, build) => {
+ const { sql } = compile(build());
+ expect(sql).toMatch(/(start_time|ts) >= \{p\d+:DateTime64\(6\)\}/);
+ });
+
+ // When the column's table can't be resolved, the bind type falls back to the
+ // JS value: a Date binds as DateTime64(3), even against events.
+ it.each([
+ [
+ "a JOIN where an unqualified column exists with different types",
+ () =>
+ getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .innerJoin("observations as o", "o.trace_id", "e.trace_id")
+ .select("e.span_id")
+ .where("start_time", ">=", START),
+ ],
+ ])("falls back to value inference for %s", (_, build) => {
+ const { sql } = compile(build());
+ expect(sql).toMatch(/start_time >= \{p\d+:DateTime64\(3\)\}/);
+ });
+
+ it("propagates the source column type through a JOIN to an aliased subquery", () => {
+ const db = getClickhouseKysely();
+ const sub = db
+ .selectFrom("events_core")
+ .select(["trace_id", "start_time"])
+ .as("sub");
+ const { sql } = compile(
+ db
+ .selectFrom("observations as o")
+ .innerJoin(sub, "sub.trace_id", "o.trace_id")
+ .select("o.trace_id")
+ .where("sub.start_time", ">=", START),
+ );
+ expect(sql).toMatch(/sub\.start_time >= \{p\d+:DateTime64\(6\)\}/);
+ });
+
+ describe("columns the compiler can't resolve to a relation", () => {
+ const db = getClickhouseKysely();
+
+ it("binds by value when no relation in scope has the column", () => {
+ const { sql } = compile(
+ db
+ .selectFrom("traces")
+ .select("id")
+ .where(db.dynamic.ref("total_cost"), ">", 1),
+ );
+ expect(sql).toMatch(/total_cost > \{p\d+:Int64\}/);
+ });
+
+ it("binds a named raw-SQL CTE column by value", () => {
+ const { sql } = compile(
+ db
+ .with("t", (qb) =>
+ qb
+ .selectFrom("events_core")
+ .select(sql_`is_deleted`.as("is_deleted")),
+ )
+ .selectFrom("t")
+ .select("is_deleted")
+ .where("is_deleted", "=", 0),
+ );
+ expect(sql).toMatch(/is_deleted = \{p\d+:Int64\}/);
+ });
+
+ it("uses the name-only type for a table-function source", () => {
+ const { sql } = compile(
+ db
+ .selectFrom((eb) => eb.fn("numbers", [eb.lit(10)]).as("n"))
+ .selectAll()
+ .where(db.dynamic.ref("n.is_deleted"), "=", 0),
+ );
+ expect(sql).toMatch(/n\.is_deleted = \{p\d+:UInt8\}/);
+ });
+
+ it("uses the name-only type for a qualifier declared nowhere", () => {
+ const { sql } = compile(
+ db
+ .selectFrom("events_core")
+ .select("span_id")
+ .where(db.dynamic.ref("x.is_deleted"), "=", 0),
+ );
+ expect(sql).toMatch(/x\.is_deleted = \{p\d+:UInt8\}/);
+ });
+ });
+
+ it("does not propagate the source type through a type-changing aggregate", () => {
+ const { sql } = compile(
+ getClickhouseKysely()
+ .with("totals", (db) =>
+ db
+ .selectFrom("events_core")
+ .select((eb) => eb.fn.count("prompt_version").as("prompt_version")),
+ )
+ .selectFrom("totals")
+ .select("prompt_version")
+ .where("prompt_version", ">=", 1),
+ );
+ expect(sql).toMatch(/prompt_version >= \{p\d+:Int64\}/);
+ });
+
it("does not type extra date-wrapper arguments as the column", () => {
const { sql } = compile(
getClickhouseKysely()
diff --git a/packages/shared/src/server/query-ast/compiler.ts b/packages/shared/src/server/query-ast/compiler.ts
index 65d5121689..f6302b7290 100644
--- a/packages/shared/src/server/query-ast/compiler.ts
+++ b/packages/shared/src/server/query-ast/compiler.ts
@@ -1,19 +1,24 @@
import {
+ AggregateFunctionNode,
+ AliasNode,
BinaryOperationNode,
ColumnNode,
CreateTableNode,
CreateViewNode,
DefaultQueryCompiler,
FunctionNode,
+ IdentifierNode,
InsertQueryNode,
ParensNode,
ReferenceNode,
+ SelectAllNode,
+ SelectQueryNode,
SetOperationNode,
+ TableNode,
ValueNode,
type OperationNode,
type PrimitiveValueListNode,
type RootOperationNode,
- type SelectQueryNode,
type ValueListNode,
} from "kysely";
import type { QueryId } from "kysely";
@@ -25,7 +30,7 @@ import {
type ClickHouseSelectQueryNode,
type LimitByNode,
} from "./nodes";
-import { COLUMN_BIND_TYPES } from "./schema";
+import { COLUMN_BIND_TYPES, TABLE_BIND_TYPES } from "./schema";
import { assertTenancyStamped } from "./tenancy";
const ARRAY_JOIN_SQL: Record<ArrayJoinNode["variant"], string> = {
@@ -67,6 +72,80 @@ function inferClickHouseType(value: unknown): string {
return "String";
}
+/**
+ * Column bind types of the relation `name` resolves to: the innermost CTE of
+ * that name, else the registry table, else undefined.
+ */
+function relationBindTypes(
+ name: string,
+ scopes: readonly { ctes: Map<string, ColumnBindTypes> }[],
+): ColumnBindTypes | undefined {
+ for (const scope of [...scopes].reverse()) {
+ const cte = scope.ctes.get(name);
+ if (cte) return cte;
+ }
+ return TABLE_BIND_TYPES[name];
+}
+
+/**
+ * Aggregates whose result has the type of their first argument. Others change
+ * it (`count`/`uniq` → UInt64, `sum` widens, `avg`/`median` → Float64), so
+ * their output falls back like any computed column.
+ */
+const TYPE_PRESERVING_AGGREGATES = new Set([
+ "min",
+ "max",
+ "any",
+ "anyLast",
+ "argMin",
+ "argMax",
+]);
+
+/** The operand whose type `node` keeps: the first argument of a type-preserving aggregate, else `node`. */
+function typePreservedOperand(node: OperationNode): OperationNode {
+ if (AggregateFunctionNode.is(node) && !node.over) {
+ return TYPE_PRESERVING_AGGREGATES.has(node.func) && node.aggregated[0]
+ ? node.aggregated[0]
+ : node;
+ }
+ if (FunctionNode.is(node)) {
+ return TYPE_PRESERVING_AGGREGATES.has(node.func) && node.arguments[0]
+ ? node.arguments[0]
+ : node;
+ }
+ return node;
+}
+
+/**
+ * Column name and qualifier of a column operand. Kysely parses `"start_time"`
+ * to a bare ColumnNode and `"e.start_time"` to a ReferenceNode carrying the
+ * table, so only the latter has a qualifier.
+ */
+function columnReference(
+ node: OperationNode,
+): { column: string; qualifier: string | undefined } | undefined {
+ if (ColumnNode.is(node)) {
+ return { column: node.column.name, qualifier: undefined };
+ }
+ if (ReferenceNode.is(node) && ColumnNode.is(node.column)) {
+ return {
+ column: node.column.column.name,
+ qualifier: node.table?.table.identifier.name,
+ };
+ }
+ return undefined;
+}
+
+/** Bind type per column name of one relation. */
+type ColumnBindTypes = Readonly<Record<string, string>>;
+
+type SelectScope = {
+ /** CTEs declared by this SELECT's WITH → bind types of their output columns. */
+ ctes: Map<string, ColumnBindTypes>;
+ /** FROM/JOIN names and aliases → the relation's column bind types, or undefined when unknown. */
+ relations: Map<string, ColumnBindTypes | undefined>;
+};
+
/**
* ClickHouse SQL compiler. Identifier quoting is omitted so `clickhouse format`
* matches the golden snapshots (unquoted identifiers). Parameters are named
@@ -93,6 +172,11 @@ export class ClickHouseQueryCompiler extends DefaultQueryCompiler {
* column is in scope.
*/
private pendingBindType: string | undefined;
+ /**
+ * The SELECTs enclosing the node being compiled, innermost last. A column
+ * operand looks up its table here to pick its registry bind type.
+ */
+ private selectScopes: SelectScope[] = [];
constructor() {
super();
@@ -128,6 +212,7 @@ export class ClickHouseQueryCompiler extends DefaultQueryCompiler {
compileQuery(node: RootOperationNode, queryId: QueryId) {
this.namedParameters = {};
this.intern = new Map();
+ this.selectScopes = [];
assertTenancyStamped(node);
return super.compileQuery(node, queryId);
}
@@ -155,8 +240,8 @@ export class ClickHouseQueryCompiler extends DefaultQueryCompiler {
*/
protected override visitBinaryOperation(node: BinaryOperationNode): void {
const columnType =
- bindTypeOfColumnOperand(node.leftOperand) ??
- bindTypeOfColumnOperand(node.rightOperand);
+ this.bindTypeOfColumnOperand(node.leftOperand) ??
+ this.bindTypeOfColumnOperand(node.rightOperand);
const previous = this.pendingBindType;
if (columnType) this.pendingBindType = columnType;
super.visitBinaryOperation(node);
@@ -205,13 +290,157 @@ export class ClickHouseQueryCompiler extends DefaultQueryCompiler {
// clear the pending bind type across the (forked) body and restore it after.
const previousBindType = this.pendingBindType;
this.pendingBindType = undefined;
+ this.selectScopes.push(this.selectScopeOf(node, this.selectScopes));
try {
this.visitSelectQueryBody(node);
} finally {
+ this.selectScopes.pop();
this.pendingBindType = previousBindType;
}
}
+ /**
+ * What one SELECT makes visible to the columns compiled inside it: the CTEs
+ * its WITH declares, and each FROM/JOIN name or alias mapped to the column
+ * bind types of the relation it reads.
+ */
+ private selectScopeOf(
+ node: SelectQueryNode,
+ enclosing: readonly SelectScope[],
+ ): SelectScope {
+ const scope: SelectScope = { ctes: new Map(), relations: new Map() };
+ const scopes = [...enclosing, scope];
+ // In declaration order, so a CTE can read an earlier one.
+ for (const cte of node.with?.expressions ?? []) {
+ scope.ctes.set(
+ cte.name.table.table.identifier.name,
+ this.outputBindTypes(cte.expression, scopes) ?? COLUMN_BIND_TYPES,
+ );
+ }
+ const relations = [
+ ...(node.from?.froms ?? []),
+ ...(node.joins ?? []).map((join) => join.table),
+ ];
+ for (const wrapped of relations) {
+ // FINAL wraps the whole relation, alias included: `scores AS s FINAL`.
+ const maybeFinal: { kind: string } = wrapped;
+ const relation = FinalTableNode.is(maybeFinal)
+ ? maybeFinal.table
+ : wrapped;
+ const aliased = AliasNode.is(relation) ? relation : undefined;
+ const inner = aliased ? aliased.node : relation;
+ const table = TableNode.is(inner)
+ ? inner.table.identifier.name
+ : undefined;
+ const columns = table
+ ? relationBindTypes(table, scopes)
+ : this.outputBindTypes(inner, scopes);
+ if (table) scope.relations.set(table, columns);
+ if (aliased && IdentifierNode.is(aliased.alias)) {
+ scope.relations.set(aliased.alias.name, columns);
+ }
+ }
+ return scope;
+ }
+
+ /**
+ * Bind types of the columns a CTE body or FROM subquery outputs. A selected
+ * column keeps the type it has in its source relation, under its alias if it
+ * has one, also through a type-preserving aggregate such as `max(col)`.
+ * Other computed columns bind by value.
+ */
+ private outputBindTypes(
+ node: OperationNode,
+ enclosing: readonly SelectScope[],
+ ): ColumnBindTypes | undefined {
+ if (!SelectQueryNode.is(node)) return undefined;
+ const scopes = [...enclosing, this.selectScopeOf(node, enclosing)];
+ // Columns the body doesn't name (an unaliased raw selection) keep the
+ // name-only fallback; a named computed column binds by value.
+ const columns: Record<string, string> = { ...COLUMN_BIND_TYPES };
+ for (const { selection } of node.selections ?? []) {
+ if (SelectAllNode.is(selection)) {
+ for (const relation of scopes.at(-1)!.relations.values()) {
+ Object.assign(columns, relation);
+ }
+ continue;
+ }
+ if (ReferenceNode.is(selection) && SelectAllNode.is(selection.column)) {
+ const qualifier = selection.table?.table.identifier.name;
+ Object.assign(
+ columns,
+ qualifier ? scopes.at(-1)!.relations.get(qualifier) : undefined,
+ );
+ continue;
+ }
+ const aliased = AliasNode.is(selection) ? selection : undefined;
+ const ref = columnReference(
+ typePreservedOperand(aliased ? aliased.node : selection),
+ );
+ const name =
+ aliased && IdentifierNode.is(aliased.alias)
+ ? aliased.alias.name
+ : ref?.column;
+ const bindType =
+ ref && this.columnBindType(ref.column, ref.qualifier, scopes);
+ if (!name) continue;
+ if (bindType) columns[name] = bindType;
+ else delete columns[name];
+ }
+ return columns;
+ }
+
+ /**
+ * Bind type of `column` in `scopes` (innermost last). A qualified column
+ * (`e.start_time`) uses the innermost SELECT that declares the qualifier. An
+ * unqualified one uses the innermost SELECT's relations when they agree on
+ * the type, and binds by value when none of them has it. Otherwise fall back
+ * to the type the column has in every table, if it has only one.
+ */
+ private columnBindType(
+ column: string,
+ qualifier: string | undefined,
+ scopes: readonly SelectScope[] = this.selectScopes,
+ ): string | undefined {
+ if (qualifier) {
+ for (const scope of [...scopes].reverse()) {
+ if (!scope.relations.has(qualifier)) continue;
+ const columns = scope.relations.get(qualifier);
+ return columns ? columns[column] : COLUMN_BIND_TYPES[column];
+ }
+ return COLUMN_BIND_TYPES[column];
+ }
+ const relations = [...new Set(scopes.at(-1)?.relations.values() ?? [])];
+ const candidates = new Set(
+ relations
+ .map((columns) => columns?.[column])
+ .filter((bindType): bindType is string => bindType !== undefined),
+ );
+ if (candidates.size === 1) return [...candidates][0];
+ // No relation has the column: guess by name only if one is opaque.
+ if (candidates.size === 0 && relations.every((columns) => columns)) {
+ return undefined;
+ }
+ return COLUMN_BIND_TYPES[column];
+ }
+
+ /** Bind type of a comparison operand that is a column, or undefined. */
+ private bindTypeOfColumnOperand(node: OperationNode): string | undefined {
+ const ref = columnReference(node);
+ if (ref) return this.columnBindType(ref.column, ref.qualifier);
+ // Single-argument date wrappers (`toDate(timestamp)`) keep the inner
+ // column's bind type. Extra arguments such as a timezone are not column
+ // values.
+ if (
+ FunctionNode.is(node) &&
+ DATE_WRAPPER_FNS.has(node.func) &&
+ node.arguments.length === 1
+ ) {
+ return this.bindTypeOfColumnOperand(node.arguments[0]);
+ }
+ return undefined;
+ }
+
/**
* Wholesale copy of Kysely's `DefaultQueryCompiler.visitSelectQuery` (kept in
* sync with the pinned 0.28.17) with two ClickHouse-only insertions:
@@ -390,21 +619,3 @@ export class ClickHouseQueryCompiler extends DefaultQueryCompiler {
return `{${name}:${inferred}}`;
}
}
-
-function bindTypeOfColumnOperand(node: OperationNode): string | undefined {
- if (ColumnNode.is(node)) return COLUMN_BIND_TYPES[node.column.name];
- if (ReferenceNode.is(node) && ColumnNode.is(node.column)) {
- return COLUMN_BIND_TYPES[node.column.column.name];
- }
- // Single-argument date wrappers (`toDate(timestamp)`) keep the inner
- // column's bind type so the compared value is still DateTime64(3). Extra
- // arguments such as a timezone are not column values.
- if (
- FunctionNode.is(node) &&
- DATE_WRAPPER_FNS.has(node.func) &&
- node.arguments.length === 1
- ) {
- return bindTypeOfColumnOperand(node.arguments[0]);
- }
- return undefined;
-}
diff --git a/packages/shared/src/server/query-ast/extensions.ts b/packages/shared/src/server/query-ast/extensions.ts
index 1279aafe37..7121964e57 100644
--- a/packages/shared/src/server/query-ast/extensions.ts
+++ b/packages/shared/src/server/query-ast/extensions.ts
@@ -10,19 +10,23 @@
* that apply those plugins while extending the builder's output row type,
* so produced aliases are type-checked and misspelled references are
* compile errors.
- * - Typed expression helpers ({@link mapKeys}, {@link mapValues},
- * {@link metadataValue}) that build ClickHouse map/array function calls and
- * `metadata[key]` subscripts as real, parameter-bound nodes — never raw SQL
- * strings — so they escape and compose like any other expression.
+ * - Typed expression helpers ({@link mapKeys}, {@link metadataValue},
+ * {@link medianExact}, …) that build ClickHouse aggregates, map/array
+ * function calls and `metadata[key]` subscripts as real, parameter-bound
+ * nodes — never raw SQL strings — so they escape and compose like any other
+ * expression.
*/
import {
+ AggregateFunctionNode,
AliasNode,
+ BinaryOperationNode,
ColumnNode,
ExpressionWrapper,
FromNode,
FunctionNode,
IdentifierNode,
JoinNode,
+ OperatorNode,
ReferenceNode,
TableNode,
ValueNode,
@@ -164,6 +168,110 @@ export function mapValues<V = string>(column: string): Expression<V[]> {
return arrayFunction<V>("mapValues", column);
}
+/** ClickHouse `uniq(column)`, an approximate distinct count. */
+export function uniq(
+ column: string,
+): ExpressionWrapper<ClickHouseDatabase, keyof ClickHouseDatabase, string> {
+ return new ExpressionWrapper(
+ AggregateFunctionNode.create("uniq", [
+ columnRef(column),
+ ]) as unknown as OperationNode,
+ );
+}
+
+/** ClickHouse `count()`. Kysely's `eb.fn.countAll()` renders `count(*)`. */
+export function count(): ExpressionWrapper<
+ ClickHouseDatabase,
+ keyof ClickHouseDatabase,
+ string
+> {
+ return new ExpressionWrapper(
+ AggregateFunctionNode.create("count", []) as unknown as OperationNode,
+ );
+}
+
+/** ClickHouse `medianExact(expression)`. */
+export function medianExact(
+ expression: Expression<unknown>,
+): ExpressionWrapper<ClickHouseDatabase, keyof ClickHouseDatabase, string> {
+ return new ExpressionWrapper(
+ AggregateFunctionNode.create("medianExact", [
+ expression.toOperationNode(),
+ ]) as unknown as OperationNode,
+ );
+}
+
+type DateDiffUnit = "millisecond" | "second" | "minute" | "hour" | "day";
+
+/** ClickHouse `dateDiff(unit, start, end)` between two columns. */
+export function dateDiff(
+ unit: DateDiffUnit,
+ start: string,
+ end: string,
+): Expression<number> {
+ return new ExpressionWrapper<
+ ClickHouseDatabase,
+ keyof ClickHouseDatabase,
+ number
+ >(
+ // ClickHouse requires the unit to be a constant, so it is inlined rather
+ // than bound. `DateDiffUnit` keeps it to known keywords.
+ FunctionNode.create("dateDiff", [
+ ValueNode.createImmediate(unit),
+ columnRef(start),
+ columnRef(end),
+ ]) as unknown as OperationNode,
+ );
+}
+
+/** `map[key]` subscript with a bound key. */
+export function mapValue<V = number>(
+ column: string,
+ key: string,
+): Expression<V> {
+ return new ExpressionWrapper<ClickHouseDatabase, keyof ClickHouseDatabase, V>(
+ ArrayIndexNode.create(
+ columnRef(column),
+ ValueNode.create(key),
+ ) as unknown as OperationNode,
+ );
+}
+
+/**
+ * Sum of the map values whose key contains `needle`, case-insensitively:
+ * `arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, needle) > 0, map)))`.
+ * The lambda is built as a `->` binary operation; Kysely has no lambda node.
+ */
+export function sumMapValuesWhereKeyContains(
+ column: string,
+ needle: string,
+): Expression<number> {
+ const keyMatches = BinaryOperationNode.create(
+ FunctionNode.create("positionCaseInsensitive", [
+ qualifiedColumn("x", "1"),
+ ValueNode.create(needle),
+ ]),
+ OperatorNode.create(">"),
+ ValueNode.createImmediate(0),
+ );
+ const lambda = BinaryOperationNode.create(
+ ColumnNode.create("x"),
+ OperatorNode.create("->"),
+ keyMatches,
+ );
+ return new ExpressionWrapper<
+ ClickHouseDatabase,
+ keyof ClickHouseDatabase,
+ number
+ >(
+ FunctionNode.create("arraySum", [
+ FunctionNode.create("mapValues", [
+ FunctionNode.create("mapFilter", [lambda, columnRef(column)]),
+ ]),
+ ]) as unknown as OperationNode,
+ );
+}
+
/**
* Lower `metadata[key]` to a traced array-subscript + `indexOf` node.
* The key is a bound `ValueNode`, not a SQL literal.
diff --git a/packages/shared/src/server/query-ast/fixtures/catalog.ts b/packages/shared/src/server/query-ast/fixtures/catalog.ts
index 12c2415201..54d78d9922 100644
--- a/packages/shared/src/server/query-ast/fixtures/catalog.ts
+++ b/packages/shared/src/server/query-ast/fixtures/catalog.ts
@@ -122,7 +122,7 @@ export const CATALOG: CatalogEntry[] = [
referenceSql: `
SELECT DISTINCT environment
FROM events_core
- WHERE (project_id = {p1:String}) AND (start_time >= {p2:DateTime64(3)})
+ WHERE (project_id = {p1:String}) AND (start_time >= {p2:DateTime64(6)})
`,
build: () =>
db()
@@ -392,7 +392,7 @@ export const CATALOG: CatalogEntry[] = [
referenceSql: `
SELECT DISTINCT environment
FROM events_core
- WHERE (project_id = {p1:String}) AND (start_time >= {p2:DateTime64(3)})
+ WHERE (project_id = {p1:String}) AND (start_time >= {p2:DateTime64(6)})
`,
build: () =>
environmentsVariant({ writeMode: "events", fromTimestamp: FROM_TS }),
diff --git a/packages/shared/src/server/query-ast/schema.test.ts b/packages/shared/src/server/query-ast/schema.test.ts
index bee42c43f1..ed6bbc0cda 100644
--- a/packages/shared/src/server/query-ast/schema.test.ts
+++ b/packages/shared/src/server/query-ast/schema.test.ts
@@ -3,6 +3,7 @@ import { describe, expect, it } from "vitest";
import {
COLUMN_BIND_TYPES,
COLUMN_DATA_TYPES,
+ TABLE_BIND_TYPES,
DEDUP_SPECS,
TENANTED_TABLES,
} from "./schema";
@@ -39,7 +40,9 @@ describe("table registry derivation", () => {
it("derives ClickHouse bind types from the same column declarations", () => {
expect(COLUMN_BIND_TYPES.total_cost).toBe("Float64");
- expect(COLUMN_BIND_TYPES.start_time).toBe("DateTime64(3)");
+ expect(TABLE_BIND_TYPES.events_core.start_time).toBe("DateTime64(6)");
+ expect(TABLE_BIND_TYPES.observations.start_time).toBe("DateTime64(3)");
+ expect(COLUMN_BIND_TYPES.start_time).toBeUndefined();
expect(COLUMN_BIND_TYPES.project_id).toBe("String");
expect(COLUMN_BIND_TYPES.metadata_names).toBe("Array(String)");
expect(COLUMN_BIND_TYPES.is_deleted).toBe("UInt8");
diff --git a/packages/shared/src/server/query-ast/schema.ts b/packages/shared/src/server/query-ast/schema.ts
index 7a6878fe2d..babe97d2a5 100644
--- a/packages/shared/src/server/query-ast/schema.ts
+++ b/packages/shared/src/server/query-ast/schema.ts
@@ -6,8 +6,8 @@
* comparisons).
* - `COLUMN_DATA_TYPES` — the coarse runtime type map the aggregate type-check
* pass consults (`typecheck.ts`).
- * - `COLUMN_BIND_TYPES` — the ClickHouse bind types the compiler uses when a
- * value is compared to a known column (`compiler.ts`).
+ * - `TABLE_BIND_TYPES` / `COLUMN_BIND_TYPES` — the ClickHouse bind types the
+ * compiler uses when a value is compared to a known column (`compiler.ts`).
* - `TENANTED_TABLES` — the relations the tenancy pass must scope
* (`tenancy.ts`).
* - `DEDUP_SPECS` — the per-table read idiom the lowering pass applies
@@ -28,26 +28,39 @@ export type ChColumnType =
| "String"
| "Float"
| "DateTime"
+ | "DateTime64(6)"
| "UInt8"
+ | "UInt16"
+ | "Nullable(UInt16)"
+ | "Nullable(DateTime64(6))"
| "Array(String)"
| "Map(String, Float)"
+ | "Map(String, UInt64)"
+ | "Map(String, Decimal(18,12))"
| "Map(String, String)";
type TsTypeOfColumn<T extends ChColumnType> = T extends "String"
? string
: T extends "Float"
? number
- : T extends "UInt8"
+ : T extends "UInt8" | "UInt16"
? number
- : T extends "DateTime"
- ? Date
- : T extends "Array(String)"
- ? string[]
- : T extends "Map(String, Float)"
- ? Record<string, number>
- : T extends "Map(String, String)"
- ? Record<string, string>
- : never;
+ : T extends "Nullable(UInt16)"
+ ? number | null
+ : T extends "DateTime" | "DateTime64(6)"
+ ? Date
+ : T extends "Nullable(DateTime64(6))"
+ ? Date | null
+ : T extends "Array(String)"
+ ? string[]
+ : T extends
+ | "Map(String, Float)"
+ | "Map(String, UInt64)"
+ | "Map(String, Decimal(18,12))"
+ ? Record<string, number>
+ : T extends "Map(String, String)"
+ ? Record<string, string>
+ : never;
/** Coarse runtime category the aggregate type-check pass reasons about. */
export type ColumnDataType = "string" | "number" | "date" | "array" | "map";
@@ -56,9 +69,15 @@ const RUNTIME_TYPE: Record<ChColumnType, ColumnDataType> = {
String: "string",
Float: "number",
UInt8: "number",
+ UInt16: "number",
+ "Nullable(UInt16)": "number",
DateTime: "date",
+ "DateTime64(6)": "date",
+ "Nullable(DateTime64(6))": "date",
"Array(String)": "array",
"Map(String, Float)": "map",
+ "Map(String, UInt64)": "map",
+ "Map(String, Decimal(18,12))": "map",
"Map(String, String)": "map",
};
@@ -105,14 +124,22 @@ function defineTable<const Cols extends Record<string, ChColumnType>>(spec: {
const EVENTS_COLUMNS = {
environment: "String",
project_id: "String",
- start_time: "DateTime",
+ start_time: "DateTime64(6)",
span_id: "String",
trace_id: "String",
- event_ts: "DateTime",
+ event_ts: "DateTime64(6)",
type: "String",
total_cost: "Float",
experiment_id: "String",
prompt_id: "String",
+ prompt_name: "String",
+ prompt_version: "Nullable(UInt16)",
+ usage_details: "Map(String, UInt64)",
+ cost_details: "Map(String, Decimal(18,12))",
+ ingestion_sdk_name: "String",
+ ingestion_sdk_version: "String",
+ telemetry_sdk_language: "String",
+ source: "String",
is_deleted: "UInt8",
metadata_names: "Array(String)",
metadata_values: "Array(String)",
@@ -120,7 +147,7 @@ const EVENTS_COLUMNS = {
session_id: "String",
name: "String",
parent_span_id: "String",
- end_time: "DateTime",
+ end_time: "Nullable(DateTime64(6))",
tags: "Array(String)",
} as const satisfies Record<string, ChColumnType>;
@@ -234,17 +261,51 @@ const BIND_TYPE: Record<ChColumnType, string> = {
String: "String",
Float: "Float64",
UInt8: "UInt8",
+ UInt16: "UInt16",
+ // A bound value is never NULL; NULL checks compile to `IS NULL`.
+ "Nullable(UInt16)": "UInt16",
DateTime: "DateTime64(3)",
+ "DateTime64(6)": "DateTime64(6)",
+ "Nullable(DateTime64(6))": "DateTime64(6)",
"Array(String)": "Array(String)",
"Map(String, Float)": "Map(String, Float64)",
+ "Map(String, UInt64)": "Map(String, UInt64)",
+ "Map(String, Decimal(18,12))": "Map(String, Decimal(18, 12))",
"Map(String, String)": "Map(String, String)",
};
-export const COLUMN_BIND_TYPES: Record<string, string> = Object.fromEntries(
- Object.values(TABLE_REGISTRY).flatMap((table) =>
- Object.entries(table.columns).map(([name, chType]) => [
- name,
- BIND_TYPE[chType],
- ]),
- ),
+/** Bind type per column, per registry table. */
+export const TABLE_BIND_TYPES: Record<
+ string,
+ Record<string, string>
+> = Object.fromEntries(
+ Object.entries(TABLE_REGISTRY).map(([table, spec]) => [
+ table,
+ Object.fromEntries(
+ Object.entries(spec.columns).map(([name, chType]) => [
+ name,
+ BIND_TYPE[chType],
+ ]),
+ ),
+ ]),
);
+
+/**
+ * Bind type by bare column name, for operands whose relation is opaque to the
+ * compiler (e.g. a table-function source). Only names with the same bind type in
+ * every table are kept, since `start_time` is `DateTime64(6)` on events but
+ * `DateTime64(3)` on observations.
+ */
+export const COLUMN_BIND_TYPES: Record<string, string> = (() => {
+ const byName = new Map<string, Set<string>>();
+ for (const columns of Object.values(TABLE_BIND_TYPES)) {
+ for (const [name, bindType] of Object.entries(columns)) {
+ byName.set(name, (byName.get(name) ?? new Set()).add(bindType));
+ }
+ }
+ return Object.fromEntries(
+ [...byName]
+ .filter(([, types]) => types.size === 1)
+ .map(([name, types]) => [name, [...types][0]]),
+ );
+})();
diff --git a/packages/shared/src/server/repositories/__snapshots__/environments.golden.test.ts.snap b/packages/shared/src/server/repositories/__snapshots__/environments.golden.test.ts.snap
index 59b29e1a43..b35808ba12 100644
--- a/packages/shared/src/server/repositories/__snapshots__/environments.golden.test.ts.snap
+++ b/packages/shared/src/server/repositories/__snapshots__/environments.golden.test.ts.snap
@@ -11,7 +11,7 @@ exports[`golden: environments.getEnvironmentsForProject > writeMode=events_only
"route": "environments.getEnvironmentsForProject",
"sql": "SELECT DISTINCT environment
FROM events_core
-WHERE (project_id = {param1:String}) AND (start_time >= {param2:DateTime64(3)})",
+WHERE (project_id = {param1:String}) AND (start_time >= {param2:DateTime64(6)})",
},
{
"fn": "queryClickhouse",
diff --git a/packages/shared/src/server/repositories/__snapshots__/events.golden.test.ts.snap b/packages/shared/src/server/repositories/__snapshots__/events.golden.test.ts.snap
index 9834754530..c7786f177d 100644
--- a/packages/shared/src/server/repositories/__snapshots__/events.golden.test.ts.snap
+++ b/packages/shared/src/server/repositories/__snapshots__/events.golden.test.ts.snap
@@ -21,7 +21,7 @@ exports[`golden: events point-reads & existence family > getAgentGraphDataFromEv
mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values))['langgraph_node'] AS node,
mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values))['langgraph_step'] AS step
FROM events_core AS e
-WHERE (e.project_id = {param1:String}) AND (e.trace_id = {param2:String}) AND (e.start_time >= {param3:DateTime64(3)}) AND (e.start_time <= {param4:DateTime64(3)})",
+WHERE (e.project_id = {param1:String}) AND (e.trace_id = {param2:String}) AND (e.start_time >= {param3:DateTime64(6)}) AND (e.start_time <= {param4:DateTime64(6)})",
},
]
`;
@@ -336,7 +336,7 @@ exports[`golden: events point-reads & existence family > getObservationByIdFromE
e.tags AS tags,
e.release AS release
FROM events_core AS e
-WHERE (e.project_id = {param1:String}) AND (span_id = {param2:String}) AND (toStartOfMinute(start_time) = toStartOfMinute({param3:DateTime64(3)})) AND (start_time >= {param4:DateTime64(3)}) AND (type = {param5:String}) AND (trace_id = {param6:String})
+WHERE (e.project_id = {param1:String}) AND (span_id = {param2:String}) AND (toStartOfMinute(start_time) = toStartOfMinute({param3:DateTime64(6)})) AND (start_time >= {param4:DateTime64(6)}) AND (type = {param5:String}) AND (trace_id = {param6:String})
ORDER BY
start_time DESC,
event_ts DESC
@@ -648,7 +648,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsT
argMaxIf(evaluation_rule_id, event_ts, evaluation_rule_id != '') AS evaluation_rule_id,
any(experiment_id) AS experiment_id
FROM events_full AS e
- WHERE (e.project_id = {param1:String}) AND (trace_id IN ({param2:Array(String)})) AND (start_time >= {param3:DateTime64(3)})
+ WHERE (e.project_id = {param1:String}) AND (trace_id IN ({param2:Array(String)})) AND (start_time >= {param3:DateTime64(6)})
GROUP BY
trace_id,
project_id
@@ -870,3 +870,565 @@ LIMIT {param4:Int64}",
},
]
`;
+
+exports[`golden: events simple aggregates family > getLatestSdkVersionInfoFromEvents 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "2025-12-25 00:00:00.000",
+ "param3": "otel",
+ "param4": [
+ "langfuse-internal-ai-sdk",
+ "langfuse-internal-otel-writer",
+ "langfuse-internal-ai-features",
+ ],
+ "param5": 0,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ e.ingestion_sdk_name AS ingestion_sdk_name,
+ e.ingestion_sdk_version AS ingestion_sdk_version,
+ e.telemetry_sdk_language AS telemetry_sdk_language,
+ min(e.start_time) AS first_seen,
+ max(e.start_time) AS last_seen,
+ count() AS event_count
+FROM events_core AS e
+WHERE (e.project_id = {param1:String}) AND (e.start_time >= {param2:DateTime64(6)}) AND (toDate(e.start_time) >= toDate({param2:DateTime64(6)})) AND startsWith(e.source, {param3:String}) AND (e.ingestion_sdk_name NOT IN ({param4:Array(String)})) AND (e.is_deleted = {param5:UInt8})
+GROUP BY
+ e.ingestion_sdk_name,
+ e.ingestion_sdk_version,
+ e.telemetry_sdk_language
+ORDER BY last_seen DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationMetricsForPromptsFromEvents promptIds=empty 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "GENERATION",
+ "param3": [],
+ "param4": "input",
+ "param5": "output",
+ "param6": "total",
+ "param7": 0,
+ },
+ "route": "unknown",
+ "sql": "WITH prompt_events AS
+ (
+ SELECT
+ e.project_id AS project_id,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ e.trace_id AS trace_id,
+ e.span_id AS span_id,
+ e.start_time AS start_time,
+ e.end_time AS end_time,
+ e.usage_details AS usage_details,
+ e.cost_details AS cost_details,
+ e.is_deleted AS is_deleted
+ FROM events_core AS e
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)}))
+ ORDER BY e.event_ts DESC
+ LIMIT 1 BY
+ e.span_id,
+ e.project_id
+ )
+SELECT
+ count() AS count,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ min(e.start_time) AS first_observation,
+ max(e.start_time) AS last_observation,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param4:String}) > 0), e.usage_details)))
+ ) AS median_input_usage,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param5:String}) > 0), e.usage_details)))
+ ) AS median_output_usage,
+ medianExact(e.cost_details[{param6:String}]) AS median_total_cost,
+ medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms
+FROM prompt_events AS e
+WHERE e.is_deleted = {param7:UInt8}
+GROUP BY
+ e.prompt_id,
+ e.prompt_version
+ORDER BY e.prompt_version DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationMetricsForPromptsFromEvents time=from 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "GENERATION",
+ "param3": [
+ "golden-prompt-id",
+ "golden-prompt-id-b",
+ ],
+ "param4": 2025-12-01T00:00:00.000Z,
+ "param5": "input",
+ "param6": "output",
+ "param7": "total",
+ "param8": 0,
+ },
+ "route": "unknown",
+ "sql": "WITH prompt_events AS
+ (
+ SELECT
+ e.project_id AS project_id,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ e.trace_id AS trace_id,
+ e.span_id AS span_id,
+ e.start_time AS start_time,
+ e.end_time AS end_time,
+ e.usage_details AS usage_details,
+ e.cost_details AS cost_details,
+ e.is_deleted AS is_deleted
+ FROM events_core AS e
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(6)})
+ ORDER BY e.event_ts DESC
+ LIMIT 1 BY
+ e.span_id,
+ e.project_id
+ )
+SELECT
+ count() AS count,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ min(e.start_time) AS first_observation,
+ max(e.start_time) AS last_observation,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param5:String}) > 0), e.usage_details)))
+ ) AS median_input_usage,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param6:String}) > 0), e.usage_details)))
+ ) AS median_output_usage,
+ medianExact(e.cost_details[{param7:String}]) AS median_total_cost,
+ medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms
+FROM prompt_events AS e
+WHERE e.is_deleted = {param8:UInt8}
+GROUP BY
+ e.prompt_id,
+ e.prompt_version
+ORDER BY e.prompt_version DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationMetricsForPromptsFromEvents time=from+to 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "GENERATION",
+ "param3": [
+ "golden-prompt-id",
+ "golden-prompt-id-b",
+ ],
+ "param4": 2025-12-01T00:00:00.000Z,
+ "param5": 2026-01-02T00:00:00.000Z,
+ "param6": "input",
+ "param7": "output",
+ "param8": "total",
+ "param9": 0,
+ },
+ "route": "unknown",
+ "sql": "WITH prompt_events AS
+ (
+ SELECT
+ e.project_id AS project_id,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ e.trace_id AS trace_id,
+ e.span_id AS span_id,
+ e.start_time AS start_time,
+ e.end_time AS end_time,
+ e.usage_details AS usage_details,
+ e.cost_details AS cost_details,
+ e.is_deleted AS is_deleted
+ FROM events_core AS e
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(6)}) AND (e.start_time <= {param5:DateTime64(6)})
+ ORDER BY e.event_ts DESC
+ LIMIT 1 BY
+ e.span_id,
+ e.project_id
+ )
+SELECT
+ count() AS count,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ min(e.start_time) AS first_observation,
+ max(e.start_time) AS last_observation,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param6:String}) > 0), e.usage_details)))
+ ) AS median_input_usage,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param7:String}) > 0), e.usage_details)))
+ ) AS median_output_usage,
+ medianExact(e.cost_details[{param8:String}]) AS median_total_cost,
+ medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms
+FROM prompt_events AS e
+WHERE e.is_deleted = {param9:UInt8}
+GROUP BY
+ e.prompt_id,
+ e.prompt_version
+ORDER BY e.prompt_version DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationMetricsForPromptsFromEvents time=to 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "GENERATION",
+ "param3": [
+ "golden-prompt-id",
+ "golden-prompt-id-b",
+ ],
+ "param4": 2026-01-02T00:00:00.000Z,
+ "param5": "input",
+ "param6": "output",
+ "param7": "total",
+ "param8": 0,
+ },
+ "route": "unknown",
+ "sql": "WITH prompt_events AS
+ (
+ SELECT
+ e.project_id AS project_id,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ e.trace_id AS trace_id,
+ e.span_id AS span_id,
+ e.start_time AS start_time,
+ e.end_time AS end_time,
+ e.usage_details AS usage_details,
+ e.cost_details AS cost_details,
+ e.is_deleted AS is_deleted
+ FROM events_core AS e
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time <= {param4:DateTime64(6)})
+ ORDER BY e.event_ts DESC
+ LIMIT 1 BY
+ e.span_id,
+ e.project_id
+ )
+SELECT
+ count() AS count,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ min(e.start_time) AS first_observation,
+ max(e.start_time) AS last_observation,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param5:String}) > 0), e.usage_details)))
+ ) AS median_input_usage,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param6:String}) > 0), e.usage_details)))
+ ) AS median_output_usage,
+ medianExact(e.cost_details[{param7:String}]) AS median_total_cost,
+ medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms
+FROM prompt_events AS e
+WHERE e.is_deleted = {param8:UInt8}
+GROUP BY
+ e.prompt_id,
+ e.prompt_version
+ORDER BY e.prompt_version DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationMetricsForPromptsFromEvents time=unset 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "GENERATION",
+ "param3": [
+ "golden-prompt-id",
+ "golden-prompt-id-b",
+ ],
+ "param4": "input",
+ "param5": "output",
+ "param6": "total",
+ "param7": 0,
+ },
+ "route": "unknown",
+ "sql": "WITH prompt_events AS
+ (
+ SELECT
+ e.project_id AS project_id,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ e.trace_id AS trace_id,
+ e.span_id AS span_id,
+ e.start_time AS start_time,
+ e.end_time AS end_time,
+ e.usage_details AS usage_details,
+ e.cost_details AS cost_details,
+ e.is_deleted AS is_deleted
+ FROM events_core AS e
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)}))
+ ORDER BY e.event_ts DESC
+ LIMIT 1 BY
+ e.span_id,
+ e.project_id
+ )
+SELECT
+ count() AS count,
+ e.prompt_id AS prompt_id,
+ e.prompt_version AS prompt_version,
+ min(e.start_time) AS first_observation,
+ max(e.start_time) AS last_observation,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param4:String}) > 0), e.usage_details)))
+ ) AS median_input_usage,
+ medianExact(
+ arraySum(mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param5:String}) > 0), e.usage_details)))
+ ) AS median_output_usage,
+ medianExact(e.cost_details[{param6:String}]) AS median_total_cost,
+ medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms
+FROM prompt_events AS e
+WHERE e.is_deleted = {param7:UInt8}
+GROUP BY
+ e.prompt_id,
+ e.prompt_version
+ORDER BY e.prompt_version DESC",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationsWithPromptNameFromEvents promptNames=empty 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [],
+ "param3": "",
+ "param4": 0,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ uniq(span_id) AS count,
+ prompt_name
+FROM events_core
+WHERE (project_id = {param1:String}) AND (prompt_name IN ({param2:Array(String)})) AND (prompt_name != {param3:String}) AND (is_deleted = {param4:UInt8})
+GROUP BY prompt_name",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationsWithPromptNameFromEvents time=from 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-prompt",
+ "golden-prompt-b",
+ ],
+ "param3": "",
+ "param4": 0,
+ "param5": "2025-12-01 00:00:00.000",
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ uniq(span_id) AS count,
+ prompt_name
+FROM events_core
+WHERE (project_id = {param1:String}) AND (prompt_name IN ({param2:Array(String)})) AND (prompt_name != {param3:String}) AND (is_deleted = {param4:UInt8}) AND (start_time >= {param5:DateTime64(6)})
+GROUP BY prompt_name",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationsWithPromptNameFromEvents time=from+to 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-prompt",
+ "golden-prompt-b",
+ ],
+ "param3": "",
+ "param4": 0,
+ "param5": "2025-12-01 00:00:00.000",
+ "param6": "2026-01-02 00:00:00.000",
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ uniq(span_id) AS count,
+ prompt_name
+FROM events_core
+WHERE (project_id = {param1:String}) AND (prompt_name IN ({param2:Array(String)})) AND (prompt_name != {param3:String}) AND (is_deleted = {param4:UInt8}) AND (start_time >= {param5:DateTime64(6)}) AND (start_time <= {param6:DateTime64(6)})
+GROUP BY prompt_name",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationsWithPromptNameFromEvents time=to 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-prompt",
+ "golden-prompt-b",
+ ],
+ "param3": "",
+ "param4": 0,
+ "param5": "2026-01-02 00:00:00.000",
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ uniq(span_id) AS count,
+ prompt_name
+FROM events_core
+WHERE (project_id = {param1:String}) AND (prompt_name IN ({param2:Array(String)})) AND (prompt_name != {param3:String}) AND (is_deleted = {param4:UInt8}) AND (start_time <= {param5:DateTime64(6)})
+GROUP BY prompt_name",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getObservationsWithPromptNameFromEvents time=unset 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-prompt",
+ "golden-prompt-b",
+ ],
+ "param3": "",
+ "param4": 0,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ uniq(span_id) AS count,
+ prompt_name
+FROM events_core
+WHERE (project_id = {param1:String}) AND (prompt_name IN ({param2:Array(String)})) AND (prompt_name != {param3:String}) AND (is_deleted = {param4:UInt8})
+GROUP BY prompt_name",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getSessionMetricsFromEvents sessionIds=empty 1`] = `[]`;
+
+exports[`golden: events simple aggregates family > getSessionMetricsFromEvents sessionIds=set 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-session",
+ "golden-session-b",
+ ],
+ "param3": "",
+ "param4": 2,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ session_id,
+ max(start_time) AS max_timestamp,
+ min(start_time) AS min_timestamp,
+ groupUniqArray(trace_id) AS trace_ids,
+ groupUniqArrayIf(user_id, (user_id IS NOT NULL) AND (user_id != '')) AS user_ids,
+ uniq(trace_id) AS trace_count,
+ groupUniqArrayArrayIf(tags, notEmpty(tags)) AS trace_tags,
+ argMaxIf(environment, event_ts, environment != '') AS environment,
+ uniqIf(span_id, parent_span_id != '') AS total_observations,
+ dateDiff('second', min(start_time), max(if(isNull(end_time), start_time, end_time))) AS duration,
+ sumMap(usage_details) AS session_usage_details,
+ sumMap(cost_details) AS session_cost_details,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(cost_details)))
+ ) AS session_input_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(cost_details)))
+ ) AS session_output_cost,
+ sumMap(cost_details)['total'] AS session_total_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(usage_details)))
+ ) AS session_input_usage,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(usage_details)))
+ ) AS session_output_usage,
+ sumMap(usage_details)['total'] AS session_total_usage
+FROM events_core AS e
+WHERE (e.project_id = {param1:String}) AND (session_id IN ({param2:Array(String)})) AND (session_id != {param3:String})
+GROUP BY session_id
+LIMIT {param4:Int64}",
+ },
+]
+`;
+
+exports[`golden: events simple aggregates family > getSessionMetricsFromEvents sessionIds=set+queryFromTimestamp 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-session",
+ "golden-session-b",
+ ],
+ "param3": "2025-11-29 00:00:00.000",
+ "param4": "",
+ "param5": 2,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ session_id,
+ max(start_time) AS max_timestamp,
+ min(start_time) AS min_timestamp,
+ groupUniqArray(trace_id) AS trace_ids,
+ groupUniqArrayIf(user_id, (user_id IS NOT NULL) AND (user_id != '')) AS user_ids,
+ uniq(trace_id) AS trace_count,
+ groupUniqArrayArrayIf(tags, notEmpty(tags)) AS trace_tags,
+ argMaxIf(environment, event_ts, environment != '') AS environment,
+ uniqIf(span_id, parent_span_id != '') AS total_observations,
+ dateDiff('second', min(start_time), max(if(isNull(end_time), start_time, end_time))) AS duration,
+ sumMap(usage_details) AS session_usage_details,
+ sumMap(cost_details) AS session_cost_details,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(cost_details)))
+ ) AS session_input_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(cost_details)))
+ ) AS session_output_cost,
+ sumMap(cost_details)['total'] AS session_total_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(usage_details)))
+ ) AS session_input_usage,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(usage_details)))
+ ) AS session_output_usage,
+ sumMap(usage_details)['total'] AS session_total_usage
+FROM events_core AS e
+WHERE (e.project_id = {param1:String}) AND (session_id IN ({param2:Array(String)})) AND (start_time >= {param3:DateTime64(6)}) AND (session_id != {param4:String})
+GROUP BY session_id
+LIMIT {param5:Int64}",
+ },
+]
+`;
diff --git a/packages/shared/src/server/repositories/__snapshots__/experiments.golden.test.ts.snap b/packages/shared/src/server/repositories/__snapshots__/experiments.golden.test.ts.snap
new file mode 100644
index 0000000000..b1c3ddaa9d
--- /dev/null
+++ b/packages/shared/src/server/repositories/__snapshots__/experiments.golden.test.ts.snap
@@ -0,0 +1,32 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`golden: experiments simple aggregates family > getExperimentMetricsFromEvents experimentIds=empty 1`] = `[]`;
+
+exports[`golden: experiments simple aggregates family > getExperimentMetricsFromEvents experimentIds=set 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": [
+ "golden-experiment",
+ "golden-experiment-b",
+ ],
+ "param3": "",
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ e.experiment_id AS experiment_id,
+ SUM(e.total_cost) AS total_cost,
+ avgIf(
+ dateDiff('millisecond', e.start_time, e.end_time),
+ (e.span_id = e.experiment_item_root_span_id) AND (e.end_time IS NOT NULL)
+ ) AS latency_avg
+FROM events_core AS e
+WHERE (e.project_id = {param1:String}) AND (e.experiment_id IN ({param2:Array(String)})) AND (e.experiment_id != {param3:String})
+GROUP BY
+ e.project_id,
+ e.experiment_id",
+ },
+]
+`;
diff --git a/packages/shared/src/server/repositories/__snapshots__/scores.golden.test.ts.snap b/packages/shared/src/server/repositories/__snapshots__/scores.golden.test.ts.snap
index ae07dd35d8..65341de022 100644
--- a/packages/shared/src/server/repositories/__snapshots__/scores.golden.test.ts.snap
+++ b/packages/shared/src/server/repositories/__snapshots__/scores.golden.test.ts.snap
@@ -20,8 +20,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=obser
"TEXT",
],
},
- "sql": "WITH
- prompt_events AS
+ "sql": "WITH prompt_events AS
(
SELECT
e.project_id AS project_id,
@@ -30,7 +29,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=obser
e.span_id AS span_id,
e.is_deleted AS is_deleted
FROM events_core AS e
- WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(3)}) AND (e.start_time <= {param5:DateTime64(3)})
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(6)}) AND (e.start_time <= {param5:DateTime64(6)})
ORDER BY e.event_ts DESC
LIMIT 1 BY
e.span_id,
@@ -89,8 +88,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=obser
"TEXT",
],
},
- "sql": "WITH
- prompt_events AS
+ "sql": "WITH prompt_events AS
(
SELECT
e.project_id AS project_id,
@@ -159,8 +157,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=trace
"TEXT",
],
},
- "sql": "WITH
- prompt_events AS
+ "sql": "WITH prompt_events AS
(
SELECT
e.project_id AS project_id,
@@ -169,7 +166,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=trace
e.span_id AS span_id,
e.is_deleted AS is_deleted
FROM events_core AS e
- WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(3)})
+ WHERE (e.project_id = {param1:String}) AND (e.type = {param2:String}) AND (e.prompt_id IN ({param3:Array(String)})) AND (e.start_time >= {param4:DateTime64(6)})
ORDER BY e.event_ts DESC
LIMIT 1 BY
e.span_id,
@@ -226,8 +223,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=trace
"TEXT",
],
},
- "sql": "WITH
- prompt_events AS
+ "sql": "WITH prompt_events AS
(
SELECT
e.project_id AS project_id,
diff --git a/packages/shared/src/server/repositories/events.golden.test.ts b/packages/shared/src/server/repositories/events.golden.test.ts
index a6c87f99c7..50fc5ca345 100644
--- a/packages/shared/src/server/repositories/events.golden.test.ts
+++ b/packages/shared/src/server/repositories/events.golden.test.ts
@@ -1,4 +1,12 @@
-import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+ afterAll,
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vitest";
import { env } from "../../env";
import { LangfuseNotFoundError } from "../../errors";
@@ -21,8 +29,12 @@ vi.mock("./clickhouse", async (importOriginal) => {
import {
getAgentGraphDataFromEventsTable,
getLastTraceTimestampsByProjectsFromEventsTable,
+ getLatestSdkVersionInfoFromEvents,
getObservationByIdFromEventsTable,
+ getObservationMetricsForPromptsFromEvents,
getObservationsTraceIdsFromEventsTable,
+ getObservationsWithPromptNameFromEvents,
+ getSessionMetricsFromEvents,
getTraceByIdFromEventsTable,
getTraceMetadataByIdsFromEvents,
hasAnySessionFromEventsTable,
@@ -38,6 +50,10 @@ const FIXED_START_TIME = new Date("2026-01-01T00:00:00.000Z");
const FIXED_FROM_TIMESTAMP = new Date("2025-12-01T00:00:00.000Z");
const FIXED_CH_MIN = "2026-01-01 00:00:00.000";
const FIXED_CH_MAX = "2026-01-01 01:00:00.000";
+const FIXED_TO_TIMESTAMP = new Date("2026-01-02T00:00:00.000Z");
+const FIXED_PROMPT_NAMES = ["golden-prompt", "golden-prompt-b"];
+const FIXED_PROMPT_IDS = ["golden-prompt-id", "golden-prompt-id-b"];
+const FIXED_SESSION_IDS = ["golden-session", "golden-session-b"];
const describeWithClickhouse = clickhouseFormatAvailable()
? describe
@@ -216,3 +232,124 @@ describeWithClickhouse("golden: events point-reads & existence family", () => {
expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
});
});
+
+describeWithClickhouse("golden: events simple aggregates family", () => {
+ const originalWriteMode = env.LANGFUSE_MIGRATION_V4_WRITE_MODE;
+
+ beforeEach(() => {
+ resetCaptures();
+ env.LANGFUSE_MIGRATION_V4_WRITE_MODE = "events_only";
+ });
+ afterEach(() => {
+ vi.useRealTimers();
+ });
+ afterAll(() => {
+ env.LANGFUSE_MIGRATION_V4_WRITE_MODE = originalWriteMode;
+ });
+
+ it("getObservationsWithPromptNameFromEvents time=unset", async () => {
+ await getObservationsWithPromptNameFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_NAMES,
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getObservationsWithPromptNameFromEvents time=from+to", async () => {
+ await getObservationsWithPromptNameFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_NAMES,
+ { fromTimestamp: FIXED_FROM_TIMESTAMP, toTimestamp: FIXED_TO_TIMESTAMP },
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getObservationMetricsForPromptsFromEvents time=unset", async () => {
+ await getObservationMetricsForPromptsFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_IDS,
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getObservationMetricsForPromptsFromEvents time=from+to", async () => {
+ await getObservationMetricsForPromptsFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_IDS,
+ { fromTimestamp: FIXED_FROM_TIMESTAMP, toTimestamp: FIXED_TO_TIMESTAMP },
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it.each([
+ ["from", { fromTimestamp: FIXED_FROM_TIMESTAMP }],
+ ["to", { toTimestamp: FIXED_TO_TIMESTAMP }],
+ ] as const)(
+ "getObservationsWithPromptNameFromEvents time=%s",
+ async (_, timeWindow) => {
+ await getObservationsWithPromptNameFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_NAMES,
+ timeWindow,
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ },
+ );
+
+ it.each([
+ ["from", { fromTimestamp: FIXED_FROM_TIMESTAMP }],
+ ["to", { toTimestamp: FIXED_TO_TIMESTAMP }],
+ ] as const)(
+ "getObservationMetricsForPromptsFromEvents time=%s",
+ async (_, timeWindow) => {
+ await getObservationMetricsForPromptsFromEvents(
+ FIXED_PROJECT_ID,
+ FIXED_PROMPT_IDS,
+ timeWindow,
+ );
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ },
+ );
+
+ it("getObservationsWithPromptNameFromEvents promptNames=empty", async () => {
+ await getObservationsWithPromptNameFromEvents(FIXED_PROJECT_ID, []);
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getObservationMetricsForPromptsFromEvents promptIds=empty", async () => {
+ await getObservationMetricsForPromptsFromEvents(FIXED_PROJECT_ID, []);
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getSessionMetricsFromEvents sessionIds=empty", async () => {
+ await getSessionMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ sessionIds: [],
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getSessionMetricsFromEvents sessionIds=set", async () => {
+ await getSessionMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ sessionIds: FIXED_SESSION_IDS,
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getSessionMetricsFromEvents sessionIds=set+queryFromTimestamp", async () => {
+ await getSessionMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ sessionIds: FIXED_SESSION_IDS,
+ queryFromTimestamp: FIXED_FROM_TIMESTAMP,
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getLatestSdkVersionInfoFromEvents", async () => {
+ vi.useFakeTimers({ toFake: ["Date"] });
+ vi.setSystemTime(FIXED_START_TIME);
+ await getLatestSdkVersionInfoFromEvents({ projectId: FIXED_PROJECT_ID });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+});
diff --git a/packages/shared/src/server/repositories/events.ts b/packages/shared/src/server/repositories/events.ts
index 59ce450621..cf538de344 100644
--- a/packages/shared/src/server/repositories/events.ts
+++ b/packages/shared/src/server/repositories/events.ts
@@ -28,7 +28,16 @@ import {
type ExecutionContext,
} from "../query-ast/compile";
import { getClickhouseKysely } from "../query-ast/dialect";
-import { limitBy } from "../query-ast/extensions";
+import { promptGenerationEvents } from "./prompt-events";
+import {
+ count,
+ dateDiff,
+ limitBy,
+ mapValue,
+ medianExact,
+ sumMapValuesWhereKeyContains,
+ uniq,
+} from "../query-ast/extensions";
import {
convertClickhouseToDomain,
convertClickhouseTracesListToDomain,
@@ -68,10 +77,8 @@ import {
import type { EventsTableFilterState, FilterState } from "../../types";
import type { TracingSearchType } from "../../interfaces/search";
import {
- eventsSessionsAggregation,
eventsTracesAggregation,
eventsTracesScoresAggregation,
- promptEventsForMetrics,
} from "../queries/clickhouse-sql/query-fragments";
import {
eventsTableNativeUiColumnDefinitions,
@@ -118,6 +125,8 @@ import {
EventsAggQueryBuilder,
buildEventsFullTableSplitQuery,
EVENTS_AGGREGATION_FIELDS,
+ EVENTS_SESSION_AGGREGATION_FIELDS,
+ SESSION_AGGREGATION_FIELD_SETS,
eventsFieldSetSelectExpressions,
type QueryWithParams,
type SessionEventsMetricsRow,
@@ -611,37 +620,47 @@ export const getObservationMetricsForPromptsFromEvents = async (
toTimestamp,
}: { fromTimestamp?: Date; toTimestamp?: Date } = {},
) => {
- const queryBuilder = new CTEQueryBuilder()
- .withCTE(
- "prompt_events",
- promptEventsForMetrics({
- projectId,
+ const builder = getClickhouseKysely()
+ .with("prompt_events", () =>
+ promptGenerationEvents(
promptIds,
- ...(fromTimestamp
- ? { fromTimestamp: convertDateToClickhouseDateTime(fromTimestamp) }
- : {}),
- ...(toTimestamp
- ? { toTimestamp: convertDateToClickhouseDateTime(toTimestamp) }
- : {}),
- }),
- )
- .from("prompt_events", "e")
- .select(
- "count(*) AS count",
- "e.prompt_id AS prompt_id",
- "e.prompt_version AS prompt_version",
- "min(e.start_time) AS first_observation",
- "max(e.start_time) AS last_observation",
- "medianExact(arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'input') > 0, e.usage_details)))) AS median_input_usage",
- "medianExact(arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'output') > 0, e.usage_details)))) AS median_output_usage",
- "medianExact(e.cost_details['total']) AS median_total_cost",
- "medianExact(dateDiff('millisecond', e.start_time, e.end_time)) AS median_latency_ms",
+ [
+ "e.project_id as project_id",
+ "e.prompt_id as prompt_id",
+ "e.prompt_version as prompt_version",
+ "e.trace_id as trace_id",
+ "e.span_id as span_id",
+ "e.start_time as start_time",
+ "e.end_time as end_time",
+ "e.usage_details as usage_details",
+ "e.cost_details as cost_details",
+ "e.is_deleted as is_deleted",
+ ],
+ { fromTimestamp, toTimestamp },
+ ),
)
- .whereRaw("e.is_deleted = 0")
- .groupBy("e.prompt_id", "e.prompt_version")
- .orderBy("ORDER BY e.prompt_version DESC");
-
- const { query, params } = queryBuilder.buildWithParams();
+ .selectFrom("prompt_events as e")
+ .select((eb) => [
+ count().as("count"),
+ "e.prompt_id as prompt_id",
+ "e.prompt_version as prompt_version",
+ eb.fn.min("e.start_time").as("first_observation"),
+ eb.fn.max("e.start_time").as("last_observation"),
+ medianExact(sumMapValuesWhereKeyContains("e.usage_details", "input")).as(
+ "median_input_usage",
+ ),
+ medianExact(sumMapValuesWhereKeyContains("e.usage_details", "output")).as(
+ "median_output_usage",
+ ),
+ medianExact(mapValue("e.cost_details", "total")).as("median_total_cost"),
+ medianExact(dateDiff("millisecond", "e.start_time", "e.end_time")).as(
+ "median_latency_ms",
+ ),
+ ])
+ .where("e.is_deleted", "=", 0)
+ .groupBy(["e.prompt_id", "e.prompt_version"])
+ .orderBy("e.prompt_version", "desc");
+ const { sql: query, params } = compileClickhouseQuery(builder, { projectId });
const rows = await queryClickhouse<{
count: string;
prompt_id: string;
@@ -680,29 +699,23 @@ export const getObservationsWithPromptNameFromEvents = async (
toTimestamp,
}: { fromTimestamp?: Date; toTimestamp?: Date } = {},
) => {
- const query = `
- SELECT uniq(span_id) as count, prompt_name
- FROM events_core
- WHERE project_id = {projectId: String}
- AND prompt_name IN ({promptNames: Array(String)})
- AND prompt_name != ''
- AND is_deleted = 0
- ${fromTimestamp ? "AND start_time >= {fromTimestamp: DateTime64(6)}" : ""}
- ${toTimestamp ? "AND start_time <= {toTimestamp: DateTime64(6)}" : ""}
- GROUP BY prompt_name
-`;
+ const builder = getClickhouseKysely()
+ .selectFrom("events_core")
+ .select([uniq("span_id").as("count"), "prompt_name"])
+ .where("prompt_name", "in", promptNames)
+ .where("prompt_name", "!=", "")
+ .where("is_deleted", "=", 0)
+ .$if(fromTimestamp != null, (qb) =>
+ qb.where("start_time", ">=", chDateTime(fromTimestamp!)),
+ )
+ .$if(toTimestamp != null, (qb) =>
+ qb.where("start_time", "<=", chDateTime(toTimestamp!)),
+ )
+ .groupBy("prompt_name");
+ const { sql: query, params } = compileClickhouseQuery(builder, { projectId });
const rows = await queryClickhouse<{ count: string; prompt_name: string }>({
query,
- params: {
- projectId,
- promptNames,
- fromTimestamp: fromTimestamp
- ? convertDateToClickhouseDateTime(fromTimestamp)
- : undefined,
- toTimestamp: toTimestamp
- ? convertDateToClickhouseDateTime(toTimestamp)
- : undefined,
- },
+ params,
tags: { projectId },
preferredClickhouseService: "EventsReadOnly",
});
@@ -1028,11 +1041,16 @@ export const getObservationByIdFromEventsTable = async ({
const EVENTS_METADATA_MAP_SQL =
"mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values))";
-/** ClickHouse DateTime64(3) binds stay strings; the column type is Date. */
+/** ClickHouse DateTime binds stay strings; the column type is Date. */
function dateTimeParam(value: string): Date {
return value as unknown as Date;
}
+/** `date` as a ClickHouse DateTime string bind. */
+function chDateTime(date: Date): Date {
+ return dateTimeParam(convertDateToClickhouseDateTime(date));
+}
+
async function getObservationByIdFromEventsTableInternal({
id,
projectId,
@@ -1259,7 +1277,7 @@ export const getTraceByIdFromEventsTable = async ({
return res.shift();
};
-function traceAggregationSelects() {
+export function traceAggregationSelects() {
return Object.values(EVENTS_AGGREGATION_FIELDS).map((field) =>
sql.raw(field),
);
@@ -3857,20 +3875,31 @@ export const getSessionMetricsFromEvents = async (props: {
}) => {
if (props.sessionIds.length === 0) return [];
- const builder = eventsSessionsAggregation({
- projectId: props.projectId,
- sessionIds: props.sessionIds,
- startTimeFrom: props.queryFromTimestamp
- ? convertDateToClickhouseDateTime(props.queryFromTimestamp)
- : undefined,
- }).limit(props.sessionIds.length);
-
- const { query, params } = builder.buildWithParams();
+ const { projectId, sessionIds, queryFromTimestamp } = props;
+ const builder = getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select(
+ SESSION_AGGREGATION_FIELD_SETS.base.map((field) =>
+ sql.raw(EVENTS_SESSION_AGGREGATION_FIELDS[field]),
+ ) as never,
+ )
+ .where("session_id", "in", sessionIds)
+ .$if(queryFromTimestamp != null, (qb) =>
+ qb.where(
+ "start_time",
+ ">=",
+ chDateTime(observationsToTraceLowerBound(queryFromTimestamp!)),
+ ),
+ )
+ .where("session_id", "!=", "")
+ .groupBy("session_id")
+ .limit(sessionIds.length);
+ const { sql: query, params } = compileClickhouseQuery(builder, { projectId });
const rows = await queryClickhouse<SessionEventsMetricsRow>({
query,
params,
- tags: { projectId: props.projectId },
+ tags: { projectId },
preferredClickhouseService: "EventsReadOnly",
});
@@ -3910,8 +3939,38 @@ export async function getLatestSdkVersionInfoFromEvents(params: {
}): Promise<SdkMetadata> {
const { projectId } = params;
- // Time filter: last 7 days
const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+ const since = chDateTime(sevenDaysAgo);
+ const builder = getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select((eb) => [
+ "e.ingestion_sdk_name as ingestion_sdk_name",
+ "e.ingestion_sdk_version as ingestion_sdk_version",
+ "e.telemetry_sdk_language as telemetry_sdk_language",
+ eb.fn.min("e.start_time").as("first_seen"),
+ eb.fn.max("e.start_time").as("last_seen"),
+ count().as("event_count"),
+ ])
+ .where("e.start_time", ">=", since)
+ .where((eb) =>
+ eb(
+ eb.fn("toDate", ["e.start_time"]),
+ ">=",
+ eb.fn("toDate", [eb.val(since)]),
+ ),
+ )
+ .where((eb) => eb.fn<SqlBool>("startsWith", ["e.source", eb.val("otel")]))
+ .where("e.ingestion_sdk_name", "not in", [...INTERNAL_INGESTION_SDK_NAMES])
+ .where("e.is_deleted", "=", 0)
+ .groupBy([
+ "e.ingestion_sdk_name",
+ "e.ingestion_sdk_version",
+ "e.telemetry_sdk_language",
+ ])
+ .orderBy("last_seen", "desc");
+ const { sql: query, params: queryParams } = compileClickhouseQuery(builder, {
+ projectId,
+ });
const result = await queryClickhouse<{
ingestion_sdk_name: string;
ingestion_sdk_version: string;
@@ -3920,33 +3979,8 @@ export async function getLatestSdkVersionInfoFromEvents(params: {
last_seen: string;
event_count: string;
}>({
- query: `
-SELECT
- e.ingestion_sdk_name AS ingestion_sdk_name,
- e.ingestion_sdk_version AS ingestion_sdk_version,
- e.telemetry_sdk_language AS telemetry_sdk_language,
- min(e.start_time) AS first_seen,
- max(e.start_time) AS last_seen,
- count() AS event_count
-FROM events_core e
-WHERE
- e.project_id = {projectId: String}
- AND e.start_time >= {sevenDaysAgo: DateTime64(3)}
- AND toDate(e.start_time) >= toDate({sevenDaysAgo: DateTime64(3)})
- AND startsWith(e.source, 'otel')
- AND e.ingestion_sdk_name NOT IN {internalSdkNames: Array(String)}
- AND e.is_deleted = 0
-GROUP BY
- e.ingestion_sdk_name,
- e.ingestion_sdk_version,
- e.telemetry_sdk_language
-ORDER BY last_seen DESC
- `,
- params: {
- projectId,
- sevenDaysAgo: convertDateToClickhouseDateTime(sevenDaysAgo),
- internalSdkNames: [...INTERNAL_INGESTION_SDK_NAMES],
- },
+ query,
+ params: queryParams,
tags: { projectId },
preferredClickhouseService: "EventsReadOnly",
});
diff --git a/packages/shared/src/server/repositories/experiments.golden.test.ts b/packages/shared/src/server/repositories/experiments.golden.test.ts
new file mode 100644
index 0000000000..2be1c4d018
--- /dev/null
+++ b/packages/shared/src/server/repositories/experiments.golden.test.ts
@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+ capturedQueries,
+ clickhouseFormatAvailable,
+ normalizeCapturedQueries,
+ resetCaptures,
+} from "./goldenHarness";
+
+vi.mock("./clickhouse", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("./clickhouse")>();
+ const { buildClickhouseMock } = await import("./goldenHarness.js");
+ return buildClickhouseMock(actual);
+});
+
+// Enter through the server barrel: importing ./experiments directly hits the
+// db -> server-barrel -> events import cycle before events.ts initializes.
+import { getExperimentMetricsFromEvents } from "../index";
+
+const FIXED_PROJECT_ID = "golden-project";
+const FIXED_EXPERIMENT_IDS = ["golden-experiment", "golden-experiment-b"];
+
+const describeWithClickhouse = clickhouseFormatAvailable()
+ ? describe
+ : describe.skip;
+
+describeWithClickhouse("golden: experiments simple aggregates family", () => {
+ beforeEach(() => {
+ resetCaptures();
+ });
+
+ it("getExperimentMetricsFromEvents experimentIds=empty", async () => {
+ await getExperimentMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ experimentIds: [],
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
+ it("getExperimentMetricsFromEvents experimentIds=set", async () => {
+ await getExperimentMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ experimentIds: FIXED_EXPERIMENT_IDS,
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+});
diff --git a/packages/shared/src/server/repositories/experiments.ts b/packages/shared/src/server/repositories/experiments.ts
index 75d4a399ed..d3a4045d35 100644
--- a/packages/shared/src/server/repositories/experiments.ts
+++ b/packages/shared/src/server/repositories/experiments.ts
@@ -5,7 +5,14 @@ import { env } from "../../env";
import { type ScoreSourceType } from "../../domain";
import { type OrderByState } from "../../interfaces/orderBy";
import { type FilterState } from "../../types";
+import { sql } from "kysely";
import { convertDateToClickhouseDateTime } from "../clickhouse/client";
+import { compileClickhouseQuery } from "../query-ast/compile";
+import { getClickhouseKysely } from "../query-ast/dialect";
+import {
+ EXPERIMENTS_AGGREGATION_FIELDS,
+ EXPERIMENTS_AGGREGATION_FIELD_SETS,
+} from "../queries/clickhouse-sql/event-query-builder";
import {
FilterList,
StringOptionsFilter,
@@ -354,19 +361,24 @@ export const getExperimentMetricsFromEvents = async (props: {
return [];
}
- // Use eventsExperimentsAggregation with "metrics" field set for simplified aggregation
- const queryBuilder = eventsExperimentsAggregation({
- projectId: props.projectId,
- fieldSet: "metrics",
- experimentIds: props.experimentIds,
- });
-
- const { query, params } = queryBuilder.buildWithParams();
+ const { projectId, experimentIds } = props;
+ const builder = getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select(
+ // Same field map as the experiments table builder, so both stay in sync.
+ EXPERIMENTS_AGGREGATION_FIELD_SETS.metrics.map((field) =>
+ sql.raw(EXPERIMENTS_AGGREGATION_FIELDS[field]),
+ ) as never,
+ )
+ .where("e.experiment_id", "in", experimentIds)
+ .where("e.experiment_id", "!=", "")
+ .groupBy(["e.project_id", "e.experiment_id"]);
+ const { sql: query, params } = compileClickhouseQuery(builder, { projectId });
const res = await queryClickhouse<ExperimentMetricsReturnType>({
query,
params,
- tags: { projectId: props.projectId },
+ tags: { projectId },
preferredClickhouseService: "EventsReadOnly",
});
diff --git a/packages/shared/src/server/repositories/prompt-events.ts b/packages/shared/src/server/repositories/prompt-events.ts
new file mode 100644
index 0000000000..00c6b3119e
--- /dev/null
+++ b/packages/shared/src/server/repositories/prompt-events.ts
@@ -0,0 +1,32 @@
+import type { SelectExpression } from "kysely";
+
+import { getClickhouseKysely } from "../query-ast/dialect";
+import { limitBy } from "../query-ast/extensions";
+import type { ClickHouseDatabase } from "../query-ast/schema";
+
+type EventsAsE = ClickHouseDatabase & { e: ClickHouseDatabase["events_core"] };
+
+/**
+ * Latest version of each generation linked to one of `promptIds`, optionally
+ * within a start-time window. Callers pick the columns and use it as a CTE.
+ */
+export const promptGenerationEvents = <
+ S extends SelectExpression<EventsAsE, "e">,
+>(
+ promptIds: string[],
+ columns: readonly S[],
+ timeWindow: { fromTimestamp?: Date; toTimestamp?: Date } = {},
+) =>
+ getClickhouseKysely()
+ .selectFrom("events_core as e")
+ .select(columns)
+ .where("e.type", "=", "GENERATION")
+ .where("e.prompt_id", "in", promptIds)
+ .$if(timeWindow.fromTimestamp !== undefined, (qb) =>
+ qb.where("e.start_time", ">=", timeWindow.fromTimestamp!),
+ )
+ .$if(timeWindow.toTimestamp !== undefined, (qb) =>
+ qb.where("e.start_time", "<=", timeWindow.toTimestamp!),
+ )
+ .orderBy("e.event_ts", "desc")
+ .$call(limitBy({ count: 1, columns: ["e.span_id", "e.project_id"] }));
diff --git a/packages/shared/src/server/repositories/scores.ts b/packages/shared/src/server/repositories/scores.ts
index 9587d31e12..acad836ba3 100644
--- a/packages/shared/src/server/repositories/scores.ts
+++ b/packages/shared/src/server/repositories/scores.ts
@@ -77,6 +77,7 @@ import { compileClickhouseQuery } from "../query-ast/compile";
import { getClickhouseKysely } from "../query-ast/dialect";
import { limitBy, mapKeys, useFinal } from "../query-ast/extensions";
import { scoresTableCols } from "../../tableDefinitions/scoresTable";
+import { promptGenerationEvents } from "./prompt-events";
import {
findUiColumnMapping,
matchesUiColumnMapping,
@@ -2233,30 +2234,6 @@ export const getAggregatedScoresForPrompts = async (
}));
};
-const promptEventsForScoresQuery = (
- promptIds: string[],
- timeWindow: { fromTimestamp?: Date; toTimestamp?: Date } = {},
-) =>
- getClickhouseKysely()
- .selectFrom("events_core as e")
- .select([
- "e.project_id as project_id",
- "e.prompt_id as prompt_id",
- "e.trace_id as trace_id",
- "e.span_id as span_id",
- "e.is_deleted as is_deleted",
- ])
- .where("e.type", "=", "GENERATION")
- .where("e.prompt_id", "in", promptIds)
- .$if(timeWindow.fromTimestamp !== undefined, (qb) =>
- qb.where("e.start_time", ">=", timeWindow.fromTimestamp!),
- )
- .$if(timeWindow.toTimestamp !== undefined, (qb) =>
- qb.where("e.start_time", "<=", timeWindow.toTimestamp!),
- )
- .orderBy("e.event_ts", "desc")
- .$call(limitBy({ count: 1, columns: ["e.span_id", "e.project_id"] }));
-
const aggregatedScoresForPromptsFromEventsQuery = (
promptIds: string[],
fetchScoreRelation: "observation" | "trace",
@@ -2264,7 +2241,17 @@ const aggregatedScoresForPromptsFromEventsQuery = (
) =>
getClickhouseKysely()
.with("prompt_events", () =>
- promptEventsForScoresQuery(promptIds, timeWindow),
+ promptGenerationEvents(
+ promptIds,
+ [
+ "e.project_id as project_id",
+ "e.prompt_id as prompt_id",
+ "e.trace_id as trace_id",
+ "e.span_id as span_id",
+ "e.is_deleted as is_deleted",
+ ],
+ timeWindow,
+ ),
)
.selectFrom("scores as s")
.$call(useFinal(["scores"]))
diff --git a/packages/shared/src/server/services/__snapshots__/sessions-ui-table-events-service.golden.test.ts.snap b/packages/shared/src/server/services/__snapshots__/sessions-ui-table-events-service.golden.test.ts.snap
new file mode 100644
index 0000000000..7e1b941038
--- /dev/null
+++ b/packages/shared/src/server/services/__snapshots__/sessions-ui-table-events-service.golden.test.ts.snap
@@ -0,0 +1,73 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`golden: sessions simple aggregates family > getSessionTracesFromEvents 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "golden-project",
+ "param2": "golden-session",
+ "param3": 0,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ trace_id AS id,
+ project_id,
+ COALESCE(
+ nullIf(argMaxIf(e.trace_name, e.event_ts, e.trace_name != ''), ''),
+ nullIf(argMaxIf(e.name, e.event_ts, ((e.parent_span_id = '') OR (e.is_app_root = true)) AND (e.name != '')), '')
+ ) AS name,
+ min(start_time) AS timestamp,
+ argMaxIf(environment, event_ts, environment != '') AS environment,
+ argMaxIf(version, event_ts, version != '') AS version,
+ argMaxIf(session_id, event_ts, session_id != '') AS session_id,
+ argMaxIf(user_id, event_ts, user_id != '') AS user_id,
+ argMaxIf(input, event_ts, parent_span_id = '') AS input,
+ argMaxIf(output, event_ts, parent_span_id = '') AS output,
+ argMaxIf(
+ mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values)),
+ event_ts,
+ parent_span_id = ''
+ ) AS metadata,
+ min(created_at) AS created_at,
+ max(updated_at) AS updated_at,
+ sum(total_cost) AS total_cost,
+ if(
+ max(end_time) IS NULL,
+ NULL,
+ dateDiff('millisecond', min(start_time), greatest(max(start_time), max(end_time)))
+ ) AS latency_milliseconds,
+ groupUniqArrayIf(span_id, span_id != '') AS observation_ids,
+ length(groupUniqArrayIf(span_id, (span_id != '') AND (span_id != concat('t-', trace_id)))) AS observation_count,
+ argMaxIf(bookmarked, event_ts, parent_span_id = '') AS bookmarked,
+ max(public) AS public,
+ argMaxIf(experiment_item_id, event_ts, experiment_item_id != '') AS experiment_item_id,
+ sumMap(usage_details) AS usage_details,
+ sumMap(cost_details) AS cost_details,
+ multiIf(
+ arrayExists(x -> (x = 'ERROR'), groupArray(level)),
+ 'ERROR',
+ arrayExists(x -> (x = 'WARNING'), groupArray(level)),
+ 'WARNING',
+ arrayExists(x -> (x = 'DEFAULT'), groupArray(level)),
+ 'DEFAULT',
+ 'DEBUG'
+ ) AS aggregated_level,
+ countIf(level = 'WARNING') AS warning_count,
+ countIf(level = 'ERROR') AS error_count,
+ countIf(level = 'DEFAULT') AS default_count,
+ countIf(level = 'DEBUG') AS debug_count,
+ argMaxIf(tags, event_ts, notEmpty(tags)) AS tags,
+ argMaxIf(release, event_ts, release != '') AS release,
+ argMaxIf(evaluator_id, event_ts, evaluator_id != '') AS evaluator_id,
+ argMaxIf(evaluation_rule_id, event_ts, evaluation_rule_id != '') AS evaluation_rule_id,
+ any(experiment_id) AS experiment_id
+FROM events_full AS e
+WHERE (e.project_id = {param1:String}) AND (e.session_id = {param2:String}) AND (e.is_deleted = {param3:UInt8})
+GROUP BY
+ trace_id,
+ project_id
+ORDER BY timestamp ASC",
+ },
+]
+`;
diff --git a/packages/shared/src/server/services/sessions-ui-table-events-service.golden.test.ts b/packages/shared/src/server/services/sessions-ui-table-events-service.golden.test.ts
new file mode 100644
index 0000000000..53d7d9f28b
--- /dev/null
+++ b/packages/shared/src/server/services/sessions-ui-table-events-service.golden.test.ts
@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+ capturedQueries,
+ clickhouseFormatAvailable,
+ normalizeCapturedQueries,
+ resetCaptures,
+} from "../repositories/goldenHarness";
+
+vi.mock("../repositories/clickhouse", async (importOriginal) => {
+ const actual =
+ await importOriginal<typeof import("../repositories/clickhouse")>();
+ const { buildClickhouseMock } =
+ await import("../repositories/goldenHarness.js");
+ return buildClickhouseMock(actual);
+});
+
+// Enter through the server barrel: importing the service directly hits the
+// db -> server-barrel -> events import cycle before events.ts initializes.
+import { getSessionTracesFromEvents } from "../index";
+
+const describeWithClickhouse = clickhouseFormatAvailable()
+ ? describe
+ : describe.skip;
+
+describeWithClickhouse("golden: sessions simple aggregates family", () => {
+ beforeEach(() => {
+ resetCaptures();
+ });
+
+ it("getSessionTracesFromEvents", async () => {
+ await getSessionTracesFromEvents({
+ projectId: "golden-project",
+ sessionId: "golden-session",
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+});
diff --git a/packages/shared/src/server/services/sessions-ui-table-events-service.ts b/packages/shared/src/server/services/sessions-ui-table-events-service.ts
index 8d520ab603..23bbd815ec 100644
--- a/packages/shared/src/server/services/sessions-ui-table-events-service.ts
+++ b/packages/shared/src/server/services/sessions-ui-table-events-service.ts
@@ -1,4 +1,5 @@
import { ClickHouseClientConfigOptions } from "@clickhouse/client";
+import { sql } from "kysely";
import { InvalidRequestError } from "../../errors";
import { OrderByState } from "../../interfaces/orderBy";
import { FilterState } from "../../types";
@@ -12,12 +13,14 @@ import {
type SessionEventsMetricsRow,
} from "../queries";
import { createFilterFromFilterState } from "../queries/clickhouse-sql/factory";
+import { compileClickhouseQuery } from "../query-ast/compile";
+import { getClickhouseKysely } from "../query-ast/dialect";
import {
eventsSessionsAggregation,
eventsSessionScoresAggregation,
- eventsTracesAggregation,
} from "../queries/clickhouse-sql/query-fragments";
import { queryClickhouse } from "../repositories";
+import { traceAggregationSelects } from "../repositories/events";
import {
sessionEventsCols,
sessionEventsOrderByCols,
@@ -60,29 +63,15 @@ export const getSessionTracesFromEvents = async (props: {
projectId: string;
sessionId: string;
}) => {
- const tracesBuilder = eventsTracesAggregation({
- projectId: props.projectId,
- })
- .whereRaw("e.session_id = {sessionId: String}", {
- sessionId: props.sessionId,
- })
- .whereRaw("e.is_deleted = 0")
- .orderByColumns([{ column: "timestamp", direction: "ASC" }]);
-
- const tracesCte = tracesBuilder.buildWithParams();
-
- const query = `
- ${tracesCte.query}
- `;
-
- const input = {
- params: {
- ...tracesCte.params,
- projectId: props.projectId,
- sessionId: props.sessionId,
- },
- tags: { projectId: props.projectId },
- };
+ const { projectId, sessionId } = props;
+ const builder = getClickhouseKysely()
+ .selectFrom("events_full as e")
+ .select(traceAggregationSelects() as never)
+ .where("e.session_id", "=", sessionId)
+ .where("e.is_deleted", "=", 0)
+ .groupBy(["trace_id", "project_id"])
+ .orderBy(sql.ref("timestamp"), "asc");
+ const { sql: query, params } = compileClickhouseQuery(builder, { projectId });
const rows = await queryClickhouse<{
id: string;
@@ -94,8 +83,8 @@ export const getSessionTracesFromEvents = async (props: {
latency_milliseconds: number | string | null;
}>({
query,
- params: input.params,
- tags: input.tags,
+ params,
+ tags: { projectId },
preferredClickhouseService: "EventsReadOnly",
});