Skip to content

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

refactor(query-ast): write events aggregation and by-id selects as typed expressions (#18829)

Niklas Semmlerb526ee2a35f6
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 a84d6dddfb..fe6432d780 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
@@ -7,11 +7,7 @@ import {
eventsTableTraceNameAggregationSql,
eventsTableTraceNameSelectSql,
} from "../../../eventsTable";
-import type {
- SkillsAvailable,
- SkillsResourceLoaded,
-} from "../../../features/skills/trace";
-import { expressionBuilder, sql, type SelectExpression } from "kysely";
+import { expressionBuilder } from "kysely";
import { renderClickhouseExpression } from "../../query-ast/compile";
import { metadataMap, traceSessionId } from "../../query-ast/extensions";
@@ -359,50 +355,6 @@ const FIELD_SETS = {
"experimentMetadata",
"experimentDescription",
],
- // getById field sets (reuse the same fields - all queries use `FROM events_<type> e`)
- byIdBase: [
- "id",
- "traceId",
- "projectId",
- "environment",
- "type",
- "parentObservationId",
- "startTime",
- "endTime",
- "name",
- "metadata",
- "level",
- "statusMessage",
- "version",
- "release",
- "userId",
- "sessionId",
- "traceName",
- "tags",
- "bookmarked",
- "public",
- "toolDefinitions",
- "toolCalls",
- "toolCallNames",
- "skillsAvailable",
- "skillsResourceLoaded",
- ],
- byIdModel: [
- "providedModelName",
- "internalModelId",
- "modelParameters",
- "providedUsageDetails",
- "usageDetails",
- "providedCostDetails",
- "costDetails",
- "totalCost",
- "usagePricingTierId",
- "usagePricingTierName",
- "completionStartTime",
- ],
- byIdPrompt: ["promptId", "promptName", "promptVersion"],
- byIdTimestamps: ["createdAt", "updatedAt", "eventTs"],
-
// Public API v2 field sets (field groups for selective fetching)
core: [
"id",
@@ -543,76 +495,6 @@ const FIELD_SETS = {
export type FieldSetName = keyof typeof FIELD_SETS;
-type EventsFieldKey = keyof typeof EVENTS_FIELDS;
-
-type EventsSelection = SelectExpression<
- { e: ClickHouseDatabase["events_core"] },
- "e"
->;
-
-/** Fields whose EVENTS_FIELDS entry is a registry column reference. */
-type EventsColumnField = {
- [K in EventsFieldKey]: (typeof EVENTS_FIELDS)[K] extends EventsSelection
- ? K
- : never;
-}[EventsFieldKey];
-
-/**
- * Query-AST selections for fields that are not plain column references,
- * built from the same source as their EVENTS_FIELDS entry.
- */
-const EVENTS_FIELD_EXPRESSIONS = {
- traceName: sql.raw<string>(eventsTableTraceNameSelectSql).as("trace_name"),
- metadata: eventsMetadataMap.as("metadata"),
- skillsAvailable: sql
- .ref<SkillsAvailable>("e.skills_available")
- .as("skills_available"),
- skillsResourceLoaded: sql
- .ref<SkillsResourceLoaded>("e.skills_resource_loaded")
- .as("skills_resource_loaded"),
-} satisfies Partial<
- Record<Exclude<EventsFieldKey, EventsColumnField>, EventsSelection>
->;
-
-type EventsExpressionField = keyof typeof EVENTS_FIELD_EXPRESSIONS;
-
-/** Field sets whose every field has a query-AST selection. */
-type SelectableFieldSetName = {
- [S in FieldSetName]: (typeof FIELD_SETS)[S][number] extends
- | EventsColumnField
- | EventsExpressionField
- ? S
- : never;
-}[FieldSetName];
-
-type EventsFieldSelection<K> = K extends EventsExpressionField
- ? (typeof EVENTS_FIELD_EXPRESSIONS)[K]
- : K extends EventsColumnField
- ? (typeof EVENTS_FIELDS)[K]
- : never;
-
-function isEventsExpressionField(key: string): key is EventsExpressionField {
- return Object.hasOwn(EVENTS_FIELD_EXPRESSIONS, key);
-}
-
-/**
- * Query-AST selections for the given field sets, in EVENTS_FIELDS declaration
- * order. Column fields are the EVENTS_FIELDS strings themselves, so Kysely
- * checks each against the table registry and infers the selected row.
- */
-export function eventsFieldSetSelections<S extends SelectableFieldSetName>(
- ...setNames: S[]
-): Array<EventsFieldSelection<(typeof FIELD_SETS)[S][number]>>;
-export function eventsFieldSetSelections(
- ...setNames: SelectableFieldSetName[]
-): EventsSelection[] {
- return orderedFieldKeys(setNames.flatMap((s) => FIELD_SETS[s])).map((key) =>
- isEventsExpressionField(key)
- ? EVENTS_FIELD_EXPRESSIONS[key]
- : EVENTS_FIELDS[key],
- );
-}
-
// Canonicalize by EVENTS_FIELDS declaration order so SELECT column order does
// not follow caller field-set order. Clustered ClickHouse reads align result
// blocks by position; incompatible Map types (cost_details vs metadata) 500
@@ -2170,17 +2052,12 @@ export const EXPERIMENTS_AGGREGATION_FIELDS = {
"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",
-
- // Metrics fields
- totalCost: "SUM(e.total_cost) AS total_cost",
- latencyAvg:
- "avgIf(date_diff('millisecond', e.start_time, e.end_time), e.span_id = e.experiment_item_root_span_id AND e.end_time IS NOT NULL) AS latency_avg",
} as const;
/**
* Field sets for experiment aggregation queries.
*/
-export const EXPERIMENTS_AGGREGATION_FIELD_SETS = {
+const EXPERIMENTS_AGGREGATION_FIELD_SETS = {
count: ["experimentId"] as const,
base: [
"experimentId",
@@ -2193,7 +2070,6 @@ export const EXPERIMENTS_AGGREGATION_FIELD_SETS = {
"prompts",
"experimentMetadata",
] as const,
- metrics: ["experimentId", "totalCost", "latencyAvg"] as const,
publicApiSummary: [
"experimentId",
"experimentName",
@@ -2209,10 +2085,6 @@ export type ExperimentsAggregationFieldSetName =
/**
* ExperimentsAggregationQueryBuilder - Aggregates events by (experiment_id, project_id).
- *
- * Use the "metrics" field set for cost and latency aggregations:
- * - Cost: SUM of all event costs for the experiment
- * - Latency: AVG of root span duration (where span_id = experiment_item_root_span_id)
*/
export class ExperimentsAggregationQueryBuilder extends BaseEventsQueryBuilder<
typeof EXPERIMENTS_AGGREGATION_FIELDS
diff --git a/packages/shared/src/server/query-ast/README.md b/packages/shared/src/server/query-ast/README.md
index a2185e07de..7ff7192d6e 100644
--- a/packages/shared/src/server/query-ast/README.md
+++ b/packages/shared/src/server/query-ast/README.md
@@ -29,8 +29,10 @@ changing how it emits SQL.
soft-delete flag columns (`SOFT_DELETE_COLUMNS`) — instead of
hand-maintained tables that drift.
- `compiler.ts` / `transformer.ts` / `dialect.ts` / `nodes.ts` — the dialect.
-- `extensions.ts` — the `$call` helpers: `arrayJoin`, `mapKeys`, `mapValues`,
- `limitBy`, `useFinal`, `includeDeleted`, `metadataValue`.
+- `extensions.ts` — the `$call` helpers (`arrayJoin`, `limitBy`, `useFinal`,
+ `includeDeleted`) and typed ClickHouse functions and aggregates (`argMaxIf`,
+ `countIf`, `sumMap`, `multiIf`, `metadataValue`, `literal`, …) that take
+ `eb.ref(...)` expressions.
- `views.ts` / `dedup.ts` / `softDelete.ts` — virtual views as CTEs, per-table
dedup lowering, and soft-delete filtering.
- `fixtures/catalog.ts` — test-only catalog of builder queries exercising the
@@ -103,6 +105,10 @@ suffix to run there. Promote it to a required check once it has proven stable.
(`toClickhouseDateTime`), so binds match stored rows whatever the server
timezone. Use `toDate` / `toStartOfMinute` from `extensions.ts` for
date-truncated comparisons.
+- **Inline code constants with `literal(...)`, bind everything else.**
+ `eb("level", "=", literal("ERROR"))` renders `level = 'ERROR'`; a value that
+ comes from a caller is a plain bind, `eb("level", "=", level)`. `literal`
+ rejects backslashes and must never receive user input.
- **ClickHouse-only clauses use `$call(helper())`** — not fluent builder
methods, so they compose inside CTEs, subqueries, and views. See the recipes
below.
@@ -168,7 +174,7 @@ preserve it:
| ARRAY JOIN | Plugin attaches `ArrayJoinNode` as an extra field on `SelectQueryNode`. `ClickHouseOperationNodeTransformer` preserves it. `ClickHouseQueryCompiler.visitSelectQuery` emits it after JOINs / before WHERE. | no |
| LIMIT BY | Plugin attaches `LimitByNode` the same way. Compiler emits it after ORDER BY / before LIMIT. | no |
| FINAL | Plugin wraps a FROM/JOIN table expression in `FinalTableNode`. Compiler emits `final` after that expression (`scores as s final`). `$call(useFinal(["scores"]))`. Tables declared `dedup: none` throw. | no |
-| metadata subscript | Helper builds an `ArrayIndexNode` over the `metadataMap` `FunctionNode`, indexed by a bound `ValueNode` key. Transformer + compiler special-case the node. No plugin. | no |
+| metadata subscript | Helper builds an `ArrayIndexNode` over the `metadataMap` `FunctionNode`, indexed by a bound `ValueNode` key. Transformer + compiler special-case the node. No plugin. | no |
| Virtual view | Plugin rewrites `selectFrom(viewName)` into a WITH CTE. Outer types only expose the view's selected columns. | no |
These are real node objects whose children are traced Kysely
diff --git a/packages/shared/src/server/query-ast/extensions.test.ts b/packages/shared/src/server/query-ast/extensions.test.ts
index 24bf8d3608..26d0252951 100644
--- a/packages/shared/src/server/query-ast/extensions.test.ts
+++ b/packages/shared/src/server/query-ast/extensions.test.ts
@@ -9,8 +9,10 @@ import {
UnscopedRelationError,
} from "./errors";
import {
+ arrayExists,
arrayMap,
leftUTF8,
+ literal,
mapValue,
metadataMap,
metadataValue,
@@ -208,6 +210,24 @@ describe("arrayMap", () => {
});
});
+describe("arrayExists", () => {
+ it("names nested lambda parameters apart so the inner one does not shadow", () => {
+ const eb = expressionBuilder<
+ { e: ClickHouseDatabase["events_core"] },
+ "e"
+ >();
+ const nested = arrayExists<string>(
+ (name) =>
+ arrayExists<string>((tag) => eb(tag, "=", name), eb.ref("e.tags")),
+ eb.ref("e.metadata_names"),
+ );
+
+ expect(renderClickhouseExpression(nested)).toBe(
+ "arrayExists(x -> arrayExists(x1 -> x1 = x, e.tags), e.metadata_names)",
+ );
+ });
+});
+
describe("renderClickhouseExpression", () => {
const eb = expressionBuilder<{ e: ClickHouseDatabase["events_core"] }, "e">();
const metadata = metadataMap(
@@ -245,3 +265,13 @@ describe("renderClickhouseExpression", () => {
);
});
});
+
+describe("literal", () => {
+ it("inlines a string with its quotes doubled", () => {
+ expect(renderClickhouseExpression(literal("it's"))).toBe("'it''s'");
+ });
+
+ it("rejects a backslash, which ClickHouse reads as an escape", () => {
+ expect(() => literal("a\\")).toThrow(QueryCompileError);
+ });
+});
diff --git a/packages/shared/src/server/query-ast/extensions.ts b/packages/shared/src/server/query-ast/extensions.ts
index 3a751de55b..917fdc87cc 100644
--- a/packages/shared/src/server/query-ast/extensions.ts
+++ b/packages/shared/src/server/query-ast/extensions.ts
@@ -171,15 +171,9 @@ export function mapValues<V = string>(column: string): Expression<V[]> {
return arrayFunction<V>("mapValues", column);
}
-/** ClickHouse `uniq(column)`, an approximate distinct count. */
-export function uniq(
- column: string,
-): ExpressionWrapper<ClickHouseDatabase, keyof ClickHouseDatabase, string> {
- return new ExpressionWrapper(
- AggregateFunctionNode.create("uniq", [
- columnRef(column),
- ]) as unknown as OperationNode,
- );
+/** ClickHouse `uniq(value)`, an approximate distinct count. */
+export function uniq(value: Expression<unknown>): ChExpression<string> {
+ return aggregate("uniq", [value]);
}
/** ClickHouse `count()`. Kysely's `eb.fn.countAll()` renders `count(*)`. */
@@ -206,12 +200,12 @@ export function medianExact(
type DateDiffUnit = "millisecond" | "second" | "minute" | "hour" | "day";
-/** ClickHouse `dateDiff(unit, start, end)` between two columns. */
+/** ClickHouse `dateDiff(unit, start, end)`. */
export function dateDiff(
unit: DateDiffUnit,
- start: string,
- end: string,
-): Expression<number> {
+ start: Expression<unknown>,
+ end: Expression<unknown>,
+): ChExpression<number> {
return new ExpressionWrapper<
ClickHouseDatabase,
keyof ClickHouseDatabase,
@@ -221,20 +215,20 @@ export function dateDiff(
// than bound. `DateDiffUnit` keeps it to known keywords.
FunctionNode.create("dateDiff", [
ValueNode.createImmediate(unit),
- columnRef(start),
- columnRef(end),
+ start.toOperationNode(),
+ end.toOperationNode(),
]) as unknown as OperationNode,
);
}
-/** `map[key]` subscript with a bound key, on a map column or expression. */
+/** `map[key]` subscript with a bound key. */
export function mapValue<V = number>(
- map: string | Expression<Record<string, V>>,
+ map: Expression<Record<string, V>>,
key: string,
): ChExpression<V> {
return new ExpressionWrapper<ClickHouseDatabase, keyof ClickHouseDatabase, V>(
ArrayIndexNode.create(
- typeof map === "string" ? columnRef(map) : map.toOperationNode(),
+ map.toOperationNode(),
ValueNode.create(key),
) as unknown as OperationNode,
);
@@ -246,9 +240,9 @@ export function mapValue<V = number>(
* The lambda is built as a `->` binary operation; Kysely has no lambda node.
*/
export function sumMapValuesWhereKeyContains(
- column: string,
+ map: Expression<Record<string, unknown>>,
needle: string,
-): Expression<number> {
+): ChExpression<number> {
const keyMatches = BinaryOperationNode.create(
FunctionNode.create("positionCaseInsensitive", [
qualifiedColumn("x", "1"),
@@ -269,7 +263,7 @@ export function sumMapValuesWhereKeyContains(
>(
FunctionNode.create("arraySum", [
FunctionNode.create("mapValues", [
- FunctionNode.create("mapFilter", [lambda, columnRef(column)]),
+ FunctionNode.create("mapFilter", [lambda, map.toOperationNode()]),
]),
]) as unknown as OperationNode,
);
@@ -290,6 +284,168 @@ function functionCall<T>(
);
}
+function aggregate<T>(
+ fn: string,
+ args: ReadonlyArray<OperationNodeSource>,
+): ChExpression<T> {
+ return new ExpressionWrapper(
+ AggregateFunctionNode.create(
+ fn,
+ args.map(toNode),
+ ) as unknown as OperationNode,
+ );
+}
+
+/**
+ * A constant inlined into the SQL text rather than bound, so code-defined
+ * constants (`level = 'ERROR'`, `span_id != ''`) render as literals. Never
+ * pass user input; bind it instead.
+ */
+export function literal<T extends string | number | boolean | null>(
+ value: T,
+): ChExpression<T> {
+ // Kysely doubles single quotes but leaves backslashes, which ClickHouse
+ // reads as escapes.
+ if (typeof value === "string" && value.includes("\\")) {
+ throw new QueryCompileError(
+ `literal does not accept backslashes, got ${value}.`,
+ );
+ }
+ return new ExpressionWrapper(
+ ValueNode.createImmediate(value) as unknown as OperationNode,
+ );
+}
+
+/** ClickHouse `if(condition, then, otherwise)`. */
+export function ifElse<A, B>(
+ condition: Expression<SqlBool>,
+ then: Expression<A>,
+ otherwise: Expression<B>,
+): ChExpression<A | B> {
+ return functionCall("if", [condition, then, otherwise]);
+}
+
+/** ClickHouse `multiIf(c1, v1, c2, v2, …, otherwise)`. */
+export function multiIf<T>(
+ branches: ReadonlyArray<readonly [Expression<SqlBool>, Expression<T>]>,
+ otherwise: Expression<T>,
+): ChExpression<T> {
+ return functionCall("multiIf", [...branches.flat(), otherwise]);
+}
+
+/** ClickHouse `nullIf(value, other)`. */
+export function nullIf<T>(
+ value: Expression<T>,
+ other: Expression<T>,
+): ChExpression<T | null> {
+ return functionCall("nullIf", [value, other]);
+}
+
+/** ClickHouse `ifNull(value, fallback)`. */
+export function ifNull<T>(
+ value: Expression<T | null>,
+ fallback: Expression<T>,
+): ChExpression<T> {
+ return functionCall("ifNull", [value, fallback]);
+}
+
+/** ClickHouse `isNull(value)`. */
+export function isNull(value: Expression<unknown>): ChExpression<SqlBool> {
+ return functionCall("isNull", [value]);
+}
+
+/** ClickHouse `greatest(a, b, …)`. */
+export function greatest<T>(...values: Expression<T>[]): ChExpression<T> {
+ return functionCall("greatest", values);
+}
+
+/** ClickHouse `concat(a, b, …)`. */
+export function concat(...values: Expression<string>[]): ChExpression<string> {
+ return functionCall("concat", values);
+}
+
+/** ClickHouse `length(array)`. */
+export function arrayLength(
+ array: Expression<unknown[]>,
+): ChExpression<string> {
+ return functionCall("length", [array]);
+}
+
+/** ClickHouse `notEmpty(array)`. */
+export function notEmpty(array: Expression<unknown[]>): ChExpression<SqlBool> {
+ return functionCall("notEmpty", [array]);
+}
+
+/**
+ * ClickHouse `arrayExists(x -> predicate, array)`. `predicate` receives the
+ * lambda parameter: `x` at the top level, `x1`, `x2`, … inside nested lambdas.
+ */
+export function arrayExists<T>(
+ predicate: (element: Expression<T>) => Expression<SqlBool>,
+ array: Expression<T[]>,
+): ChExpression<SqlBool> {
+ return functionCall("arrayExists", [lambda("x", predicate), array]);
+}
+
+/** ClickHouse `any(value)`: some value of the group. */
+export function anyValue<T>(value: Expression<T>): ChExpression<T> {
+ return aggregate("any", [value]);
+}
+
+/** ClickHouse `countIf(condition)`. */
+export function countIf(condition: Expression<SqlBool>): ChExpression<string> {
+ return aggregate("countIf", [condition]);
+}
+
+/** ClickHouse `uniqIf(value, condition)`, an approximate distinct count. */
+export function uniqIf(
+ value: Expression<unknown>,
+ condition: Expression<SqlBool>,
+): ChExpression<string> {
+ return aggregate("uniqIf", [value, condition]);
+}
+
+/** ClickHouse `avgIf(value, condition)`. */
+export function avgIf(
+ value: Expression<number>,
+ condition: Expression<SqlBool>,
+): ChExpression<number> {
+ return aggregate("avgIf", [value, condition]);
+}
+
+/** ClickHouse `groupArray(value)`. */
+export function groupArray<T>(value: Expression<T>): ChExpression<T[]> {
+ return aggregate("groupArray", [value]);
+}
+
+/** ClickHouse `groupUniqArray(value)`. */
+export function groupUniqArray<T>(value: Expression<T>): ChExpression<T[]> {
+ return aggregate("groupUniqArray", [value]);
+}
+
+/** ClickHouse `groupUniqArrayIf(value, condition)`. */
+export function groupUniqArrayIf<T>(
+ value: Expression<T>,
+ condition: Expression<SqlBool>,
+): ChExpression<T[]> {
+ return aggregate("groupUniqArrayIf", [value, condition]);
+}
+
+/** ClickHouse `groupUniqArrayArrayIf(array, condition)`. */
+export function groupUniqArrayArrayIf<T>(
+ array: Expression<T[]>,
+ condition: Expression<SqlBool>,
+): ChExpression<T[]> {
+ return aggregate("groupUniqArrayArrayIf", [array, condition]);
+}
+
+/** ClickHouse `sumMap(map)`: per-key sums over the group. */
+export function sumMap<V>(
+ map: Expression<Record<string, V>>,
+): ChExpression<Record<string, V>> {
+ return aggregate("sumMap", [map]);
+}
+
/**
* ClickHouse `leftUTF8(expression, length)`; `expression` is a column name or
* a string expression. The length is inlined as an integer literal; it must be
@@ -370,41 +526,44 @@ export function metadataMap(
return mapFromArrays(arrayReverse(names), arrayReverse(values));
}
-// Nesting depth of `arrayMap` bodies under construction. Each nesting level
+// Nesting depth of lambda bodies under construction. Each nesting level
// names its lambda parameter differently, so an inner lambda never shadows
-// an outer one. Zero outside any `arrayMap` call.
-// Module state is safe here: `body` runs synchronously inside `arrayMap`, and
+// an outer one. Zero outside any lambda.
+// Module state is safe here: `body` runs synchronously inside `lambda`, and
// JavaScript never interleaves another synchronous call with it, so concurrent
// requests cannot observe each other's depth.
-let arrayMapDepth = 0;
+let lambdaDepth = 0;
-/**
- * ClickHouse `arrayMap(v -> body, array)`. `body` receives the lambda
- * parameter: `v` at the top level, `v1`, `v2`, … inside nested calls. The
- * lambda is built as a `->` binary operation; Kysely has no lambda node.
- */
-export function arrayMap<T, U>(
+/** `p -> body(p)`, with `p` named `base` plus the nesting depth past zero. */
+function lambda<T, U>(
+ base: string,
body: (element: Expression<T>) => Expression<U>,
- array: Expression<T[]>,
-): ChExpression<U[]> {
+): OperationNode {
const param = ColumnNode.create(
- arrayMapDepth === 0 ? "v" : `v${arrayMapDepth}`,
+ lambdaDepth === 0 ? base : `${base}${lambdaDepth}`,
);
- arrayMapDepth++;
+ lambdaDepth++;
let bodyNode: OperationNode;
try {
bodyNode = body(
new ExpressionWrapper(param as unknown as OperationNode),
).toOperationNode();
} finally {
- arrayMapDepth--;
+ lambdaDepth--;
}
- const lambda = BinaryOperationNode.create(
- param,
- OperatorNode.create("->"),
- bodyNode,
- );
- return functionCall("arrayMap", [lambda, array]);
+ return BinaryOperationNode.create(param, OperatorNode.create("->"), bodyNode);
+}
+
+/**
+ * ClickHouse `arrayMap(v -> body, array)`. `body` receives the lambda
+ * parameter: `v` at the top level, `v1`, `v2`, … inside nested calls. The
+ * lambda is built as a `->` binary operation; Kysely has no lambda node.
+ */
+export function arrayMap<T, U>(
+ body: (element: Expression<T>) => Expression<U>,
+ array: Expression<T[]>,
+): ChExpression<U[]> {
+ return functionCall("arrayMap", [lambda("v", body), array]);
}
/**
@@ -436,7 +595,7 @@ function nonEmpty(expression: Expression<string>): ChExpression<SqlBool> {
}
/** ClickHouse `argMaxIf(value, by, condition)`. */
-function argMaxIf<T>(
+export function argMaxIf<T>(
value: Expression<T>,
by: Expression<unknown>,
condition: Expression<SqlBool>,
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 07bb507d38..1393724258 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
@@ -812,7 +812,7 @@ exports[`golden: events point-reads & existence family > getObservationByIdFromE
e.user_id AS user_id,
e.session_id AS session_id,
ifNull(
- COALESCE(
+ coalesce(
nullIf(e.trace_name, ''),
if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)
),
@@ -881,7 +881,7 @@ exports[`golden: events point-reads & existence family > getObservationByIdFromE
e.user_id AS user_id,
e.session_id AS session_id,
ifNull(
- COALESCE(
+ coalesce(
nullIf(e.trace_name, ''),
if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)
),
@@ -952,7 +952,7 @@ exports[`golden: events point-reads & existence family > getObservationByIdFromE
e.user_id AS user_id,
e.session_id AS session_id,
ifNull(
- COALESCE(
+ coalesce(
nullIf(e.trace_name, ''),
if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)
),
@@ -1027,7 +1027,7 @@ exports[`golden: events point-reads & existence family > getObservationByIdFromE
e.user_id AS user_id,
e.session_id AS session_id,
ifNull(
- COALESCE(
+ coalesce(
nullIf(e.trace_name, ''),
if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)
),
@@ -1108,7 +1108,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsT
SELECT
trace_id AS id,
project_id,
- COALESCE(
+ 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 != '')),
@@ -1212,7 +1212,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsT
SELECT
trace_id AS id,
project_id,
- COALESCE(
+ 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 != '')),
@@ -1318,7 +1318,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsT
SELECT
trace_id AS id,
project_id,
- COALESCE(
+ 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 != '')),
@@ -1399,7 +1399,7 @@ SELECT
t.input,
t.output
FROM traces AS t
-WHERE toDate(t.timestamp) = toDate({param4:DateTime64(3)})
+WHERE toDate(t.timestamp) = toDate({param4:DateTime64(6)})
ORDER BY t.timestamp DESC
LIMIT {param5:Int64}",
},
@@ -1423,7 +1423,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsT
SELECT
trace_id AS id,
project_id,
- COALESCE(
+ 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 != '')),
@@ -1527,14 +1527,14 @@ exports[`golden: events point-reads & existence family > getTraceMetadataByIdsFr
"route": "unknown",
"sql": "SELECT
e.trace_id AS id,
- COALESCE(
+ coalesce(
nullIf(e.trace_name, ''),
if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)
) AS name,
e.user_id AS user_id,
e.tags AS tags
FROM events_core AS e
-WHERE (e.project_id = {param1:String}) AND (e.is_deleted = {param2:UInt8}) AND (COALESCE(nullIf(e.trace_name, ''), if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)) IS NOT NULL) AND (e.trace_id IN ({param3:Array(String)}))
+WHERE (e.project_id = {param1:String}) AND (e.is_deleted = {param2:UInt8}) AND (coalesce(nullIf(e.trace_name, ''), if((e.parent_span_id = '') OR (e.is_app_root = true), nullIf(e.name, ''), NULL)) IS NOT NULL) AND (e.trace_id IN ({param3:Array(String)}))
LIMIT 1 BY e.trace_id",
},
]
@@ -2057,6 +2057,58 @@ GROUP BY prompt_name",
]
`;
+exports[`golden: events simple aggregates family > getSessionMetricsFromEvents fields=all 1`] = `
+[
+ {
+ "fn": "queryClickhouse",
+ "params": {
+ "param1": "input",
+ "param2": "output",
+ "param3": "total",
+ "param4": "golden-project",
+ "param5": [
+ "golden-session",
+ "golden-session-b",
+ ],
+ "param6": "",
+ "param7": 2,
+ },
+ "route": "unknown",
+ "sql": "SELECT
+ session_id,
+ max(start_time) AS max_timestamp,
+ min(start_time) AS min_timestamp,
+ groupUniqArray(trace_id) AS trace_ids,
+ groupUniqArrayIf(user_id, (user_id IS NOT NULL) AND (user_id != '')) AS user_ids,
+ uniq(trace_id) AS trace_count,
+ groupUniqArrayArrayIf(tags, notEmpty(tags)) AS trace_tags,
+ argMaxIf(environment, event_ts, environment != '') AS environment,
+ uniqIf(span_id, parent_span_id != '') AS total_observations,
+ dateDiff('second', min(start_time), max(if(isNull(end_time), start_time, end_time))) AS duration,
+ sumMap(usage_details) AS session_usage_details,
+ sumMap(cost_details) AS session_cost_details,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param1:String}) > 0), sumMap(cost_details)))
+ ) AS session_input_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param2:String}) > 0), sumMap(cost_details)))
+ ) AS session_output_cost,
+ sumMap(cost_details)[{param3:String}] AS session_total_cost,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param1:String}) > 0), sumMap(usage_details)))
+ ) AS session_input_usage,
+ arraySum(
+ mapValues(mapFilter(x -> (positionCaseInsensitive(x.1, {param2:String}) > 0), sumMap(usage_details)))
+ ) AS session_output_usage,
+ sumMap(usage_details)[{param3:String}] AS session_total_usage
+FROM events_core AS e
+WHERE (e.project_id = {param4:String}) AND (session_id IN ({param5:Array(String)})) AND (session_id != {param6:String})
+GROUP BY session_id
+LIMIT {param7:Int64}",
+ },
+]
+`;
+
exports[`golden: events simple aggregates family > getSessionMetricsFromEvents sessionIds=empty 1`] = `[]`;
exports[`golden: events simple aggregates family > getSessionMetricsFromEvents sessionIds=set 1`] = `
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 b1c3ddaa9d..adc28c90e8 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
@@ -17,7 +17,7 @@ exports[`golden: experiments simple aggregates family > getExperimentMetricsFrom
"route": "unknown",
"sql": "SELECT
e.experiment_id AS experiment_id,
- SUM(e.total_cost) AS total_cost,
+ sum(e.total_cost) AS total_cost,
avgIf(
dateDiff('millisecond', e.start_time, e.end_time),
(e.span_id = e.experiment_item_root_span_id) AND (e.end_time IS NOT NULL)
diff --git a/packages/shared/src/server/repositories/events-selects.ts b/packages/shared/src/server/repositories/events-selects.ts
new file mode 100644
index 0000000000..ea9354a29f
--- /dev/null
+++ b/packages/shared/src/server/repositories/events-selects.ts
@@ -0,0 +1,288 @@
+import { expressionBuilder, sql, type SelectExpression } from "kysely";
+
+import type {
+ SkillsAvailable,
+ SkillsResourceLoaded,
+} from "../../features/skills/trace";
+
+import {
+ argMaxIf,
+ anyValue,
+ arrayExists,
+ arrayLength,
+ concat,
+ countIf,
+ dateDiff,
+ greatest,
+ groupArray,
+ groupUniqArray,
+ groupUniqArrayArrayIf,
+ groupUniqArrayIf,
+ ifElse,
+ ifNull,
+ isNull,
+ literal,
+ mapValue,
+ metadataMap,
+ multiIf,
+ notEmpty,
+ nullIf,
+ sumMap,
+ sumMapValuesWhereKeyContains,
+ traceSessionId,
+ uniq,
+ uniqIf,
+} from "../query-ast/extensions";
+import type { ClickHouseDatabase } from "../query-ast/schema";
+import type { SessionEventsField } from "../queries/clickhouse-sql/event-query-builder";
+
+type EventsDb = { e: ClickHouseDatabase["events_core"] };
+type EventsRow = ClickHouseDatabase["events_core"];
+type EventsColumn = keyof EventsRow & string;
+type StringColumn = {
+ [K in EventsColumn]: EventsRow[K] extends string ? K : never;
+}[EventsColumn];
+type EventsSelection = SelectExpression<EventsDb, "e">;
+
+const eb = expressionBuilder<EventsDb, "e">();
+
+const eventsMetadataMap = metadataMap(
+ eb.ref("e.metadata_names"),
+ eb.ref("e.metadata_values"),
+);
+
+const isRootObservation = eb.or([
+ eb("e.parent_span_id", "=", literal("")),
+ eb("e.is_app_root", "=", literal(true)),
+]);
+
+/**
+ * An event's trace name: the stored `trace_name`, else the name of a root
+ * observation, else NULL.
+ */
+export const eventsTraceName = eb.fn.coalesce(
+ nullIf(eb.ref("e.trace_name"), literal("")),
+ ifElse(
+ isRootObservation,
+ nullIf(eb.ref("e.name"), literal("")),
+ literal(null),
+ ),
+);
+
+/** The latest non-empty value of `column` across a trace's events. */
+const latestNonEmpty = (column: StringColumn) =>
+ argMaxIf(eb.ref(column), eb.ref("event_ts"), eb(column, "<>", literal("")));
+
+/** `column` of the trace's root observation. */
+const ofRootSpan = <C extends EventsColumn>(column: C) =>
+ argMaxIf(
+ eb.ref(column),
+ eb.ref("event_ts"),
+ eb("parent_span_id", "=", literal("")),
+ );
+
+const countLevel = (level: string) => countIf(eb("level", "=", literal(level)));
+
+/**
+ * One row per trace, aggregated from its events. Grouped by
+ * `trace_id, project_id`.
+ */
+export const TRACE_AGGREGATION_SELECTS = [
+ eb.ref("trace_id").as("id"),
+ "project_id",
+ eb.fn
+ .coalesce(
+ nullIf(
+ argMaxIf(
+ eb.ref("e.trace_name"),
+ eb.ref("e.event_ts"),
+ eb("e.trace_name", "<>", literal("")),
+ ),
+ literal(""),
+ ),
+ nullIf(
+ argMaxIf(
+ eb.ref("e.name"),
+ eb.ref("e.event_ts"),
+ eb.and([isRootObservation, eb("e.name", "<>", literal(""))]),
+ ),
+ literal(""),
+ ),
+ )
+ .as("name"),
+ eb.fn.min("start_time").as("timestamp"),
+ latestNonEmpty("environment").as("environment"),
+ latestNonEmpty("version").as("version"),
+ traceSessionId().as("session_id"),
+ latestNonEmpty("user_id").as("user_id"),
+ ofRootSpan("input").as("input"),
+ ofRootSpan("output").as("output"),
+ argMaxIf(
+ eventsMetadataMap,
+ eb.ref("event_ts"),
+ eb("parent_span_id", "=", literal("")),
+ ).as("metadata"),
+ eb.fn.min("created_at").as("created_at"),
+ eb.fn.max("updated_at").as("updated_at"),
+ eb.fn.sum("total_cost").as("total_cost"),
+ ifElse(
+ eb(eb.fn.max("end_time"), "is", null),
+ literal(null),
+ dateDiff(
+ "millisecond",
+ eb.fn.min("start_time"),
+ greatest(eb.fn.max("start_time"), eb.fn.max("end_time")),
+ ),
+ ).as("latency_milliseconds"),
+ groupUniqArrayIf(eb.ref("span_id"), eb("span_id", "<>", literal(""))).as(
+ "observation_ids",
+ ),
+ arrayLength(
+ groupUniqArrayIf(
+ eb.ref("span_id"),
+ eb.and([
+ eb("span_id", "<>", literal("")),
+ eb("span_id", "<>", concat(literal("t-"), eb.ref("trace_id"))),
+ ]),
+ ),
+ ).as("observation_count"),
+ ofRootSpan("bookmarked").as("bookmarked"),
+ eb.fn.max("public").as("public"),
+ latestNonEmpty("experiment_item_id").as("experiment_item_id"),
+ sumMap(eb.ref("usage_details")).as("usage_details"),
+ sumMap(eb.ref("cost_details")).as("cost_details"),
+ multiIf(
+ ["ERROR", "WARNING", "DEFAULT"].map(
+ (level) =>
+ [
+ arrayExists(
+ (x) => eb(x, "=", literal(level)),
+ groupArray(eb.ref("level")),
+ ),
+ literal(level),
+ ] as const,
+ ),
+ literal("DEBUG"),
+ ).as("aggregated_level"),
+ countLevel("WARNING").as("warning_count"),
+ countLevel("ERROR").as("error_count"),
+ countLevel("DEFAULT").as("default_count"),
+ countLevel("DEBUG").as("debug_count"),
+ argMaxIf(eb.ref("tags"), eb.ref("event_ts"), notEmpty(eb.ref("tags"))).as(
+ "tags",
+ ),
+ latestNonEmpty("release").as("release"),
+ latestNonEmpty("evaluator_id").as("evaluator_id"),
+ latestNonEmpty("evaluation_rule_id").as("evaluation_rule_id"),
+ anyValue(eb.ref("experiment_id")).as("experiment_id"),
+] satisfies EventsSelection[];
+
+/** Session-level aggregates over events, keyed by field. Grouped by `session_id`. */
+export const SESSION_AGGREGATION_SELECTS = {
+ session_id: "session_id",
+ max_timestamp: eb.fn.max("start_time").as("max_timestamp"),
+ min_timestamp: eb.fn.min("start_time").as("min_timestamp"),
+ trace_ids: groupUniqArray(eb.ref("trace_id")).as("trace_ids"),
+ user_ids: groupUniqArrayIf(
+ eb.ref("user_id"),
+ eb.and([eb("user_id", "is not", null), eb("user_id", "!=", literal(""))]),
+ ).as("user_ids"),
+ trace_count: uniq(eb.ref("trace_id")).as("trace_count"),
+ trace_tags: groupUniqArrayArrayIf(
+ eb.ref("tags"),
+ notEmpty(eb.ref("tags")),
+ ).as("trace_tags"),
+ environment: latestNonEmpty("environment").as("environment"),
+ total_observations: uniqIf(
+ eb.ref("span_id"),
+ eb("parent_span_id", "!=", literal("")),
+ ).as("total_observations"),
+ duration: dateDiff(
+ "second",
+ eb.fn.min("start_time"),
+ eb.fn.max(
+ ifElse(
+ isNull(eb.ref("end_time")),
+ eb.ref("start_time"),
+ eb.ref("end_time"),
+ ),
+ ),
+ ).as("duration"),
+ session_usage_details: sumMap(eb.ref("usage_details")).as(
+ "session_usage_details",
+ ),
+ session_cost_details: sumMap(eb.ref("cost_details")).as(
+ "session_cost_details",
+ ),
+ session_input_cost: sumMapValuesWhereKeyContains(
+ sumMap(eb.ref("cost_details")),
+ "input",
+ ).as("session_input_cost"),
+ session_output_cost: sumMapValuesWhereKeyContains(
+ sumMap(eb.ref("cost_details")),
+ "output",
+ ).as("session_output_cost"),
+ session_total_cost: mapValue(sumMap(eb.ref("cost_details")), "total").as(
+ "session_total_cost",
+ ),
+ session_input_usage: sumMapValuesWhereKeyContains(
+ sumMap(eb.ref("usage_details")),
+ "input",
+ ).as("session_input_usage"),
+ session_output_usage: sumMapValuesWhereKeyContains(
+ sumMap(eb.ref("usage_details")),
+ "output",
+ ).as("session_output_usage"),
+ session_total_usage: mapValue(sumMap(eb.ref("usage_details")), "total").as(
+ "session_total_usage",
+ ),
+} satisfies Record<SessionEventsField, EventsSelection>;
+
+/** One observation's fields, without input/output. */
+export const OBSERVATION_BY_ID_SELECTS = [
+ "e.span_id as id",
+ "e.trace_id as trace_id",
+ "e.project_id as project_id",
+ "e.environment as environment",
+ "e.type as type",
+ "e.parent_span_id as parent_observation_id",
+ "e.name as name",
+ "e.level as level",
+ "e.status_message as status_message",
+ "e.version as version",
+ "e.bookmarked as bookmarked",
+ "e.public as public",
+ "e.user_id as user_id",
+ "e.session_id as session_id",
+ // String-typed on purpose: '' when the event has no trace name.
+ ifNull(eventsTraceName, literal("")).as("trace_name"),
+ "e.start_time as start_time",
+ "e.end_time as end_time",
+ "e.completion_start_time as completion_start_time",
+ "e.created_at as created_at",
+ "e.updated_at as updated_at",
+ "e.event_ts",
+ "e.provided_model_name as provided_model_name",
+ "e.model_id as internal_model_id",
+ "e.model_parameters as model_parameters",
+ "e.provided_usage_details as provided_usage_details",
+ "e.usage_details as usage_details",
+ "e.provided_cost_details as provided_cost_details",
+ "e.cost_details as cost_details",
+ "e.total_cost as total_cost",
+ "e.prompt_id as prompt_id",
+ "e.prompt_name as prompt_name",
+ "e.prompt_version as prompt_version",
+ sql.ref<SkillsAvailable>("e.skills_available").as("skills_available"),
+ sql
+ .ref<SkillsResourceLoaded>("e.skills_resource_loaded")
+ .as("skills_resource_loaded"),
+ "e.tool_definitions as tool_definitions",
+ "e.tool_calls as tool_calls",
+ "e.tool_call_names as tool_call_names",
+ "e.usage_pricing_tier_id as usage_pricing_tier_id",
+ "e.usage_pricing_tier_name as usage_pricing_tier_name",
+ eventsMetadataMap.as("metadata"),
+ "e.tags as tags",
+ "e.release as release",
+] satisfies EventsSelection[];
diff --git a/packages/shared/src/server/repositories/events.golden.test.ts b/packages/shared/src/server/repositories/events.golden.test.ts
index 6a9e7e0a51..c83836402e 100644
--- a/packages/shared/src/server/repositories/events.golden.test.ts
+++ b/packages/shared/src/server/repositories/events.golden.test.ts
@@ -48,6 +48,7 @@ import {
streamObservationIOFieldFromEventsTable,
} from "./events";
import { getTraceBatchEventStream } from "./trace-batch";
+import { ALL_SESSION_EVENTS_FIELDS } from "../queries/clickhouse-sql/event-query-builder";
const FIXED_PROJECT_ID = "golden-project";
const FIXED_PROJECT_IDS = ["golden-project", "golden-project-b"] as const;
@@ -355,6 +356,15 @@ describeWithClickhouse("golden: events simple aggregates family", () => {
expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
});
+ it("getSessionMetricsFromEvents fields=all", async () => {
+ await getSessionMetricsFromEvents({
+ projectId: FIXED_PROJECT_ID,
+ sessionIds: FIXED_SESSION_IDS,
+ fields: ALL_SESSION_EVENTS_FIELDS,
+ });
+ expect(normalizeCapturedQueries(capturedQueries)).toMatchSnapshot();
+ });
+
it("getLatestSdkVersionInfoFromEvents", async () => {
vi.useFakeTimers({ toFake: ["Date"] });
vi.setSystemTime(FIXED_START_TIME);
diff --git a/packages/shared/src/server/repositories/events.ts b/packages/shared/src/server/repositories/events.ts
index e8de269d2e..ae3974d132 100644
--- a/packages/shared/src/server/repositories/events.ts
+++ b/packages/shared/src/server/repositories/events.ts
@@ -40,6 +40,7 @@ import {
includeDeleted,
leftUTF8,
limitBy,
+ literal,
mapValue,
medianExact,
metadataMap,
@@ -133,14 +134,17 @@ import {
ObservationTableQuery,
} from "./observations";
import { convertEventsObservation } from "./observations_converters";
+import {
+ eventsTraceName,
+ OBSERVATION_BY_ID_SELECTS,
+ SESSION_AGGREGATION_SELECTS,
+ TRACE_AGGREGATION_SELECTS,
+} from "./events-selects";
import {
EventsQueryBuilder,
CTEQueryBuilder,
EventsAggQueryBuilder,
buildEventsFullTableSplitQuery,
- EVENTS_AGGREGATION_FIELDS,
- EVENTS_SESSION_AGGREGATION_FIELDS,
- eventsFieldSetSelections,
type QueryWithParams,
normalizeSessionCounts,
type SessionEventsField,
@@ -163,7 +167,6 @@ import {
import { type EventsObservationPublic } from "../queries/createGenerationsQuery";
import {
eventsTableCols,
- eventsTableTraceNameSql,
normalizeEventsTraceName,
type NumericEventsTableColumnId,
} from "../../eventsTable";
@@ -674,16 +677,18 @@ export const getObservationMetricsForPromptsFromEvents = async (
"e.prompt_version as prompt_version",
eb.fn.min("e.start_time").as("first_observation"),
eb.fn.max("e.start_time").as("last_observation"),
- medianExact(sumMapValuesWhereKeyContains("e.usage_details", "input")).as(
- "median_input_usage",
- ),
- medianExact(sumMapValuesWhereKeyContains("e.usage_details", "output")).as(
- "median_output_usage",
- ),
- medianExact(mapValue("e.cost_details", "total")).as("median_total_cost"),
- medianExact(dateDiff("millisecond", "e.start_time", "e.end_time")).as(
- "median_latency_ms",
+ medianExact(
+ sumMapValuesWhereKeyContains(eb.ref("e.usage_details"), "input"),
+ ).as("median_input_usage"),
+ medianExact(
+ sumMapValuesWhereKeyContains(eb.ref("e.usage_details"), "output"),
+ ).as("median_output_usage"),
+ medianExact(mapValue(eb.ref("e.cost_details"), "total")).as(
+ "median_total_cost",
),
+ medianExact(
+ dateDiff("millisecond", eb.ref("e.start_time"), eb.ref("e.end_time")),
+ ).as("median_latency_ms"),
])
.where("e.is_deleted", "=", 0)
.groupBy(["e.prompt_id", "e.prompt_version"])
@@ -729,7 +734,7 @@ export const getObservationsWithPromptNameFromEvents = async (
) => {
const builder = getClickhouseKysely()
.selectFrom("events_core")
- .select([uniq("span_id").as("count"), "prompt_name"])
+ .select((eb) => [uniq(eb.ref("span_id")).as("count"), "prompt_name"])
.where("prompt_name", "in", promptNames)
.where("prompt_name", "!=", "")
.$if(fromTimestamp != null, (qb) =>
@@ -1101,15 +1106,7 @@ async function getObservationByIdFromEventsTableInternal({
: db.selectFrom("events_core as e")
)
.$call(includeDeleted())
- // Built per call: events.ts and the builder module import each other.
- .select(
- eventsFieldSetSelections(
- "byIdBase",
- "byIdModel",
- "byIdPrompt",
- "byIdTimestamps",
- ),
- )
+ .select(OBSERVATION_BY_ID_SELECTS)
.$if(fetchWithInputOutput, (qb) =>
qb.select(observationIoSelects(renderingProps.truncated)),
)
@@ -1197,7 +1194,7 @@ export const getTraceByIdFromEventsTable = async ({
: qb.selectFrom("events_full as e");
return from
.$call(includeDeleted())
- .select(traceAggregationSelects() as never)
+ .select(TRACE_AGGREGATION_SELECTS)
.where("trace_id", "in", [traceId])
.$if(fromTimestamp != null, (inner) =>
inner.where(
@@ -1207,12 +1204,12 @@ export const getTraceByIdFromEventsTable = async ({
),
)
.groupBy(["trace_id", "project_id"])
- .orderBy(sql`timestamp`, "desc");
+ .orderBy("timestamp", "desc");
};
const metadataSelect = excludeMetadata
? sql`map()`.as("metadata")
- : sql`t.metadata`;
+ : "t.metadata";
const builder = db
.with("traces", (qb) =>
@@ -1220,22 +1217,22 @@ export const getTraceByIdFromEventsTable = async ({
)
.selectFrom("traces as t")
.select([
- sql`t.id`,
- sql`t.name`,
- sql`t.user_id`,
- sql`t.release`,
- sql`t.version`,
- sql`t.project_id`,
- sql`t.environment`,
- sql`t.public`,
- sql`t.bookmarked`,
- sql`t.tags`,
- sql`t.session_id`,
- sql`t.timestamp`,
- sql`t.created_at`,
- sql`t.updated_at`,
+ "t.id",
+ "t.name",
+ "t.user_id",
+ "t.release",
+ "t.version",
+ "t.project_id",
+ "t.environment",
+ "t.public",
+ "t.bookmarked",
+ "t.tags",
+ "t.session_id",
+ "t.timestamp",
+ "t.created_at",
+ "t.updated_at",
metadataSelect,
- sql`0`.as("is_deleted"),
+ literal(0).as("is_deleted"),
...traceIoSelects(excludeInputOutput, truncated),
])
.$if(timestamp != null, (qb) =>
@@ -1272,12 +1269,6 @@ export const getTraceByIdFromEventsTable = async ({
return res.shift();
};
-export function traceAggregationSelects() {
- return Object.values(EVENTS_AGGREGATION_FIELDS).map((field) =>
- sql.raw(field),
- );
-}
-
/** Earliest start_time an observation of a trace anchored at `anchor` can have. */
function observationsToTraceLowerBound(anchor: Date): Date {
return new Date(
@@ -1286,8 +1277,14 @@ function observationsToTraceLowerBound(anchor: Date): Date {
);
}
-function traceIoSelects(excludeInputOutput: boolean, truncated: boolean) {
- if (excludeInputOutput) return [sql`''`.as("input"), sql`''`.as("output")];
+function traceIoSelects(
+ excludeInputOutput: boolean,
+ truncated: boolean,
+): ReadonlyArray<
+ "t.input" | "t.output" | AliasedExpression<unknown, "input" | "output">
+> {
+ if (excludeInputOutput)
+ return [literal("").as("input"), literal("").as("output")];
if (truncated) {
const charLimit = env.LANGFUSE_SERVER_SIDE_IO_CHAR_LIMIT;
return [
@@ -1295,7 +1292,7 @@ function traceIoSelects(excludeInputOutput: boolean, truncated: boolean) {
leftUTF8("t.output", charLimit).as("output"),
];
}
- return [sql`t.input`, sql`t.output`];
+ return ["t.input", "t.output"];
}
/**
@@ -3641,11 +3638,11 @@ export const getTraceMetadataByIdsFromEvents = async (props: {
.selectFrom("events_core as e")
.select([
"e.trace_id as id",
- sql.raw(eventsTableTraceNameSql).as("name"),
+ eventsTraceName.as("name"),
"e.user_id as user_id",
"e.tags as tags",
])
- .where(sql<SqlBool>`${sql.raw(eventsTableTraceNameSql)} IS NOT NULL`)
+ .where(eventsTraceName, "is not", null)
.where("e.trace_id", "in", props.traceIds)
.$call(limitBy({ count: 1, columns: ["e.trace_id"] }));
@@ -3906,11 +3903,7 @@ export const getSessionMetricsFromEvents = async <
const builder = getClickhouseKysely()
.selectFrom("events_core as e")
.$call(includeDeleted())
- .select(
- fields.map((field) =>
- sql.raw(EVENTS_SESSION_AGGREGATION_FIELDS[field]),
- ) as never,
- )
+ .select(fields.map((field) => SESSION_AGGREGATION_SELECTS[field]))
.where("session_id", "in", sessionIds)
.$if(queryFromTimestamp != null, (qb) =>
qb.where(
diff --git a/packages/shared/src/server/repositories/experiments.ts b/packages/shared/src/server/repositories/experiments.ts
index 253710c89c..cc9f35aacb 100644
--- a/packages/shared/src/server/repositories/experiments.ts
+++ b/packages/shared/src/server/repositories/experiments.ts
@@ -5,15 +5,10 @@ import { env } from "../../env";
import { type ScoreSourceType } from "../../domain";
import { type OrderByState } from "../../interfaces/orderBy";
import { type FilterState } from "../../types";
-import { sql } from "kysely";
import { convertDateToClickhouseDateTime } from "../clickhouse/client";
import { compileClickhouseQuery } from "../query-ast/compile";
import { getClickhouseKysely } from "../query-ast/dialect";
-import { includeDeleted } from "../query-ast/extensions";
-import {
- EXPERIMENTS_AGGREGATION_FIELDS,
- EXPERIMENTS_AGGREGATION_FIELD_SETS,
-} from "../queries/clickhouse-sql/event-query-builder";
+import { avgIf, dateDiff, includeDeleted } from "../query-ast/extensions";
import {
FilterList,
StringOptionsFilter,
@@ -366,12 +361,17 @@ export const getExperimentMetricsFromEvents = async (props: {
const builder = getClickhouseKysely()
.selectFrom("events_core as e")
.$call(includeDeleted())
- .select(
- // Same field map as the experiments table builder, so both stay in sync.
- EXPERIMENTS_AGGREGATION_FIELD_SETS.metrics.map((field) =>
- sql.raw(EXPERIMENTS_AGGREGATION_FIELDS[field]),
- ) as never,
- )
+ .select((eb) => [
+ "e.experiment_id as experiment_id",
+ eb.fn.sum("e.total_cost").as("total_cost"),
+ avgIf(
+ dateDiff("millisecond", eb.ref("e.start_time"), eb.ref("e.end_time")),
+ eb.and([
+ eb("e.span_id", "=", eb.ref("e.experiment_item_root_span_id")),
+ eb("e.end_time", "is not", null),
+ ]),
+ ).as("latency_avg"),
+ ])
.where("e.experiment_id", "in", experimentIds)
.where("e.experiment_id", "!=", "")
.groupBy(["e.project_id", "e.experiment_id"]);
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 6d5a11a752..17294d1223 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
@@ -13,7 +13,7 @@ exports[`golden: sessions simple aggregates family > getSessionTracesFromEvents
"sql": "SELECT
trace_id AS id,
project_id,
- COALESCE(
+ 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,
diff --git a/packages/shared/src/server/services/sessions-ui-table-events-service.ts b/packages/shared/src/server/services/sessions-ui-table-events-service.ts
index a1f165a7c9..3cf8fc3727 100644
--- a/packages/shared/src/server/services/sessions-ui-table-events-service.ts
+++ b/packages/shared/src/server/services/sessions-ui-table-events-service.ts
@@ -1,5 +1,4 @@
import { ClickHouseClientConfigOptions } from "@clickhouse/client";
-import { sql } from "kysely";
import { InvalidRequestError } from "../../errors";
import { OrderByState } from "../../interfaces/orderBy";
import { FilterState } from "../../types";
@@ -26,7 +25,7 @@ import {
eventsSessionScoresAggregation,
} from "../queries/clickhouse-sql/query-fragments";
import { queryClickhouse } from "../repositories";
-import { traceAggregationSelects } from "../repositories/events";
+import { TRACE_AGGREGATION_SELECTS } from "../repositories/events-selects";
import {
sessionEventsCols,
sessionEventsOrderByCols,
@@ -52,10 +51,10 @@ export const getSessionTracesFromEvents = async (props: {
const { projectId, sessionId } = props;
const builder = getClickhouseKysely()
.selectFrom("events_full as e")
- .select(traceAggregationSelects() as never)
+ .select(TRACE_AGGREGATION_SELECTS)
.where("e.session_id", "=", sessionId)
.groupBy(["trace_id", "project_id"])
- .orderBy(sql.ref("timestamp"), "asc");
+ .orderBy("timestamp", "asc");
const { sql: query, params } = compileClickhouseQuery(builder, projectId);
const rows = await queryClickhouse<{
diff --git a/web/src/__tests__/server/event-query-builder.servertest.ts b/web/src/__tests__/server/event-query-builder.servertest.ts
index 7898d1d588..170aa4c002 100644
--- a/web/src/__tests__/server/event-query-builder.servertest.ts
+++ b/web/src/__tests__/server/event-query-builder.servertest.ts
@@ -1030,7 +1030,7 @@ describe("EventsQueryBuilder", () => {
expect(query).toContain("FROM events_full e");
});
- it("should include pricing tier fields in observation list, detail, usage, and export field sets", () => {
+ it("should include pricing tier fields in observation list, usage, and export field sets", () => {
const buildQuery = (
...fieldSets: Parameters<EventsQueryBuilder["selectFieldSet"]>
) =>
@@ -1042,25 +1042,17 @@ describe("EventsQueryBuilder", () => {
const listQuery = buildQuery("base", "calculated");
const slimListQuery = buildQuery("baseWithoutTools", "calculated");
- const byIdQuery = buildQuery(
- "byIdBase",
- "byIdModel",
- "byIdPrompt",
- "byIdTimestamps",
- );
const usageQuery = buildQuery("core", "usage");
const exportQuery = buildQuery("export");
- [listQuery, slimListQuery, byIdQuery, usageQuery, exportQuery].forEach(
- (query) => {
- expect(query).toContain(
- "e.usage_pricing_tier_id as usage_pricing_tier_id",
- );
- expect(query).toContain(
- "e.usage_pricing_tier_name as usage_pricing_tier_name",
- );
- },
- );
+ [listQuery, slimListQuery, usageQuery, exportQuery].forEach((query) => {
+ expect(query).toContain(
+ "e.usage_pricing_tier_id as usage_pricing_tier_id",
+ );
+ expect(query).toContain(
+ "e.usage_pricing_tier_name as usage_pricing_tier_name",
+ );
+ });
});
it("should include experiment item metadata in eval field set", () => {