🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
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.tsindex 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 fieldsexperimentId: "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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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 environmentFROM 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 environmentFROM 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.tsindex 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.tsindex 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.snapindex 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 environmentFROM 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.snapindex 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 > getAgentGraphDataFromEvmapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values))['langgraph_node'] AS node,mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values))['langgraph_step'] AS stepFROM 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 > getObservationByIdFromEe.tags AS tags,e.release AS releaseFROM 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 BYstart_time DESC,event_ts DESC@@ -648,7 +648,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsTargMaxIf(evaluation_rule_id, event_ts, evaluation_rule_id != '') AS evaluation_rule_id,any(experiment_id) AS experiment_idFROM 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 BYtrace_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.snapnew file mode 100644index 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.snapindex 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(SELECTe.project_id AS project_id,@@ -30,7 +29,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=obsere.span_id AS span_id,e.is_deleted AS is_deletedFROM 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 DESCLIMIT 1 BYe.span_id,@@ -89,8 +88,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=obser"TEXT",],},- "sql": "WITH- prompt_events AS+ "sql": "WITH prompt_events AS(SELECTe.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(SELECTe.project_id AS project_id,@@ -169,7 +166,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=tracee.span_id AS span_id,e.is_deleted AS is_deletedFROM 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 DESCLIMIT 1 BYe.span_id,@@ -226,8 +223,7 @@ exports[`golden: scores.getAggregatedScoresForPromptsFromEvents > relation=trace"TEXT",],},- "sql": "WITH- prompt_events AS+ "sql": "WITH prompt_events AS(SELECTe.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.tsindex 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.tsindex 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 daysconst 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.snapnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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",});