🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
refactor(query-ast): 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.tsindex 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_FIELDSdiff --git a/packages/shared/src/server/query-ast/README.md b/packages/shared/src/server/query-ast/README.mdindex 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 ofhand-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-tablededup 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 servertimezone. Use `toDate` / `toStartOfMinute` from `extensions.ts` fordate-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 buildermethods, so they compose inside CTEs, subqueries, and views. See the recipesbelow.@@ -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 Kyselydiff --git a/packages/shared/src/server/query-ast/extensions.test.ts b/packages/shared/src/server/query-ast/extensions.test.tsindex 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.tsindex 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.snapindex 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 > getObservationByIdFromEe.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 > getObservationByIdFromEe.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 > getObservationByIdFromEe.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 > getObservationByIdFromEe.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 > getTraceByIdFromEventsTSELECTtrace_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 > getTraceByIdFromEventsTSELECTtrace_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 > getTraceByIdFromEventsTSELECTtrace_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 @@ SELECTt.input,t.outputFROM traces AS t-WHERE toDate(t.timestamp) = toDate({param4:DateTime64(3)})+WHERE toDate(t.timestamp) = toDate({param4:DateTime64(6)})ORDER BY t.timestamp DESCLIMIT {param5:Int64}",},@@ -1423,7 +1423,7 @@ exports[`golden: events point-reads & existence family > getTraceByIdFromEventsTSELECTtrace_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": "SELECTe.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 tagsFROM 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.snapindex 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": "SELECTe.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.tsnew file mode 100644index 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.tsindex 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.tsindex 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.tsindex 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.snapindex 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": "SELECTtrace_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.tsindex 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.tsindex 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", () => {