Skip to content

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

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.ts
index 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.ts
index 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 BaseEventsQueryBuilder
return 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 BaseEventsQueryBuilder
protected 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.ts
index 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.ts
index 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.ts
index 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.snap
index 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.snap
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.snap
index 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.ts
index 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.ts
index 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",
);
});
});