🪢 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): render events aggregation builders from typed selects (#19086)
Niklas Semmler2e40ea9ce37c
diff --git a/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.test.ts b/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.test.tsindex 53e03f7aee..18d389c11c 100644--- a/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.test.ts+++ b/packages/shared/src/server/queries/clickhouse-sql/event-query-builder.test.ts@@ -61,10 +61,10 @@ describe("EventsAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "length(groupUniqArrayIf(span_id, span_id <> '' AND span_id <> concat('t-', trace_id))) AS observation_count",+ "length(groupUniqArrayIf(e.span_id, (e.span_id <> '' and e.span_id <> concat('t-', e.trace_id)))) as observation_count",);expect(query).toContain(- "(e.parent_span_id = '' OR e.is_app_root = true) AND e.name <> ''",+ "(e.parent_span_id = '' or e.is_app_root = true) and e.name <> ''",);});@@ -76,10 +76,10 @@ describe("EventsAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "argMaxIf(evaluator_id, event_ts, evaluator_id <> '') AS evaluator_id",+ "argMaxIf(e.evaluator_id, e.event_ts, e.evaluator_id != '') as evaluator_id",);expect(query).toContain(- "argMaxIf(evaluation_rule_id, event_ts, evaluation_rule_id <> '') AS evaluation_rule_id",+ "argMaxIf(e.evaluation_rule_id, e.event_ts, e.evaluation_rule_id != '') as evaluation_rule_id",);});});@@ -93,10 +93,10 @@ describe("EventsSessionAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "argMax(metadata_names, tuple(start_time, event_ts, span_id)) AS metadata_names",+ "argMax(e.metadata_names, tuple(e.start_time, e.event_ts, e.span_id)) as metadata_names",);expect(query).toContain(- "argMax(metadata_values, tuple(start_time, event_ts, span_id)) AS metadata_values",+ "argMax(e.metadata_values, tuple(e.start_time, e.event_ts, e.span_id)) as metadata_values",);expect(query).toContain("e.project_id = {projectId: String}");});@@ -121,7 +121,7 @@ describe("EventsSessionAggregationQueryBuilder", () => {.selectSessionFields(["session_id", "trace_count"]).buildWithParams();- expect(query).toContain("uniq(trace_id) AS trace_count");+ expect(query).toContain("uniq(e.trace_id) as trace_count");expect(query).not.toContain("trace_ids");expect(query).not.toContain("sumMap");});@@ -134,12 +134,12 @@ describe("EventsSessionAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "groupUniqArrayArray(mapKeys(tool_definitions)) AS tool_names",+ "groupUniqArrayArray(mapKeys(e.tool_definitions)) as tool_names",);expect(query).toContain(- "groupUniqArrayArray(tool_call_names) AS called_tool_names",+ "groupUniqArrayArray(e.tool_call_names) as called_tool_names",);- expect(query).toContain("sum(length(tool_calls)) AS tool_calls_count");+ expect(query).toContain("sum(length(e.tool_calls)) as tool_calls_count");});});@@ -262,7 +262,7 @@ describe("ExperimentsAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "anyIf(e.experiment_description, e.span_id = e.experiment_item_root_span_id) AS experiment_description",+ "anyIf(e.experiment_description, e.span_id = e.experiment_item_root_span_id) as experiment_description",);});});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 25e6baed7c..703aa2633a 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@@ -1,12 +1,7 @@-import { eventsTableTraceNameAggregationSql } from "../../../eventsTable";import { expressionBuilder } from "kysely";import { renderClickhouseExpression } from "../../query-ast/compile";-import {- metadataMap,- toBool,- latestNonEmpty,-} from "../../query-ast/extensions";+import { metadataMap, toBool } from "../../query-ast/extensions";import type { ClickHouseDatabase } from "../../query-ast/schema";import { OBSERVATIONS_TO_TRACE_INTERVAL } from "../../repositories/constants";import {@@ -16,6 +11,9 @@ import {type FieldSetName,} from "../../repositories/events-field-sets";import {+ EXPERIMENT_AGGREGATION_SQL,+ SESSION_AGGREGATION_SQL,+ TRACE_AGGREGATION_SQL,eventsTraceNameOrEmpty,eventsIsRootObservation,millisecondsSinceStart,@@ -40,10 +38,6 @@ const eventsMetadataMap = metadataMap(const EVENTS_METADATA_MAP_SQL = renderClickhouseExpression(eventsMetadataMap);-const TRACE_SESSION_ID_SQL = renderClickhouseExpression(- latestNonEmpty(eventsRef.ref("session_id"), eventsRef.ref("event_ts")),-);-/*** Extract the output column alias from a field expression (unquoted).* E.g. "e.span_id as id" → "id", 'e.trace_id as "trace_id"' → "trace_id"@@ -247,73 +241,12 @@ function eventsFieldSelectExpressions(fieldKeys: readonly string[]): string[] {});}-/**- * Aggregation fields for trace-level queries- * These fields use ClickHouse aggregation functions and require GROUP BY- */-export const EVENTS_AGGREGATION_FIELDS = {- // Grouping keys (must be in GROUP BY)- id: "trace_id AS id",- projectId: "project_id",-- // Aggregated fields- name: `${eventsTableTraceNameAggregationSql} AS name`,- timestamp: "min(start_time) as timestamp",- environment:- "argMaxIf(environment, event_ts, environment <> '') AS environment",- version: "argMaxIf(version, event_ts, version <> '') AS version",- session_id: `${TRACE_SESSION_ID_SQL} AS session_id`,- user_id: "argMaxIf(user_id, event_ts, user_id <> '') AS user_id",- input: "argMaxIf(input, event_ts, parent_span_id = '') AS input",- output: "argMaxIf(output, event_ts, parent_span_id = '') AS output",- // Note: events_core/events_full tables don't have input_truncated/output_truncated columns.- // Truncation is handled by the materialized view for events_core, or by leftUTF8() at query time.- metadata: `argMaxIf(${EVENTS_METADATA_MAP_SQL}, event_ts, parent_span_id = '') AS metadata`,- created_at: "min(created_at) AS created_at",- updated_at: "max(updated_at) AS updated_at",- total_cost: "sum(total_cost) AS total_cost",- latency_milliseconds:- "if(max(end_time) IS NULL, NULL, date_diff('millisecond', min(start_time), greatest(max(start_time), max(end_time)))) AS latency_milliseconds",- observation_ids:- "groupUniqArrayIf(span_id, span_id <> '') AS observation_ids",- observation_count:- "length(groupUniqArrayIf(span_id, span_id <> '' AND span_id <> concat('t-', trace_id))) AS observation_count",-- bookmarked:- "argMaxIf(bookmarked, event_ts, parent_span_id = '') AS bookmarked",- public: "max(public) AS public",- experiment_item_id:- "argMaxIf(experiment_item_id, event_ts, experiment_item_id <> '') AS experiment_item_id",-- // Observation-level aggregations for filtering support- usage_details: "sumMap(usage_details) as usage_details",- cost_details: "sumMap(cost_details) as cost_details",- aggregated_level:- "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",- warning_count: "countIf(level = 'WARNING') as warning_count",- error_count: "countIf(level = 'ERROR') as error_count",- default_count: "countIf(level = 'DEFAULT') as default_count",- debug_count: "countIf(level = 'DEBUG') as debug_count",-- tags: "argMaxIf(tags, event_ts, notEmpty(tags)) AS tags",- release: "argMaxIf(release, event_ts, release <> '') AS release",-- // Evaluator execution fields are stamped on every internal evaluation span.- evaluator_id:- "argMaxIf(evaluator_id, event_ts, evaluator_id <> '') AS evaluator_id",- evaluation_rule_id:- "argMaxIf(evaluation_rule_id, event_ts, evaluation_rule_id <> '') AS evaluation_rule_id",-- // experiment fields- experiment_id: "any(experiment_id) as experiment_id",-} as const;-/*** Field sets for aggregation queries*/const AGGREGATION_FIELD_SETS = {- all: Object.keys(EVENTS_AGGREGATION_FIELDS) as Array<- keyof typeof EVENTS_AGGREGATION_FIELDS+ all: Object.keys(TRACE_AGGREGATION_SQL) as Array<+ keyof typeof TRACE_AGGREGATION_SQL>,} as const;@@ -1066,12 +999,12 @@ type AliasedColumns<* const { query, params } = builder.buildWithParams();*/export class EventsAggregationQueryBuilder extends BaseEventsQueryBuilder<- typeof EVENTS_AGGREGATION_FIELDS+ typeof TRACE_AGGREGATION_SQL> {private truncated = true;constructor(options: { projectId: string }) {- super(EVENTS_AGGREGATION_FIELDS, options);+ super(TRACE_AGGREGATION_SQL, options);}/**@@ -1130,7 +1063,7 @@ export class EventsAggregationQueryBuilder extends BaseEventsQueryBuilder<protected buildSelectClause(): string {const fieldExpressions = [...this.selectFields].map((key) => {- return this.fields[key as keyof typeof EVENTS_AGGREGATION_FIELDS];+ return this.fields[key as keyof typeof TRACE_AGGREGATION_SQL];}).filter(Boolean);return `SELECT\n ${fieldExpressions.join(",\n ")}`;@@ -1187,63 +1120,25 @@ export type SessionEventsFields<F extends SessionEventsField> = readonly [...F[],];-/**- * Aggregation fields for session-level queries.- * These fields use ClickHouse aggregation functions and require GROUP BY session_id.- */-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",- trace_ids: "groupUniqArray(trace_id) AS trace_ids",- user_ids:- "groupUniqArrayIf(user_id, user_id IS NOT NULL AND user_id != '') AS user_ids",- trace_count: "uniq(trace_id) AS trace_count",- trace_tags: "groupUniqArrayArrayIf(tags, notEmpty(tags)) AS trace_tags",- tool_names: "groupUniqArrayArray(mapKeys(tool_definitions)) AS tool_names",- called_tool_names:- "groupUniqArrayArray(tool_call_names) AS called_tool_names",- tool_calls_count: "sum(length(tool_calls)) AS tool_calls_count",- environment:- "argMaxIf(environment, event_ts, environment <> '') AS environment",- metadata_names:- "argMax(metadata_names, tuple(start_time, event_ts, span_id)) AS metadata_names",- metadata_values:- "argMax(metadata_values, tuple(start_time, event_ts, span_id)) AS metadata_values",- total_observations:- "uniqIf(span_id, parent_span_id != '') AS total_observations",- duration:- "date_diff('second', min(start_time), max(if(isNull(end_time), start_time, end_time))) AS duration",- session_usage_details: "sumMap(usage_details) AS session_usage_details",- session_cost_details: "sumMap(cost_details) AS session_cost_details",- session_input_cost:- "arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'input') > 0, sumMap(cost_details)))) AS session_input_cost",- session_output_cost:- "arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'output') > 0, sumMap(cost_details)))) AS session_output_cost",- session_total_cost: "sumMap(cost_details)['total'] AS session_total_cost",- session_input_usage:- "arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'input') > 0, sumMap(usage_details)))) AS session_input_usage",- session_output_usage:- "arraySum(mapValues(mapFilter(x -> positionCaseInsensitive(x.1, 'output') > 0, sumMap(usage_details)))) AS session_output_usage",- session_total_usage: "sumMap(usage_details)['total'] AS session_total_usage",-} as const;-/*** Field sets for session aggregation queries*/export const SESSION_AGGREGATION_FIELD_SETS = {- all: Object.keys(EVENTS_SESSION_AGGREGATION_FIELDS) as Array<- keyof typeof EVENTS_SESSION_AGGREGATION_FIELDS+ all: Object.keys(SESSION_AGGREGATION_SQL) as Array<+ keyof typeof SESSION_AGGREGATION_SQL>,- base: Object.keys(EVENTS_SESSION_AGGREGATION_FIELDS).filter(+ base: Object.keys(SESSION_AGGREGATION_SQL).filter((field) =>field !== "metadata_names" &&field !== "metadata_values" &&!["tool_names", "called_tool_names", "tool_calls_count"].includes(field),- ) as Array<keyof typeof EVENTS_SESSION_AGGREGATION_FIELDS>,+ ) as Array<keyof typeof SESSION_AGGREGATION_SQL>,metadata: ["metadata_names", "metadata_values"],tools: ["tool_names", "called_tool_names", "tool_calls_count"],-} as const;+} as const satisfies Record<+ string,+ ReadonlyArray<keyof typeof SESSION_AGGREGATION_SQL>+>;/*** Every session field. Only for a CTE whose outer SELECT picks the columns;@@ -1268,12 +1163,12 @@ export const ALL_SESSION_EVENTS_FIELDS =* const { query, params } = builder.buildWithParams();*/export class EventsSessionAggregationQueryBuilder extends BaseEventsQueryBuilder<- typeof EVENTS_SESSION_AGGREGATION_FIELDS+ typeof SESSION_AGGREGATION_SQL> {private fullTable = false;constructor(options: { projectId: string }) {- super(EVENTS_SESSION_AGGREGATION_FIELDS, options);+ super(SESSION_AGGREGATION_SQL, options);}/**@@ -1301,7 +1196,9 @@ export class EventsSessionAggregationQueryBuilder extends BaseEventsQueryBuilderreturn this;}- selectSessionFields(fields: readonly SessionEventsField[]): this {+ selectSessionFields(+ fields: ReadonlyArray<keyof typeof SESSION_AGGREGATION_SQL>,+ ): this {fields.forEach((field) => this.selectFields.add(field));return this;}@@ -1360,9 +1257,7 @@ export class EventsSessionAggregationQueryBuilder extends BaseEventsQueryBuilderprotected buildSelectClause(): string {const fieldExpressions = [...this.selectFields].map((key) => {- return this.fields[- key as keyof typeof EVENTS_SESSION_AGGREGATION_FIELDS- ];+ return this.fields[key as keyof typeof SESSION_AGGREGATION_SQL];}).filter(Boolean);return `SELECT\n ${fieldExpressions.join(",\n ")}`;@@ -1728,54 +1623,39 @@ export class EventsAggQueryBuilder extends AbstractCTEQueryBuilder {// EXPERIMENTS AGGREGATION BUILDER// ============================================================-/**- * Aggregation fields for experiment-level queries.- * These fields use ClickHouse aggregation functions and require GROUP BY experiment_id, project_id.- */-export const EXPERIMENTS_AGGREGATION_FIELDS = {- // Base aggregated fields- experimentId: "e.experiment_id AS experiment_id",- experimentName: "any(e.experiment_name) AS experiment_name",- experimentDescription:- "anyIf(e.experiment_description, e.span_id = e.experiment_item_root_span_id) AS experiment_description",- experimentDatasetId:- "nullIf(any(e.experiment_dataset_id), '') AS experiment_dataset_id",- startTime: "min(e.start_time) AS start_time",- itemCount: "uniq(e.experiment_item_id) AS item_count",- // Distinct items that carry any ERROR event, so the number matches the- // items-view Status=ERROR list the badge opens.- errorCount: "uniqIf(e.experiment_item_id, e.level = 'ERROR') AS error_count",- prompts:- "groupUniqArrayIf(tuple(e.prompt_name, e.prompt_version), e.prompt_name != '') AS prompts",- experimentMetadata:- "any(mapFromArrays(e.experiment_metadata_names, e.experiment_metadata_values)) AS experiment_metadata",-} as const;-/*** Field sets for experiment aggregation queries.*/const EXPERIMENTS_AGGREGATION_FIELD_SETS = {- count: ["experimentId"] as const,+ count: ["experiment_id"] as const,base: [- "experimentId",- "experimentName",- "experimentDescription",- "experimentDatasetId",- "startTime",- "itemCount",- "errorCount",+ "experiment_id",+ "experiment_name",+ "experiment_description",+ "experiment_dataset_id",+ "start_time",+ "item_count",+ "error_count","prompts",- "experimentMetadata",+ "experiment_metadata",] as const,publicApiSummary: [- "experimentId",- "experimentName",- "experimentDescription",- "experimentDatasetId",- "startTime",+ "experiment_id",+ "experiment_name",+ "experiment_description",+ "experiment_dataset_id",+ "start_time",] as const,- publicApiSummaryMetadata: ["experimentMetadata"] as const,-} as const;+ publicApiSummaryMetadata: ["experiment_metadata"] as const,+ datasetMetrics: [+ "experiment_id",+ "experiment_dataset_id",+ "start_time",+ ] as const,+} as const satisfies Record<+ string,+ ReadonlyArray<keyof typeof EXPERIMENT_AGGREGATION_SQL>+>;export type ExperimentsAggregationFieldSetName =keyof typeof EXPERIMENTS_AGGREGATION_FIELD_SETS;@@ -1784,14 +1664,14 @@ export type ExperimentsAggregationFieldSetName =* ExperimentsAggregationQueryBuilder - Aggregates events by (experiment_id, project_id).*/export class ExperimentsAggregationQueryBuilder extends BaseEventsQueryBuilder<- typeof EXPERIMENTS_AGGREGATION_FIELDS+ typeof EXPERIMENT_AGGREGATION_SQL> {private selectedFieldSets: Set<ExperimentsAggregationFieldSetName> =new Set();private rawSelectExpressions: string[] = [];constructor(opts: { projectId: string }) {- super(EXPERIMENTS_AGGREGATION_FIELDS, { projectId: opts.projectId });+ super(EXPERIMENT_AGGREGATION_SQL, { projectId: opts.projectId });}/**@@ -1845,10 +1725,7 @@ export class ExperimentsAggregationQueryBuilder extends BaseEventsQueryBuilder<for (const setName of this.selectedFieldSets) {const fieldKeys = EXPERIMENTS_AGGREGATION_FIELD_SETS[setName];for (const key of fieldKeys) {- const fieldExpr =- EXPERIMENTS_AGGREGATION_FIELDS[- key as keyof typeof EXPERIMENTS_AGGREGATION_FIELDS- ];+ const fieldExpr = EXPERIMENT_AGGREGATION_SQL[key];if (fieldExpr) {fields.push(fieldExpr);}diff --git a/packages/shared/src/server/query-ast/compile.ts b/packages/shared/src/server/query-ast/compile.tsindex 36a1554888..de53728247 100644--- a/packages/shared/src/server/query-ast/compile.ts+++ b/packages/shared/src/server/query-ast/compile.ts@@ -1,13 +1,21 @@import {+ AliasNode,createQueryId,+ IdentifierNode,+ ReferenceNode,+ ColumnNode,type Expression,type KyselyPlugin,+ type OperationNode,type RootOperationNode,+ type SelectionNode,+ type SelectQueryBuilder,} from "kysely";import { ClickHouseQueryCompiler } from "./compiler";import { CteNamePlugin } from "./ctes";import { DedupLoweringPlugin } from "./dedup";+import { QueryCompileError } from "./errors";import { EventsTableRoutingPlugin } from "./eventsRouting";import { SoftDeleteFilterPlugin } from "./softDelete";import {@@ -76,7 +84,54 @@ export function compileClickhouseQuery(export function renderClickhouseExpression(expression: Expression<unknown>,): string {- const node = expression.toOperationNode();+ return renderNode(expression.toOperationNode());+}++/**+ * SQL text of each select of `query`, keyed by output name in select order,+ * for raw-SQL builders that share AST selects: `.select(["e.span_id as id",+ * eb.fn.min("e.start_time").as("start")])` → `{ id: "e.span_id as id",+ * start: "min(e.start_time) as start" }`. Only the select list is read; the+ * FROM just types its columns. Throws like {@link renderClickhouseExpression},+ * on a select without an output name (`*`, raw SQL), and on two selects+ * sharing one.+ */+export function renderClickhouseSelections<O>(+ query: SelectQueryBuilder<any, any, O>,+): Record<keyof O & string, string> {+ const rendered = (query.toOperationNode().selections ?? []).map(+ (selection) => [selectionName(selection), renderNode(selection)] as const,+ );+ assertDistinctOutputNames(rendered.map(([name]) => name));+ return Object.fromEntries(rendered) as Record<keyof O & string, string>;+}++function renderNode(node: OperationNode): string {assertRelationFree(node);return new ClickHouseQueryCompiler().compileExpression(node);}++function assertDistinctOutputNames(names: readonly string[]): void {+ const seen = new Set<string>();+ for (const name of names) {+ if (seen.has(name)) {+ throw new QueryCompileError(+ `Two rendered selects share the output name "${name}".`,+ );+ }+ seen.add(name);+ }+}++/** `expr as name` → `name`; an unaliased `e.col` → `col`. */+function selectionName({ selection }: SelectionNode): string {+ if (AliasNode.is(selection) && IdentifierNode.is(selection.alias)) {+ return selection.alias.name;+ }+ if (ReferenceNode.is(selection) && ColumnNode.is(selection.column)) {+ return selection.column.column.name;+ }+ throw new QueryCompileError(+ "A rendered select needs an output name: alias it, or select a column.",+ );+}diff --git a/packages/shared/src/server/query-ast/extensions.test.ts b/packages/shared/src/server/query-ast/extensions.test.tsindex 102089b8e0..7755e1800c 100644--- a/packages/shared/src/server/query-ast/extensions.test.ts+++ b/packages/shared/src/server/query-ast/extensions.test.ts@@ -1,7 +1,11 @@import { expressionBuilder, sql, type ExpressionBuilder } from "kysely";import { describe, expect, expectTypeOf, it } from "vitest";-import { compileClickhouseQuery, renderClickhouseExpression } from "./compile";+import {+ compileClickhouseQuery,+ renderClickhouseExpression,+ renderClickhouseSelections,+} from "./compile";import { getClickhouseKysely } from "./dialect";import {QueryCompileError,@@ -356,6 +360,63 @@ describe("renderClickhouseExpression", () => {});});+describe("renderClickhouseSelections", () => {+ const events = getClickhouseKysely().selectFrom("events_core as e");++ it("keys each select by its output name, in select order", () => {+ const rendered = renderClickhouseSelections(+ events.select((eb) => [+ "e.span_id as id",+ "e.trace_id",+ eb.fn.min("e.start_time").as("start"),+ ]),+ );+ expect(Object.entries(rendered)).toEqual([+ ["id", "e.span_id as id"],+ ["trace_id", "e.trace_id"],+ ["start", "min(e.start_time) as start"],+ ]);+ expectTypeOf(rendered).toEqualTypeOf<+ Record<"id" | "trace_id" | "start", string>+ >();+ });++ it("keys an output name that is also an Object prototype key", () => {+ expect(+ renderClickhouseSelections(+ events.select((eb) => eb.ref("e.trace_id").as("constructor")),+ ),+ ).toEqual({ constructor: "e.trace_id as constructor" });+ });++ it("rejects a select without an output name", () => {+ expect(() => renderClickhouseSelections(events.selectAll())).toThrow(+ QueryCompileError,+ );+ });++ it("rejects two selects with one output name", () => {+ expect(() =>+ renderClickhouseSelections(+ events.select((eb) => [+ "e.trace_id",+ eb.ref("e.span_id").as("trace_id"),+ ]),+ ),+ ).toThrow(/share the output name "trace_id"/);+ });++ it("rejects a select containing a subquery", () => {+ expect(() =>+ renderClickhouseSelections(+ events.select((eb) =>+ eb.selectFrom("events_core as x").select("x.trace_id").as("t"),+ ),+ ),+ ).toThrow(UnscopedRelationError);+ });+});+describe("64-bit results", () => {const eb = expressionBuilder<{ e: ClickHouseDatabase["events_core"] }, "e">();const isError = eb("e.level", "=", literal("ERROR"));diff --git a/packages/shared/src/server/query-ast/extensions.ts b/packages/shared/src/server/query-ast/extensions.tsindex 8ebe934e99..7001b760aa 100644--- a/packages/shared/src/server/query-ast/extensions.ts+++ b/packages/shared/src/server/query-ast/extensions.ts@@ -422,6 +422,22 @@ export function anyValue<T>(value: Expression<T>): ChExpression<T> {return aggregate("any", [value]);}+/** ClickHouse `anyIf(value, condition)`: some value among the matching rows. */+export function anyIf<T>(+ value: Expression<T>,+ condition: Expression<SqlBool>,+): ChExpression<T> {+ return aggregate("anyIf", [value, condition]);+}++/** ClickHouse `argMax(value, by)`: `value` of the row with the largest `by`. */+export function argMax<T>(+ value: Expression<T>,+ by: Expression<unknown>,+): ChExpression<T> {+ return aggregate("argMax", [value, by]);+}+/** ClickHouse `countIf(condition)`. */export function countIf(condition: Expression<SqlBool>): ChExpression<number> {return aggregate("countIf", [condition]);@@ -461,6 +477,13 @@ export function groupUniqArrayIf<T>(return aggregate("groupUniqArrayIf", [value, condition]);}+/** ClickHouse `groupUniqArrayArray(array)`: the distinct elements of all arrays. */+export function groupUniqArrayArray<T>(+ array: Expression<T[]>,+): ChExpression<T[]> {+ return aggregate("groupUniqArrayArray", [array]);+}+/** ClickHouse `groupUniqArrayArrayIf(array, condition)`. */export function groupUniqArrayArrayIf<T>(array: Expression<T[]>,@@ -530,13 +553,20 @@ export function toStartOfMinute(return functionCall("toStartOfMinute", [dateArg(value)]);}+/** ClickHouse `tuple(a, b, …)`. */+export function tuple<T extends unknown[]>(+ ...values: { [K in keyof T]: Expression<T[K]> }+): ChExpression<T> {+ return functionCall("tuple", values);+}+/** ClickHouse `arrayReverse(array)`. */function arrayReverse<T>(array: Expression<T[]>): ChExpression<T[]> {return functionCall("arrayReverse", [array]);}/** ClickHouse `mapFromArrays(keys, values)`. */-function mapFromArrays<V>(+export function mapFromArrays<V>(keys: Expression<string[]>,values: Expression<V[]>,): ChExpression<Record<string, V>> {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 eb95a468ed..02d1daae3b 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@@ -3545,3 +3545,326 @@ LIMIT {param4:Int64}",},]`;++exports[`golden: events trace aggregation family > getTracesFromEventsTableForPublicApi fields=all 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": 50,+ },+ "route": "unknown",+ "sql": "WITH+ traces AS+ (+ SELECT+ e.trace_id AS id,+ e.project_id AS 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(e.start_time) AS timestamp,+ argMaxIf(e.environment, e.event_ts, e.environment != '') AS environment,+ argMaxIf(e.version, e.event_ts, e.version != '') AS version,+ argMaxIf(e.session_id, e.event_ts, e.session_id != '') AS session_id,+ argMaxIf(e.user_id, e.event_ts, e.user_id != '') AS user_id,+ argMaxIf(e.input, e.event_ts, e.parent_span_id = '') AS input,+ argMaxIf(e.output, e.event_ts, e.parent_span_id = '') AS output,+ argMaxIf(+ mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values)),+ e.event_ts,+ e.parent_span_id = ''+ ) AS metadata,+ min(e.created_at) AS created_at,+ max(e.updated_at) AS updated_at,+ sum(e.total_cost) AS total_cost,+ if(+ max(e.end_time) IS NULL,+ NULL,+ dateDiff('millisecond', min(e.start_time), greatest(max(e.start_time), max(e.end_time)))+ ) AS latency_milliseconds,+ groupUniqArrayIf(e.span_id, e.span_id != '') AS observation_ids,+ length(+ groupUniqArrayIf(e.span_id, (e.span_id != '') AND (e.span_id != concat('t-', e.trace_id)))+ ) AS observation_count,+ argMaxIf(e.bookmarked, e.event_ts, e.parent_span_id = '') AS bookmarked,+ max(e.public) AS public,+ argMaxIf(e.experiment_item_id, e.event_ts, e.experiment_item_id != '') AS experiment_item_id,+ sumMap(e.usage_details) AS usage_details,+ sumMap(e.cost_details) AS cost_details,+ multiIf(+ arrayExists(x -> (x = 'ERROR'), groupArray(e.level)),+ 'ERROR',+ arrayExists(x -> (x = 'WARNING'), groupArray(e.level)),+ 'WARNING',+ arrayExists(x -> (x = 'DEFAULT'), groupArray(e.level)),+ 'DEFAULT',+ 'DEBUG'+ ) AS aggregated_level,+ countIf(e.level = 'WARNING') AS warning_count,+ countIf(e.level = 'ERROR') AS error_count,+ countIf(e.level = 'DEFAULT') AS default_count,+ countIf(e.level = 'DEBUG') AS debug_count,+ argMaxIf(e.tags, e.event_ts, notEmpty(e.tags)) AS tags,+ argMaxIf(e.release, e.event_ts, e.release != '') AS release,+ argMaxIf(e.evaluator_id, e.event_ts, e.evaluator_id != '') AS evaluator_id,+ argMaxIf(e.evaluation_rule_id, e.event_ts, e.evaluation_rule_id != '') AS evaluation_rule_id,+ any(e.experiment_id) AS experiment_id+ FROM events_full AS e+ WHERE e.project_id = {param1:String}+ GROUP BY+ trace_id,+ project_id+ ORDER BY timestamp DESC+ ),+ score_stats AS+ (+ SELECT+ trace_id,+ project_id,+ groupUniqArray(id) AS score_ids+ FROM scores+ WHERE (project_id = {param1:String})+ AND (observation_id IS NULL)+ GROUP BY+ trace_id,+ project_id+ )+SELECT+ t.id,+ t.project_id,+ t.timestamp,+ t.name,+ t.environment,+ t.session_id,+ t.user_id,+ t.version,+ t.created_at,+ t.updated_at,+ t.tags,+ t.bookmarked,+ t.public,+ t.release,+ CONCAT('/project/', t.project_id, '/traces/', t.id) AS htmlPath,+ t.input,+ t.output,+ t.metadata,+ s.score_ids AS scores,+ t.observation_ids AS observations,+ t.total_cost AS totalCost,+ COALESCE(t.latency_milliseconds / 1000, 0) AS latency+FROM traces AS t+LEFT JOIN score_stats AS s ON (s.trace_id = t.id) AND (s.project_id = t.project_id)+ORDER BY+ t.project_id DESC,+ t.timestamp DESC+LIMIT {param2:Int32}",+ },+]+`;++exports[`golden: events trace aggregation family > getTracesFromEventsTableForPublicApi fields=core fromTimestamp=set 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": "2025-12-01 00:00:00.000",+ "param3": "2025-12-01 00:00:00.000",+ "param4": 50,+ },+ "route": "unknown",+ "sql": "WITH traces AS+ (+ SELECT+ e.trace_id AS id,+ e.project_id AS 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(e.start_time) AS timestamp,+ argMaxIf(e.environment, e.event_ts, e.environment != '') AS environment,+ argMaxIf(e.version, e.event_ts, e.version != '') AS version,+ argMaxIf(e.session_id, e.event_ts, e.session_id != '') AS session_id,+ argMaxIf(e.user_id, e.event_ts, e.user_id != '') AS user_id,+ argMaxIf(e.input, e.event_ts, e.parent_span_id = '') AS input,+ argMaxIf(e.output, e.event_ts, e.parent_span_id = '') AS output,+ argMaxIf(+ mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values)),+ e.event_ts,+ e.parent_span_id = ''+ ) AS metadata,+ min(e.created_at) AS created_at,+ max(e.updated_at) AS updated_at,+ sum(e.total_cost) AS total_cost,+ if(+ max(e.end_time) IS NULL,+ NULL,+ dateDiff('millisecond', min(e.start_time), greatest(max(e.start_time), max(e.end_time)))+ ) AS latency_milliseconds,+ groupUniqArrayIf(e.span_id, e.span_id != '') AS observation_ids,+ length(+ groupUniqArrayIf(e.span_id, (e.span_id != '') AND (e.span_id != concat('t-', e.trace_id)))+ ) AS observation_count,+ argMaxIf(e.bookmarked, e.event_ts, e.parent_span_id = '') AS bookmarked,+ max(e.public) AS public,+ argMaxIf(e.experiment_item_id, e.event_ts, e.experiment_item_id != '') AS experiment_item_id,+ sumMap(e.usage_details) AS usage_details,+ sumMap(e.cost_details) AS cost_details,+ multiIf(+ arrayExists(x -> (x = 'ERROR'), groupArray(e.level)),+ 'ERROR',+ arrayExists(x -> (x = 'WARNING'), groupArray(e.level)),+ 'WARNING',+ arrayExists(x -> (x = 'DEFAULT'), groupArray(e.level)),+ 'DEFAULT',+ 'DEBUG'+ ) AS aggregated_level,+ countIf(e.level = 'WARNING') AS warning_count,+ countIf(e.level = 'ERROR') AS error_count,+ countIf(e.level = 'DEFAULT') AS default_count,+ countIf(e.level = 'DEBUG') AS debug_count,+ argMaxIf(e.tags, e.event_ts, notEmpty(e.tags)) AS tags,+ argMaxIf(e.release, e.event_ts, e.release != '') AS release,+ argMaxIf(e.evaluator_id, e.event_ts, e.evaluator_id != '') AS evaluator_id,+ argMaxIf(e.evaluation_rule_id, e.event_ts, e.evaluation_rule_id != '') AS evaluation_rule_id,+ any(e.experiment_id) AS experiment_id+ FROM events_core AS e+ WHERE (e.project_id = {param1:String})+ AND (start_time >= ({param2:DateTime64(3)} - toIntervalDay(2)))+ GROUP BY+ trace_id,+ project_id+ ORDER BY timestamp DESC+ )+SELECT+ t.id,+ t.project_id,+ t.timestamp,+ t.name,+ t.environment,+ t.session_id,+ t.user_id,+ t.version,+ t.created_at,+ t.updated_at,+ t.tags,+ t.bookmarked,+ t.public,+ t.release,+ CONCAT('/project/', t.project_id, '/traces/', t.id) AS htmlPath+FROM traces AS t+WHERE t.timestamp >= {param3:DateTime64(3, 'UTC')}+ORDER BY+ t.project_id DESC,+ t.timestamp DESC+LIMIT {param4:Int32}",+ },+]+`;++exports[`golden: events trace aggregation family > getTracesIdentifierForSessionFromEvents 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": "golden-session",+ },+ "route": "unknown",+ "sql": "WITH traces AS+ (+ SELECT+ e.trace_id AS id,+ e.project_id AS 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(e.start_time) AS timestamp,+ argMaxIf(e.environment, e.event_ts, e.environment != '') AS environment,+ argMaxIf(e.version, e.event_ts, e.version != '') AS version,+ argMaxIf(e.session_id, e.event_ts, e.session_id != '') AS session_id,+ argMaxIf(e.user_id, e.event_ts, e.user_id != '') AS user_id,+ argMaxIf(e.input, e.event_ts, e.parent_span_id = '') AS input,+ argMaxIf(e.output, e.event_ts, e.parent_span_id = '') AS output,+ argMaxIf(+ mapFromArrays(arrayReverse(e.metadata_names), arrayReverse(e.metadata_values)),+ e.event_ts,+ e.parent_span_id = ''+ ) AS metadata,+ min(e.created_at) AS created_at,+ max(e.updated_at) AS updated_at,+ sum(e.total_cost) AS total_cost,+ if(+ max(e.end_time) IS NULL,+ NULL,+ dateDiff('millisecond', min(e.start_time), greatest(max(e.start_time), max(e.end_time)))+ ) AS latency_milliseconds,+ groupUniqArrayIf(e.span_id, e.span_id != '') AS observation_ids,+ length(+ groupUniqArrayIf(e.span_id, (e.span_id != '') AND (e.span_id != concat('t-', e.trace_id)))+ ) AS observation_count,+ argMaxIf(e.bookmarked, e.event_ts, e.parent_span_id = '') AS bookmarked,+ max(e.public) AS public,+ argMaxIf(e.experiment_item_id, e.event_ts, e.experiment_item_id != '') AS experiment_item_id,+ sumMap(e.usage_details) AS usage_details,+ sumMap(e.cost_details) AS cost_details,+ multiIf(+ arrayExists(x -> (x = 'ERROR'), groupArray(e.level)),+ 'ERROR',+ arrayExists(x -> (x = 'WARNING'), groupArray(e.level)),+ 'WARNING',+ arrayExists(x -> (x = 'DEFAULT'), groupArray(e.level)),+ 'DEFAULT',+ 'DEBUG'+ ) AS aggregated_level,+ countIf(e.level = 'WARNING') AS warning_count,+ countIf(e.level = 'ERROR') AS error_count,+ countIf(e.level = 'DEFAULT') AS default_count,+ countIf(e.level = 'DEBUG') AS debug_count,+ argMaxIf(e.tags, e.event_ts, notEmpty(e.tags)) AS tags,+ argMaxIf(e.release, e.event_ts, e.release != '') AS release,+ argMaxIf(e.evaluator_id, e.event_ts, e.evaluator_id != '') AS evaluator_id,+ argMaxIf(e.evaluation_rule_id, e.event_ts, e.evaluation_rule_id != '') AS evaluation_rule_id,+ any(e.experiment_id) AS experiment_id+ FROM events_core AS e+ WHERE (e.project_id = {param1:String})+ AND (e.trace_id IN (+ SELECT DISTINCT trace_id+ FROM events_core+ WHERE (project_id = {param1:String})+ AND (session_id = {param2:String})+ ))+ GROUP BY+ trace_id,+ project_id+ HAVING session_id = {param2:String}+ )+SELECT+ t.id,+ t.user_id,+ t.name,+ t.timestamp,+ t.project_id,+ t.environment+FROM traces AS t+ORDER BY t.timestamp ASC+LIMIT 1 BY+ t.id,+ t.project_id",+ },+]+`;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.snapindex 0ef958a0a7..f318dddd43 100644--- a/packages/shared/src/server/repositories/__snapshots__/experiments.golden.test.ts.snap+++ b/packages/shared/src/server/repositories/__snapshots__/experiments.golden.test.ts.snap@@ -1,5 +1,39 @@// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html+exports[`golden: experiments simple aggregates family > getDatasetExperimentMetricsFromEvents 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": [+ "golden-dataset",+ ],+ },+ "route": "unknown",+ "sql": "SELECT+ experiment_dataset_id,+ count() AS count_dataset_runs,+ max(start_time) AS last_run_at+FROM+(+ SELECT+ e.experiment_id AS experiment_id,+ nullIf(any(e.experiment_dataset_id), '') AS experiment_dataset_id,+ min(e.start_time) AS start_time+ FROM events_core AS e+ WHERE (e.project_id = {param1:String})+ AND (e.experiment_id != '')+ AND (e.experiment_dataset_id IN ({param2:Array(String)}))+ GROUP BY+ e.project_id,+ e.experiment_id+) AS experiments+GROUP BY experiment_dataset_id",+ },+]+`;+exports[`golden: experiments simple aggregates family > getExperimentMetricsFromEvents experimentIds=empty 1`] = `[]`;exports[`golden: experiments simple aggregates family > getExperimentMetricsFromEvents experimentIds=set 1`] = `@@ -32,3 +66,69 @@ GROUP BY},]`;++exports[`golden: experiments simple aggregates family > getExperimentsCountFromEvents filter=experimentIds+startTime 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": [+ "golden-experiment",+ "golden-experiment-b",+ ],+ "param3": "2025-12-01 00:00:00.000",+ "param4": [+ "golden-experiment",+ "golden-experiment-b",+ ],+ "param5": "2025-12-01 00:00:00.000",+ },+ "route": "unknown",+ "sql": "SELECT count() AS count+FROM+(+ SELECT e.experiment_id AS experiment_id+ FROM events_core AS e+ WHERE (e.project_id = {param1:String})+ AND (e.experiment_id IN ({param2:Array(String)}))+ AND (e.start_time >= ({param3:DateTime64(3)} - toIntervalDay(2)))+ AND (e.experiment_id != '')+ AND ((e.experiment_id IN ({param4:Array(String)})) AND (e.start_time >= {param5:DateTime64(3, 'UTC')}))+ GROUP BY+ e.project_id,+ e.experiment_id+) AS matched_experiments",+ },+]+`;++exports[`golden: experiments simple aggregates family > getExperimentsFromEvents filter=none 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": 50,+ },+ "route": "unknown",+ "sql": "SELECT+ e.experiment_id AS experiment_id,+ any(e.experiment_name) AS experiment_name,+ anyIf(e.experiment_description, e.span_id = e.experiment_item_root_span_id) AS experiment_description,+ nullIf(any(e.experiment_dataset_id), '') AS experiment_dataset_id,+ min(e.start_time) AS start_time,+ uniq(e.experiment_item_id) AS item_count,+ uniqIf(e.experiment_item_id, e.level = 'ERROR') AS error_count,+ groupUniqArrayIf(tuple(e.prompt_name, e.prompt_version), e.prompt_name != '') AS prompts,+ any(mapFromArrays(e.experiment_metadata_names, e.experiment_metadata_values)) AS experiment_metadata+FROM events_core AS e+WHERE (e.project_id = {param1:String})+ AND (e.experiment_id != '')+GROUP BY+ e.project_id,+ e.experiment_id+LIMIT {param2:Int32}",+ },+]+`;diff --git a/packages/shared/src/server/repositories/events-selects.ts b/packages/shared/src/server/repositories/events-selects.tsindex c77547f456..a4667f4920 100644--- a/packages/shared/src/server/repositories/events-selects.ts+++ b/packages/shared/src/server/repositories/events-selects.ts@@ -1,6 +1,15 @@-import type { Expression, ExpressionBuilder, SelectExpression } from "kysely";+import type {+ Expression,+ ExpressionBuilder,+ SelectCallback,+ SelectExpression,+} from "kysely";+import { renderClickhouseSelections } from "../query-ast/compile";+import { getClickhouseKysely } from "../query-ast/dialect";import {+ anyIf,+ argMax,argMaxIf,anyValue,arrayExists,@@ -11,6 +20,7 @@ import {greatest,groupArray,groupUniqArray,+ groupUniqArrayArray,groupUniqArrayArrayIf,groupUniqArrayIf,ifElse,@@ -18,6 +28,8 @@ import {isNull,latestNonEmpty,literal,+ mapFromArrays,+ mapKeys,mapValue,metadataValue,metadataMap,@@ -27,6 +39,7 @@ import {sumMap,sumMapValuesWhereKeyContains,toBool,+ tuple,uniq,uniqIf,} from "../query-ast/extensions";@@ -61,8 +74,18 @@ export type SessionEventsMetricsRow = {export type SessionEventsField = keyof SessionEventsMetricsRow;-type EventsDb = { e: ClickHouseDatabase["events_core"] };-type EventsRow = ClickHouseDatabase["events_core"];+/** Session aggregates that only filters and sorts read, never a result row. */+type SessionFilterField =+ | "tool_names"+ | "called_tool_names"+ | "tool_calls_count"+ | "metadata_names"+ | "metadata_values";++type SessionAggregationField = SessionEventsField | SessionFilterField;++type EventsDb = { e: ClickHouseDatabase["events"] };+type EventsRow = ClickHouseDatabase["events"];type EventsColumn = keyof EventsRow & string;type StringColumn = {[K in EventsColumn]: EventsRow[K] extends string ? K : never;@@ -278,6 +301,7 @@ export const traceAggregationSelects = scopedToEvents(notEmpty(eb.ref("e.tags")),).as("tags"),latestNonEmptyOf(eb, "e.release").as("release"),+ // Evaluator execution fields are stamped on every internal evaluation span.latestNonEmptyOf(eb, "e.evaluator_id").as("evaluator_id"),latestNonEmptyOf(eb, "e.evaluation_rule_id").as("evaluation_rule_id"),anyValue(eb.ref("e.experiment_id")).as("experiment_id"),@@ -311,7 +335,23 @@ function sessionAggregationSelectMap(eb: EventsExpressionBuilder) {eb.ref("e.tags"),notEmpty(eb.ref("e.tags")),).as("trace_tags"),+ tool_names: groupUniqArrayArray(mapKeys(eb.ref("e.tool_definitions"))).as(+ "tool_names",+ ),+ called_tool_names: groupUniqArrayArray(eb.ref("e.tool_call_names")).as(+ "called_tool_names",+ ),+ tool_calls_count: eb.fn+ .sum(arrayLength(eb.ref("e.tool_calls")))+ .as("tool_calls_count"),environment: latestNonEmptyOf(eb, "e.environment").as("environment"),+ metadata_names: argMax(eb.ref("e.metadata_names"), latestSpanOrder(eb)).as(+ "metadata_names",+ ),+ metadata_values: argMax(+ eb.ref("e.metadata_values"),+ latestSpanOrder(eb),+ ).as("metadata_values"),total_observations: uniqIf(eb.ref("e.span_id"),eb("e.parent_span_id", "!=", literal("")),@@ -357,9 +397,50 @@ function sessionAggregationSelectMap(eb: EventsExpressionBuilder) {sumMap(eb.ref("e.usage_details")),literal("total"),).as("session_total_usage"),- } satisfies Record<SessionEventsField, EventsSelection>;+ } satisfies Record<SessionAggregationField, EventsSelection>;}+/** Orders a session's events by start, then write time, then span id. */+const latestSpanOrder = (eb: EventsExpressionBuilder) =>+ tuple(eb.ref("e.start_time"), eb.ref("e.event_ts"), eb.ref("e.span_id"));++/**+ * One row per experiment, aggregated from its events. Grouped by+ * `project_id, experiment_id`.+ */+const experimentAggregationSelects = scopedToEvents(+ (eb) =>+ [+ "e.experiment_id as experiment_id",+ anyValue(eb.ref("e.experiment_name")).as("experiment_name"),+ anyIf(+ eb.ref("e.experiment_description"),+ eb("e.span_id", "=", eb.ref("e.experiment_item_root_span_id")),+ ).as("experiment_description"),+ nullIf(anyValue(eb.ref("e.experiment_dataset_id")), literal("")).as(+ "experiment_dataset_id",+ ),+ eb.fn.min("e.start_time").as("start_time"),+ uniq(eb.ref("e.experiment_item_id")).as("item_count"),+ // Distinct items that carry any ERROR event, so the number matches the+ // items-view Status=ERROR list the badge opens.+ uniqIf(+ eb.ref("e.experiment_item_id"),+ eb("e.level", "=", literal("ERROR")),+ ).as("error_count"),+ groupUniqArrayIf(+ tuple(eb.ref("e.prompt_name"), eb.ref("e.prompt_version")),+ eb("e.prompt_name", "!=", literal("")),+ ).as("prompts"),+ anyValue(+ mapFromArrays(+ eb.ref("e.experiment_metadata_names"),+ eb.ref("e.experiment_metadata_values"),+ ),+ ).as("experiment_metadata"),+ ] satisfies EventsSelection[],+);+/** Milliseconds from an event's start to `end`, NULL while `end` is unset. */export const millisecondsSinceStart = scopedToEvents((@@ -489,12 +570,39 @@ export const eventsMetricsSecondsSelects = scopedToEvents(] satisfies EventsSelection[],);+/** {@link traceAggregationSelects} as SQL text, keyed by output name. */+export const TRACE_AGGREGATION_SQL = renderEventsSelects((eb) =>+ traceAggregationSelects(eb),+);++/** Every session aggregate as SQL text, keyed by field. */+export const SESSION_AGGREGATION_SQL = renderEventsSelects((eb) =>+ Object.values(sessionAggregationSelectMap(eb)),+);++/** {@link experimentAggregationSelects} as SQL text, keyed by output name. */+export const EXPERIMENT_AGGREGATION_SQL = renderEventsSelects((eb) =>+ experimentAggregationSelects(eb),+);++/**+ * SQL text of each of `selects`, keyed by output name, for the raw-SQL builders+ * that read events as `e`.+ */+function renderEventsSelects<S extends SelectCallback<EventsDb, "e">>(+ selects: S,+) {+ return renderClickhouseSelections(+ getClickhouseKysely().selectFrom("events as e").select(selects),+ );+}+/*** Makes `build` callable with the calling query's expression builder, which- * must satisfy {@link ReadsEvents}. Every export of this module goes through- * it, and so must any helper that composes them: called with the query's own- * builder, using one outside a query that reads only events as `e` is a type- * error. Never pass a query's own builder to a helper typed+ * must satisfy {@link ReadsEvents}. Every expression export of this module+ * goes through it, and so must any helper that composes them: called with the+ * query's own builder, using one outside a query that reads only events as `e`+ * is a type error. Never pass a query's own builder to a helper typed* `ExpressionBuilder<{ e: … }, "e">`: that accepts any query's builder and the* check is lost. Wrap the helper in `scopedToEvents` instead.*/diff --git a/packages/shared/src/server/repositories/events.golden.test.ts b/packages/shared/src/server/repositories/events.golden.test.tsindex aafc467c71..ac6dfa9cb6 100644--- a/packages/shared/src/server/repositories/events.golden.test.ts+++ b/packages/shared/src/server/repositories/events.golden.test.ts@@ -9,11 +9,13 @@ import {} from "vitest";import { OBSERVATION_FIELD_GROUPS_FULL } from "../../domain/observation-field-groups";+import { eventsTableTraceNameAggregationSql } from "../../eventsTable";import { env } from "../../env";import { LangfuseNotFoundError } from "../../errors";import {capturedQueries,clickhouseFormatAvailable,+ formatSql,normalizeCapturedQueries,resetCaptures,} from "./goldenHarness";@@ -46,11 +48,14 @@ import {getSessionMetricsFromEvents,getTraceByIdFromEventsTable,getTraceMetadataByIdsFromEvents,+ getTracesFromEventsTableForPublicApi,+ getTracesIdentifierForSessionFromEvents,hasAnySessionFromEventsTable,hasAnyTraceFromEventsTable,hasAnyUserFromEventsTable,streamObservationIOFieldFromEventsTable,} from "./events";+import { TRACE_AGGREGATION_SQL } from "./events-selects";import { getTraceBatchEventStream } from "./trace-batch";import { ALL_SESSION_EVENTS_FIELDS } from "../queries/clickhouse-sql/event-query-builder";@@ -534,6 +539,51 @@ describeWithClickhouse(},);+describeWithClickhouse("golden: events trace aggregation family", () => {+ beforeEach(() => {+ resetCaptures();+ });++ it("getTracesFromEventsTableForPublicApi fields=all", async () => {+ await getTracesFromEventsTableForPublicApi({+ projectId: FIXED_PROJECT_ID,+ page: 1,+ limit: 50,+ fields: ["core", "io", "scores", "observations", "metrics"],+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });++ it("getTracesFromEventsTableForPublicApi fields=core fromTimestamp=set", async () => {+ await getTracesFromEventsTableForPublicApi({+ projectId: FIXED_PROJECT_ID,+ page: 1,+ limit: 50,+ fields: ["core"],+ fromTimestamp: FIXED_FROM_TIMESTAMP.toISOString(),+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });++ it("raw trace-name aggregation SQL matches the typed trace name", () => {+ // ClickHouse function names are case-insensitive and `clickhouse format`+ // keeps their spelling, so `COALESCE` and `coalesce` compare lowercased.+ const select = (expression: string) =>+ formatSql(`SELECT ${expression} FROM events_core AS e`).toLowerCase();+ expect(select(`${eventsTableTraceNameAggregationSql} AS name`)).toBe(+ select(TRACE_AGGREGATION_SQL.name),+ );+ });++ it("getTracesIdentifierForSessionFromEvents", async () => {+ await getTracesIdentifierForSessionFromEvents(+ FIXED_PROJECT_ID,+ FIXED_SESSION_IDS[0],+ );+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });+});+describeWithClickhouse("golden: events export streams family", () => {beforeEach(() => {resetCaptures();diff --git a/packages/shared/src/server/repositories/experiments.golden.test.ts b/packages/shared/src/server/repositories/experiments.golden.test.tsindex 2be1c4d018..7b1c63f558 100644--- a/packages/shared/src/server/repositories/experiments.golden.test.ts+++ b/packages/shared/src/server/repositories/experiments.golden.test.ts@@ -15,7 +15,12 @@ vi.mock("./clickhouse", async (importOriginal) => {// Enter through the server barrel: importing ./experiments directly hits the// db -> server-barrel -> events import cycle before events.ts initializes.-import { getExperimentMetricsFromEvents } from "../index";+import {+ getDatasetExperimentMetricsFromEvents,+ getExperimentMetricsFromEvents,+ getExperimentsCountFromEvents,+ getExperimentsFromEvents,+} from "../index";const FIXED_PROJECT_ID = "golden-project";const FIXED_EXPERIMENT_IDS = ["golden-experiment", "golden-experiment-b"];@@ -44,4 +49,43 @@ describeWithClickhouse("golden: experiments simple aggregates family", () => {});expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();});++ it("getDatasetExperimentMetricsFromEvents", async () => {+ await getDatasetExperimentMetricsFromEvents({+ projectId: FIXED_PROJECT_ID,+ datasetIds: ["golden-dataset"],+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });++ it("getExperimentsFromEvents filter=none", async () => {+ await getExperimentsFromEvents({+ projectId: FIXED_PROJECT_ID,+ filter: [],+ limit: 50,+ page: 0,+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });++ it("getExperimentsCountFromEvents filter=experimentIds+startTime", async () => {+ await getExperimentsCountFromEvents({+ projectId: FIXED_PROJECT_ID,+ filter: [+ {+ type: "stringOptions",+ column: "id",+ operator: "any of",+ value: FIXED_EXPERIMENT_IDS,+ },+ {+ type: "datetime",+ column: "startTime",+ operator: ">=",+ value: new Date("2025-12-01T00:00:00.000Z"),+ },+ ],+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });});diff --git a/packages/shared/src/server/repositories/experiments.ts b/packages/shared/src/server/repositories/experiments.tsindex a5c1d6c57e..7f3c2fa66f 100644--- a/packages/shared/src/server/repositories/experiments.ts+++ b/packages/shared/src/server/repositories/experiments.ts@@ -90,12 +90,8 @@ export const getDatasetExperimentMetricsFromEvents = async (props: {const experimentsQuery = eventsExperimentsAggregation({projectId: props.projectId,- fieldSet: "count",+ fieldSet: "datasetMetrics",})- .selectRaw(- "nullIf(any(e.experiment_dataset_id), '') AS experiment_dataset_id",- "min(e.start_time) AS start_time",- ).whereRaw("e.experiment_dataset_id IN ({datasetIds: Array(String)})", {datasetIds: props.datasetIds,})diff --git a/packages/shared/src/server/repositories/scores.ts b/packages/shared/src/server/repositories/scores.tsindex 80f5b80acb..e51c80d880 100644--- a/packages/shared/src/server/repositories/scores.ts+++ b/packages/shared/src/server/repositories/scores.ts@@ -2660,8 +2660,9 @@ const buildAnalyticsScoreTraceAttributesCte = (//// Hand-written rather than eventsTracesAggregation: aggregating only// semantic-root rows keeps the GROUP BY state ~one row per trace (the-// full-span aggregation OOMed the largest tenants). Trace-name selection is-// shared with eventsTracesAggregation; the remaining field expressions keep+// full-span aggregation OOMed the largest tenants). The trace name is+// the latest non-empty trace_name, else the latest root-observation name; the+// remaining field expressions keep// the parity fixes byte-verified against prod dual-write data in the// LFE-14383 benchmark (tracked in LFE-11009).const buildAnalyticsScoreTraceAttributesFromEventsCte = (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.snapindex c9b49cf6f7..ce34f5b43a 100644--- 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@@ -74,3 +74,159 @@ ORDER BY timestamp ASC",},]`;++exports[`golden: sessions table aggregation family > getSessionsTableCountFromEvents filter=metadata+tools+sessionIds+createdAt 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param10": [+ "golden-tool",+ ],+ "param11": [+ "golden-session",+ "golden-session-b",+ ],+ "param12": "2025-12-01 00:00:00.000",+ "param2": [+ "golden-session",+ "golden-session-b",+ ],+ "param3": "2025-12-01 00:00:00.000",+ "param4": "golden-key",+ "param5": "%golden-value%",+ "param6": "golden-value",+ "param7": "golden-key",+ "param8": "%golden-value%",+ "param9": "golden-value",+ },+ "route": "unknown",+ "sql": "WITH session_data AS+ (+ SELECT+ e.session_id AS session_id,+ max(e.start_time) AS max_timestamp,+ min(e.start_time) AS min_timestamp,+ groupUniqArray(e.trace_id) AS trace_ids,+ groupUniqArrayIf(e.user_id, (e.user_id IS NOT NULL) AND (e.user_id != '')) AS user_ids,+ uniq(e.trace_id) AS trace_count,+ groupUniqArrayArrayIf(e.tags, notEmpty(e.tags)) AS trace_tags,+ argMaxIf(e.environment, e.event_ts, e.environment != '') AS environment,+ uniqIf(e.span_id, e.parent_span_id != '') AS total_observations,+ dateDiff('second', min(e.start_time), max(if(isNull(e.end_time), e.start_time, e.end_time))) AS duration,+ sumMap(e.usage_details) AS session_usage_details,+ sumMap(e.cost_details) AS session_cost_details,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(e.cost_details)))+ ) AS session_input_cost,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(e.cost_details)))+ ) AS session_output_cost,+ sumMap(e.cost_details)['total'] AS session_total_cost,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(e.usage_details)))+ ) AS session_input_usage,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(e.usage_details)))+ ) AS session_output_usage,+ sumMap(e.usage_details)['total'] AS session_total_usage,+ argMax(e.metadata_names, tuple(e.start_time, e.event_ts, e.span_id)) AS metadata_names,+ argMax(e.metadata_values, tuple(e.start_time, e.event_ts, e.span_id)) AS metadata_values,+ groupUniqArrayArray(mapKeys(e.tool_definitions)) AS tool_names,+ groupUniqArrayArray(e.tool_call_names) AS called_tool_names,+ sum(length(e.tool_calls)) AS tool_calls_count+ FROM events_full AS e+ WHERE (e.project_id = {param1:String})+ AND (session_id IN ({param2:Array(String)}))+ AND (start_time >= ({param3:DateTime64(3)} - toIntervalDay(2)))+ AND (session_id IN (+ SELECT m.session_id+ FROM events_full AS m+ WHERE (m.project_id = {param1:String})+ AND (m.start_time >= ({param3:DateTime64(3)} - toIntervalDay(2)))+ AND (m.session_id != '')+ AND (has(m.metadata_names, {param4:String}) AND like(arrayStringConcat(m.metadata_values), {param5:String}) AND (position(m.metadata_values[indexOf(m.metadata_names, {param4:String})], {param6:String}) > 0))+ ))+ AND (session_id != '')+ GROUP BY session_id+ )+SELECT count(s.session_id) AS count+FROM session_data AS s+WHERE has(s.metadata_names, {param7:String})+ AND like(arrayStringConcat(s.metadata_values), {param8:String})+ AND (position(s.metadata_values[indexOf(s.metadata_names, {param7:String})], {param9:String}) > 0)+ AND (hasAny({param10:Array(String)}, s.tool_names) = true)+ AND (session_id IN ({param11:Array(String)}))+ AND (min_timestamp >= {param12:DateTime64(3, 'UTC')})",+ },+]+`;++exports[`golden: sessions table aggregation family > getSessionsTableFromEvents filter=none 1`] = `+[+ {+ "fn": "queryClickhouse",+ "params": {+ "param1": "golden-project",+ "param2": 50,+ },+ "route": "unknown",+ "sql": "WITH session_data AS+ (+ SELECT+ e.session_id AS session_id,+ max(e.start_time) AS max_timestamp,+ min(e.start_time) AS min_timestamp,+ groupUniqArray(e.trace_id) AS trace_ids,+ groupUniqArrayIf(e.user_id, (e.user_id IS NOT NULL) AND (e.user_id != '')) AS user_ids,+ uniq(e.trace_id) AS trace_count,+ groupUniqArrayArrayIf(e.tags, notEmpty(e.tags)) AS trace_tags,+ argMaxIf(e.environment, e.event_ts, e.environment != '') AS environment,+ uniqIf(e.span_id, e.parent_span_id != '') AS total_observations,+ dateDiff('second', min(e.start_time), max(if(isNull(e.end_time), e.start_time, e.end_time))) AS duration,+ sumMap(e.usage_details) AS session_usage_details,+ sumMap(e.cost_details) AS session_cost_details,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(e.cost_details)))+ ) AS session_input_cost,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(e.cost_details)))+ ) AS session_output_cost,+ sumMap(e.cost_details)['total'] AS session_total_cost,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'input') > 0), sumMap(e.usage_details)))+ ) AS session_input_usage,+ arraySum(+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, 'output') > 0), sumMap(e.usage_details)))+ ) AS session_output_usage,+ sumMap(e.usage_details)['total'] AS session_total_usage+ FROM events_core AS e+ WHERE (e.project_id = {param1:String})+ AND (session_id != '')+ GROUP BY session_id+ )+SELECT+ s.session_id,+ s.max_timestamp,+ s.min_timestamp,+ s.trace_ids,+ s.user_ids,+ s.trace_count,+ s.trace_tags,+ s.environment,+ s.total_observations,+ s.duration,+ s.session_usage_details,+ s.session_cost_details,+ s.session_input_cost,+ s.session_output_cost,+ s.session_total_cost,+ s.session_input_usage,+ s.session_output_usage,+ s.session_total_usage+FROM session_data AS s+LIMIT {param2:Int32}",+ },+]+`;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.tsindex 53d7d9f28b..1d12ca7ef0 100644--- 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@@ -17,7 +17,12 @@ vi.mock("../repositories/clickhouse", async (importOriginal) => {// 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";+import {+ ALL_SESSION_EVENTS_FIELDS,+ getSessionTracesFromEvents,+ getSessionsTableCountFromEvents,+ getSessionsTableFromEvents,+} from "../index";const describeWithClickhouse = clickhouseFormatAvailable()? describe@@ -36,3 +41,54 @@ describeWithClickhouse("golden: sessions simple aggregates family", () => {expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();});});++describeWithClickhouse("golden: sessions table aggregation family", () => {+ beforeEach(() => {+ resetCaptures();+ });++ it("getSessionsTableFromEvents filter=none", async () => {+ await getSessionsTableFromEvents({+ projectId: "golden-project",+ filter: [],+ fields: ALL_SESSION_EVENTS_FIELDS,+ limit: 50,+ page: 0,+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });++ it("getSessionsTableCountFromEvents filter=metadata+tools+sessionIds+createdAt", async () => {+ await getSessionsTableCountFromEvents({+ projectId: "golden-project",+ filter: [+ {+ type: "stringObject",+ column: "metadata",+ key: "golden-key",+ operator: "contains",+ value: "golden-value",+ },+ {+ type: "arrayOptions",+ column: "toolNames",+ operator: "any of",+ value: ["golden-tool"],+ },+ {+ type: "stringOptions",+ column: "id",+ operator: "any of",+ value: ["golden-session", "golden-session-b"],+ },+ {+ type: "datetime",+ column: "createdAt",+ operator: ">=",+ value: new Date("2025-12-01T00:00:00.000Z"),+ },+ ],+ });+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();+ });+});diff --git a/web/src/__tests__/server/event-query-builder.servertest.ts b/web/src/__tests__/server/event-query-builder.servertest.tsindex 170aa4c002..db7b6c8984 100644--- a/web/src/__tests__/server/event-query-builder.servertest.ts+++ b/web/src/__tests__/server/event-query-builder.servertest.ts@@ -1097,7 +1097,7 @@ describe("ExperimentsAggregationQueryBuilder", () => {.buildWithParams();expect(query).toContain(- "uniqIf(e.experiment_item_id, e.level = 'ERROR') AS error_count",+ "uniqIf(e.experiment_item_id, e.level = 'ERROR') as error_count",);});});